OneApplyCal.h

Go to the documentation of this file.

// OneApplyCal.h: DP3 step class to apply a calibration correction to the data
// Copyright (C) 2020 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
 
#ifndef DP3_STEPS_ONEAPPLYCAL_H_
#define DP3_STEPS_ONEAPPLYCAL_H_
 
#include <mutex>
 
#include <casacore/casa/Arrays/Cube.h>
#include <casacore/casa/Arrays/ArrayMath.h>
#include <schaapcommon/h5parm/h5parm.h>
#include <schaapcommon/h5parm/jonesparameters.h>
 
#include "Step.h"
#include "base/DPBuffer.h"
#include "base/FlagCounter.h"
#include "common/Timer.h"
#include "parmdb/ParmFacade.h"
#include "parmdb/ParmSet.h"
#include "parmdb/Parm.h"
 
namespace dp3 {
namespace steps {
 
 
class OneApplyCal : public Step {
 public:
  OneApplyCal(const common::ParameterSet&, const std::string& prefix,
              const std::string& defaultPrefix, bool substep = false,
              std::string predictDirection = "");
 
  ~OneApplyCal() override;
 
  common::Fields getRequiredFields() const override {
    return kDataField | kWeightsField | kFlagsField;
  }
 
  common::Fields getProvidedFields() const override {
    common::Fields fields = kDataField | kFlagsField;
    if (itsUpdateWeights) fields |= kWeightsField;
    return fields;
  }
 
  bool process(std::unique_ptr<base::DPBuffer> buffer) override;
 
  void finish() override;
 
  void updateInfo(const base::DPInfo&) override;
 
  void show(std::ostream&) const override;
 
  void showTimings(std::ostream&, double duration) const override;
 
  bool invert() { return itsInvert; }
 
 private:
  void updateParmsParmDB(const double bufStartTime);
 
  void updateParmsH5(const double bufStartTime, hsize_t direction_index,
                     const std::string& direction_name,
                     const std::vector<double>& times);
 
  void showCounts(std::ostream&) const override;
 
  void initDataArrays();
 
  unsigned int nPol(schaapcommon::h5parm::SolTab& solution_table);
 
  // Check the number of polarizations in the parmdb
  unsigned int nPol(const std::string& parmName);
 
  std::vector<double> CalculateBufferTimes(double buffer_start_time,
                                           bool use_end);
 
  void MakeSolutionTables(schaapcommon::h5parm::H5Parm& h5parm);
 
  std::string getDirectionPatch(const std::string& direction_name);
 
  void CorrectionLoop(dp3::base::DPBuffer& buffer,
                      const std::string& direction_name);
 
  void CheckParmDB();
 
  std::string itsName;
  std::string itsParmDBName;
  // itsParmDBOnDisk specifies the existence of a parmdb on disk. If this is
  // false, it means the solutions are instead stored in the DPBuffer, which can
  // be fetched with DPBuffer::GetSolutions.
  bool itsParmDBOnDisk;
  bool itsUseH5Parm;
  std::string itsSolSetName;
  std::shared_ptr<parmdb::ParmFacade> itsParmDB;
  std::string specified_correction_;
  size_t n_polarizations_in_sol_tab_ = 0;
  schaapcommon::h5parm::JonesParameters::MissingAntennaBehavior
      itsMissingAntennaBehavior;
  schaapcommon::h5parm::GainType itsCorrectType;
  bool itsInvert;
  schaapcommon::h5parm::JonesParameters::InterpolationType itsInterpolationType;
  unsigned int itsTimeSlotsPerParmUpdate;
  bool itsUpdateWeights;
  bool itsUseModelData;
 
  unsigned int itsCount;  
 
  std::vector<casacore::String> itsParmExprs;
 
  std::map<std::string, std::unique_ptr<schaapcommon::h5parm::JonesParameters>>
      itsJonesParametersPerDirection;
 
  unsigned int itsTimeStep;  
  unsigned int itsNCorr;
  double itsLastTime;  
  base::FlagCounter itsFlagCounter;
  bool itsUseAP;  
  hsize_t itsDirection;
  common::NSTimer itsTimer;
  std::vector<std::string> solution_table_names_;
 
  // This variable keeps the H5 contents in memory, reading
  // the H5 file only once in the constructor. These solutions
  // are used in the constructor, process(..) and methods
  // called from process(..).
  std::vector<schaapcommon::h5parm::SolTab> solution_tables_;
 
  static std::mutex theirHDF5Mutex;  
};
 
}  // namespace steps
}  // namespace dp3
 
#endif