PreFlagger.h

Go to the documentation of this file.

// PreFlagger.h: DP3 step class to flag data on channel, baseline, or time
// Copyright (C) 2023 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
 
#ifndef DP3_STEPS_PREFLAGGER_H_
#define DP3_STEPS_PREFLAGGER_H_
 
#include <casacore/measures/Measures/MDirection.h>
 
#include <xtensor/containers/xtensor.hpp>
 
#include "base/DPBuffer.h"
#include "steps/Step.h"
 
#include "base/BaselineSelection.h"
#include "base/FlagCounter.h"
#include "common/ParameterSet.h"
#include "common/Timer.h"
 
namespace dp3::steps {
 
 
 
class PreFlagger : public Step {
  friend class TestPSet;
 
 public:
  enum class Mode { kSetFlag, kClearFlag, kSetComp, kClearComp };
 
  PreFlagger(const common::ParameterSet&, const std::string& prefix);
 
  ~PreFlagger() override;
 
  common::Fields getRequiredFields() const override {
    common::Fields fields = kFlagsField;
    if (itsMode == Mode::kClearFlag || itsMode == Mode::kClearComp) {
      fields |= kDataField | kWeightsField;
    }
    return fields |= itsPSet.getRequiredFields();
  }
 
  common::Fields getProvidedFields() const override { return kFlagsField; }
 
  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 showCounts(std::ostream&) const override;
 
  void showTimings(std::ostream&, double duration) const override;
 
 private:
  class PSet {
    friend class TestPSet;
 
   public:
    enum Oper { OpParen = -1, OpOr = -2, OpAnd = -3, OpNot = -4 };
 
    typedef std::shared_ptr<PSet> ShPtr;
 
    PSet() {}
 
    PSet(const common::ParameterSet& parset, const std::string& prefix);
 
    common::Fields getRequiredFields() const {
      common::Fields fields;
      if (itsFlagOnAmpl || itsFlagOnPhase || itsFlagOnReal || itsFlagOnImag) {
        fields |= kDataField;
      }
      if (itsFlagOnUV) {
        fields |= kUvwField;
      }
      for (const std::shared_ptr<PSet>& sub_pset : itsPSets) {
        fields |= sub_pset->getRequiredFields();
      }
      return fields;
    }
 
    xt::xtensor<uint8_t, 2>* process(base::DPBuffer&, unsigned int timeSlot,
                                     const xt::xtensor<bool, 1>& matchBL,
                                     common::NSTimer& timer);
 
    void updateInfo(const base::DPInfo&);
 
    void show(std::ostream&, bool showName) const;
 
   private:
    bool matchTime(double time, unsigned int timeSlot) const;
 
    bool matchRange(double v, const std::vector<double>& ranges) const;
 
    bool flagBL();
 
    bool flagUV(const base::DPBuffer::UvwType& uvw);
 
    bool flagAzEl(double time);
 
    void testAzEl(casacore::MDirection::Convert& converter, unsigned int blnr,
                  int ant, const std::vector<int>& ant1,
                  const std::vector<int>& ant2);
 
    void flagAmpl(const base::DPBuffer::DataType& data);
 
    void flagPhase(const base::DPBuffer::DataType& data);
 
    void flagReal(const base::DPBuffer::DataType& data);
    void flagImag(const base::DPBuffer::DataType& data);
 
    void flagChannels();
 
    std::vector<double> fillTimes(const std::vector<std::string>& str,
                                  bool asTime, bool canEndBeforeStart);
 
    double getSeconds(const std::string& str, bool asTime, bool usepm);
 
    void fillBLMatrix();
 
    void fillChannels(const base::DPInfo&);
 
    std::vector<float> fillValuePerCorr(const common::ParameterValue& value,
                                        float defVal, bool& doFlag);
 
    xt::xtensor<int, 1> handleFreqRanges(const std::vector<double>& chanFreqs);
 
    void getValue(const std::string& str, double& value,
                  casacore::String& unit);
 
    double getFreqHz(double value, const casacore::String& unit);
 
    std::vector<std::string> exprToRpn(const std::string& expr);
 
    const base::DPInfo* itsInfo;
    std::string itsName;
    std::string itsStrExpr;
    bool itsFlagOnTimeOnly;  
    bool itsFlagOnTime;      
    bool itsFlagOnUV;        
    bool itsFlagOnBL;        
    bool itsFlagOnAmpl;      
    bool itsFlagOnPhase;     
    bool itsFlagOnReal;      
    bool itsFlagOnImag;      
    bool itsFlagOnAzEl;      
    base::BaselineSelection itsSelBL;
    double itsMinUV;                   
    double itsMaxUV;                   
    casacore::Matrix<bool> itsFlagBL;  
    std::vector<double> itsAzimuth;    
    std::vector<double> itsElevation;  
    std::vector<double> itsTimes;      
    std::vector<double> itsLST;        
    std::vector<double> itsATimes;     
    std::vector<double> itsRTimes;     
    std::vector<unsigned int> itsTimeSlot;  
    std::vector<float> itsAmplMin;          
    std::vector<float> itsAmplMax;          
    std::vector<float> itsPhaseMin;         
    std::vector<float> itsPhaseMax;         
    std::vector<float> itsRealMin;          
    std::vector<float> itsRealMax;          
    std::vector<float> itsImagMin;          
    std::vector<float> itsImagMax;          
    std::vector<unsigned int> itsChannels;  
    std::vector<std::string> itsStrChan;    
    std::vector<std::string> itsStrFreq;    
    std::vector<std::string> itsStrTime;    
    std::vector<std::string> itsStrLST;     
    std::vector<std::string>
        itsStrATime;  
    std::vector<std::string>
        itsStrRTime;  
    std::vector<std::string> itsStrAzim;  
    std::vector<std::string> itsStrElev;  
    std::vector<int> itsRpn;              
    std::vector<PSet::ShPtr> itsPSets;    
    xt::xtensor<bool, 1> itsChanFlags;    
    // Using 'uint8_t' instead of 'bool' in itsFlags works better with XSimd,
    // since XSimd uses an integer representation anyway for boolean operations.
    xt::xtensor<uint8_t, 2> itsFlags;
    xt::xtensor<bool, 1> itsMatchBL;  
  };
 
  void setFlags(const xt::xtensor<uint8_t, 2>& in,
                base::DPBuffer::FlagsType& out, bool mode);
 
  void clearFlags(const xt::xtensor<uint8_t, 2>& in,
                  base::DPBuffer::FlagsType& out, bool mode,
                  const base::DPBuffer::DataType& data,
                  const base::DPBuffer::WeightsType& weights);
 
  std::string itsName;
  Mode itsMode;
  common::NSTimer itsTimer;
  PSet itsPSet;
  unsigned int itsCount;
  base::FlagCounter itsFlagCounter;
};
 
}  // namespace dp3::steps
 
#endif