GainCal.h

Go to the documentation of this file.

// GainCal.h: DP3 step class to calibrate (direction independent) gains
// Copyright (C) 2022 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
 
#ifndef DP3_STEPS_GAINCAL_H_
#define DP3_STEPS_GAINCAL_H_
 
#include <complex>
#include <vector>
 
#include <xtensor/containers/xtensor.hpp>
 
#include <schaapcommon/h5parm/h5parm.h>
 
#define H5Acreate_vers 2
#define H5Tarray_create_vers 2
#define H5Dcreate_vers 2
#define H5Gcreate_vers 2
#include <H5Cpp.h>
 
#include "base/BaselineSelection.h"
#include "base/CalType.h"
#include "base/GainCalAlgorithm.h"
#include "base/PhaseFitter.h"
#include "common/ParameterSet.h"
#include "parmdb/ParmDB.h"
 
#include "InputStep.h"
#include "Predict.h"
#include "ResultStep.h"
#include "UVWFlagger.h"
 
namespace dp3 {
namespace steps {
 
class GainCal final : public Step {
 public:
  GainCal(const common::ParameterSet& parset, const std::string& prefix);
 
  common::Fields getRequiredFields() const override {
    return kDataField | kFlagsField | kWeightsField |
           itsUVWFlagStep.getRequiredFields() | itsSubRequiredFields;
  }
 
  common::Fields getProvidedFields() const override {
    common::Fields fields;
    if (itsApplySolution) fields |= kDataField | kFlagsField;
    return fields;
  }
 
  bool process(std::unique_ptr<base::DPBuffer>) override;
 
  void finish() override;
 
  void updateInfo(const base::DPInfo&) override;
 
  void show(std::ostream&) const override;
 
  void showTimings(std::ostream&, double duration) const override;
 
  static std::vector<schaapcommon::h5parm::SolTab> makeSolTab(
      schaapcommon::h5parm::H5Parm& h5parm, base::CalType caltype,
      std::vector<schaapcommon::h5parm::AxisInfo>& axes);
 
 private:
  void calibrate();
 
  static bool scalarMode(base::CalType caltype);
 
  static bool diagonalMode(base::CalType caltype);
 
  void applySolution(base::DPBuffer& buf,
                     const xt::xtensor<std::complex<float>, 3>& invsol);
 
  xt::xtensor<std::complex<float>, 3> invertSol(
      const xt::xtensor<std::complex<float>, 3>& sol);
 
  void fillMatrices(const base::DPBuffer::DataType& model,
                    const base::DPBuffer::DataType& data,
                    const base::DPBuffer::WeightsType& weights,
                    const base::DPBuffer::FlagsType& flags);
 
  void initParmDB();
 
  std::string parmName();
 
  void setAntennaUsed();
 
  void writeSolutionsParmDB(double startTime);
 
  void writeSolutionsH5Parm(double startTime);
 
  std::string itsName;
  std::vector<std::unique_ptr<base::DPBuffer>> itsBuffers;
  bool itsUseModelColumn;
  std::string itsModelColumnName;
  std::string itsParmDBName;
  bool itsUseH5Parm;
  std::shared_ptr<parmdb::ParmDB> itsParmDB;
  std::string itsParsetString;  
 
  base::CalType itsMode;
 
  unsigned int itsDebugLevel;
  bool itsDetectStalling;
 
  bool itsApplySolution;
 
  std::vector<xt::xtensor<std::complex<float>, 3>> itsSols;
  std::vector<xt::xtensor<double, 2>> itsTECSols;
  std::vector<double> itsFreqData;  
 
  std::vector<std::unique_ptr<PhaseFitter>> itsPhaseFitters;  
 
  std::vector<base::GainCalAlgorithm> algorithms_;
 
  UVWFlagger itsUVWFlagStep;
  std::shared_ptr<ResultStep>
      itsDataResultStep;  
 
  std::shared_ptr<Step> itsFirstSubStep;
  std::shared_ptr<ResultStep> itsResultStep;
  common::Fields itsSubRequiredFields;
  bool itsApplyBeamToModelColumn;
 
  base::BaselineSelection itsBaselineSelection;  
  casacore::Vector<bool> itsSelectedBL;   
  casacore::Vector<bool> itsAntennaUsed;  
 
  std::map<std::string, int> itsParmIdMap;  
 
  unsigned int itsMaxIter;
  double itsTolerance;
  bool itsPropagateSolutions;
  unsigned int itsSolInt;  
  unsigned int itsNChan;   
  unsigned int itsNFreqCells;
 
  unsigned int itsTimeSlotsPerParmUpdate;
  unsigned int itsConverged;
  unsigned int itsNonconverged;
  unsigned int itsFailed;
  unsigned int itsStalled;
  std::vector<unsigned int>
      itsNIter;  
  unsigned int itsStepInParmUpdate;  
  double itsChunkStartTime;          
  unsigned int itsStepInSolInt;      
 
  xt::xtensor<std::complex<double>, 6> itsAllSolutions;
 
  base::FlagCounter itsFlagCounter;
 
  std::string itsModelDataName;
 
  common::NSTimer itsTimer;
  common::NSTimer itsTimerPredict;
  common::NSTimer itsTimerSolve;
  common::NSTimer itsTimerPhaseFit;
  common::NSTimer itsTimerWrite;
  common::NSTimer itsTimerFill;
};
 
}  // namespace steps
}  // namespace dp3
 
#endif