UVWFlagger.h

Go to the documentation of this file.

// UVWFlagger.h: DP3 step class to flag data on UVW coordinates
// Copyright (C) 2023 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
 
#ifndef DP3_STEPS_UVWFLAGGER_H_
#define DP3_STEPS_UVWFLAGGER_H_
 
#include "base/BdaBuffer.h"
#include "base/DPBuffer.h"
#include "base/UVWCalculator.h"
 
#include "InputStep.h"
 
namespace dp3 {
namespace common {
class ParameterSet;
class ParameterValue;
}  // namespace common
 
namespace steps {
 
 
class UVWFlagger : public Step {
 public:
  UVWFlagger(const common::ParameterSet&, const std::string& prefix,
             MsType inputType);
 
  ~UVWFlagger() override;
 
  common::Fields getRequiredFields() const override {
    if (itsIsDegenerate) return common::Fields();
 
    common::Fields fields = kFlagsField;
 
    if (itsCenter.empty()) fields |= kUvwField;
 
    return fields;
  }
 
  common::Fields getProvidedFields() const override {
    return itsIsDegenerate ? common::Fields() : kFlagsField;
  }
 
  bool process(std::unique_ptr<base::DPBuffer>) override;
 
  bool process(std::unique_ptr<base::BdaBuffer>) 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;
 
  bool accepts(MsType dt) const override { return dt == itsInputType; }
 
  MsType outputs() const override { return itsInputType; }
 
  bool isDegenerate() const { return itsIsDegenerate; }
 
 private:
  bool testUVWm(double uvw, const std::vector<double>& ranges);
 
  void testUVWl(double uvw, const std::vector<double>& ranges, bool* flagPtr,
                unsigned int nrcorr, unsigned int baseline_id);
 
  // Apply UVW flagging
  void doFlag(const std::array<double, 3>& uvw, bool* flagPtr,
              unsigned int n_correlations, unsigned int n_channels,
              unsigned int baseline_id = 0);
 
  std::vector<double> fillUVW(const common::ParameterSet& parset,
                              const std::string& prefix,
                              const std::string& name, bool square);
 
  void handleCenter();
 
  const MsType itsInputType;
  std::string itsName;
  unsigned int itsNTimes;
 
  std::vector<std::vector<double>> itsRecWavel;  
  const std::vector<double> itsRangeUVm;  
  const std::vector<double> itsRangeUm;   
  const std::vector<double> itsRangeVm;   
  const std::vector<double> itsRangeWm;   
  const std::vector<double>
      itsRangeUVl;                       
  const std::vector<double> itsRangeUl;  
  const std::vector<double> itsRangeVl;  
  const std::vector<double> itsRangeWl;  
 
  const bool itsIsDegenerate;
 
  std::unique_ptr<base::UVWCalculator> itsUVWCalc;
  const std::vector<std::string> itsCenter;
  common::NSTimer itsTimer;
  common::NSTimer itsUVWTimer;
  base::FlagCounter itsFlagCounter;
};
 
}  // namespace steps
}  // namespace dp3
 
#endif