Demixer.h

Go to the documentation of this file.

// Demixer.h: DP3 step class to subtract A-team sources
// Copyright (C) 2023 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef DP3_STEPS_DEMIXER_H_
#define DP3_STEPS_DEMIXER_H_
 
#include <casacore/measures/Measures/MeasFrame.h>
 
#include "Filter.h"
#include "ResultStep.h"
#include "MultiResultStep.h"
#include "PhaseShift.h"
 
#include "base/Baseline.h"
#include "base/FlagCounter.h"
 
#include "common/ParameterSet.h"
#include "common/Timer.h"
 
#include "model/Patch.h"
 
namespace dp3 {
namespace steps {
 
 
class Demixer : public Step {
 public:
  Demixer(const common::ParameterSet&, const std::string& prefix);
 
  bool process(std::unique_ptr<base::DPBuffer>) override;
 
  common::Fields getRequiredFields() const override;
 
  common::Fields getProvidedFields() const override;
 
  void finish() override;
 
  void updateInfo(const base::DPInfo&) override;
 
  void show(std::ostream&) const override;
 
  void showCounts(std::ostream&) const override;
 
  void showTimings(std::ostream&, double duration) const override;
 
  void addToMS(const std::string& msName) override;
 
 private:
  void addFactors(std::unique_ptr<base::DPBuffer> newBuf);
 
  void makeFactors(const aocommon::xt::UTensor<std::complex<double>, 4>& bufIn,
                   aocommon::xt::UTensor<std::complex<double>, 5>& bufOut,
                   const base::DPBuffer::WeightsType& weightSums,
                   size_t nChanOut, size_t nChanAvg);
 
  void handleDemix();
 
  void deproject(aocommon::xt::UTensor<std::complex<double>, 5>& factors,
                 unsigned int resultIndex);
 
  void demix();
 
  void dumpSolutions();
 
  void mergeSubtractResult();
 
  std::string itsName;
  base::DPBuffer itsBufTmp;
  std::string itsSkyName;
  std::string itsInstrumentName;
  double itsDefaultGain;
  size_t itsMaxIter;
  base::BaselineSelection itsSelBL;
  std::shared_ptr<Filter> itsFilter;
  std::shared_ptr<ResultStep> itsFilterResult;
  std::vector<std::shared_ptr<PhaseShift>> itsPhaseShifts;
  bool itsMovingPhaseRef;
  casacore::MeasFrame itsMeasFrame;
  std::vector<std::shared_ptr<Step>> itsFirstSteps;
  std::vector<std::shared_ptr<MultiResultStep>> itsAvgResults;
  std::shared_ptr<Step> itsAvgStepSubtr;
  std::shared_ptr<Filter> itsFilterSubtr;
  std::shared_ptr<MultiResultStep> itsAvgResultFull;
  std::shared_ptr<MultiResultStep> itsAvgResultSubtr;
  bool itsIgnoreTarget;
  std::string itsTargetSource;
  std::vector<std::string> itsSubtrSources;
  std::vector<std::string> itsModelSources;
  std::vector<std::string> itsExtraSources;
  std::vector<std::string> itsAllSources;
  bool itsPropagateSolutions;
  unsigned int itsNBl;
  unsigned int itsNChanAvg;
  unsigned int itsNChanAvgSubtr;
  unsigned int itsNChanIn;
  unsigned int itsNChanOut;
  unsigned int itsNChanOutSubtr;
  unsigned int itsNCorr;
  unsigned int itsNDir;
  unsigned int itsNModel;
  unsigned int itsNStation;
  unsigned int itsNTimeAvg;
  unsigned int itsNTimeAvgSubtr;
  unsigned int itsNTimeChunk;
  unsigned int itsNTimeChunkSubtr;
  unsigned int itsNTimeDemix;
  unsigned int itsNTimeIn;
  unsigned int itsNTimeOut;
  unsigned int itsNTimeOutSubtr;
  double itsFreqResolution;
  double itsTimeResolution;
  double itsTimeIntervalAvg;
 
  bool itsUseLBFGS;  
  unsigned int
      itsLBFGShistory;       
  double itsLBFGSrobustdof;  
  std::vector<double>
      itsRangeLBFGSsol;  
                         //< (if given) as [low,high], to this range.
 
  aocommon::xt::UTensor<std::complex<double>, 4> itsFactorBuf;
  std::vector<aocommon::xt::UTensor<std::complex<double>, 5>> itsFactors;
 
  aocommon::xt::UTensor<std::complex<double>, 4> itsFactorBufSubtr;
  std::vector<aocommon::xt::UTensor<std::complex<double>, 5>> itsFactorsSubtr;
 
  std::vector<std::shared_ptr<model::Patch>> itsPatchList;
  base::Direction itsPhaseRef;
  std::vector<base::Baseline> itsBaselines;
  std::vector<int> itsUVWSplitIndex;
  std::vector<double> itsFreqDemix;
  std::vector<double> itsFreqSubtr;
  std::vector<double> itsUnknowns;
  std::vector<double> itsPrevSolution;
  unsigned int itsTimeIndex;
  unsigned int itsNConverged;
  base::FlagCounter itsFlagCounter;
  // Store ratio of variance, before/after demixing
  float itsVarianceRatio{0.0f};
  unsigned int itsTotalDemixRuns{0};
 
  common::NSTimer itsTimer;
  common::NSTimer itsTimerPhaseShift;
  common::NSTimer itsTimerDemix;
  common::NSTimer itsTimerSolve;
  common::NSTimer itsTimerDump;
};
 
}  // namespace steps
}  // namespace dp3
 
#endif