MsReader.h

Go to the documentation of this file.

// Copyright (C) 2022 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
 
#ifndef DP3_STEPS_MSREADER_H_
#define DP3_STEPS_MSREADER_H_
 
#include <casacore/casa/Arrays/Slicer.h>
#include <casacore/ms/MeasurementSets/MeasurementSet.h>
#include <casacore/tables/Tables/TableIter.h>
 
#include "base/DPBuffer.h"
 
#include "InputStep.h"
 
#include "base/UVWCalculator.h"
#include "base/FlagCounter.h"
 
namespace dp3 {
namespace steps {
 
 
class MsReader : public InputStep {
 public:
  MsReader(const casacore::MeasurementSet& ms,
           const common::ParameterSet& parset, const std::string& prefix,
           bool allow_missing_data = false);
 
  bool process(std::unique_ptr<base::DPBuffer> buffer) override;
 
  void finish() override;
 
  void updateInfo(const base::DPInfo&) override {}
 
  void addToMS(const std::string&) override{};
 
  void show(std::ostream&) const override;
 
  void showCounts(std::ostream&) const override;
 
  void showTimings(std::ostream&, double duration) const override;
 
  void getUVW(const casacore::RefRows& rowNrs, double time, base::DPBuffer&);
 
  const casacore::Table& table() const override { return ms_; }
 
  std::string msName() const override;
 
  const std::string& BaselineSelection() const { return baseline_selection_; }
 
  bool MissingData() const { return missing_data_; }
 
  const std::vector<std::string>& ExtraDataColumnNames() const {
    return extra_data_column_names_;
  }
 
  bool AutoWeight() const { return auto_weight_; }
 
  static void FlagInfinityNan(base::DPBuffer& buffer,
                              base::FlagCounter& flagCounter);
 
  static std::pair<unsigned int, unsigned int> ParseChannelSelection(
      const std::string& start_channel_string,
      const std::string& n_channels_string, unsigned int n_channels);
 
 private:
  void SelectBaselines();
 
  void InitializeColumns(bool allow_missing_data,
                         const std::string& data_column_name,
                         const std::string& flag_column_name,
                         const std::string& weight_column_name);
 
  void InitializeIterator(bool force_auto_weight);
 
  void ReadAntennas(const casacore::Table& table);
 
  void ReadArrayInformation();
 
  void ParseTimeSelection(const common::ParameterSet& parset,
                          const std::string& prefix);
 
  void SkipFirstTimes(double& first_time, double interval);
 
  void InitializeChannels(int spectralWindow);
 
  void ReadChannelProperties(int spectralWindow);
 
  void ReadPolarizations(int spectralWindow);
 
  void AutoWeight(base::DPBuffer& buf);
 
  void GetWeights(const casacore::RefRows& rowNrs, base::DPBuffer&);
 
  casacore::MeasurementSet ms_;
  casacore::Table selection_ms_;  
  casacore::TableIterator ms_iterator_;
  std::vector<std::string> extra_data_column_names_;
  std::string start_channel_expression_{"0"};
  std::string n_channels_expression_{"0"};
  std::string baseline_selection_{};
  bool sort_{false};         
  bool auto_weight_{false};  
  bool has_weight_spectrum_{false};
  bool use_flags_{true};
  bool use_all_channels_{false};  
  bool missing_data_{false};      
  double time_tolerance_{1.0e-2};
  double time_correction_{0.0};
  double next_time_{0.0};      
  double previous_time_{0.0};  
  unsigned int n_read_{0};     
  unsigned int n_inserted_{0};      
  casacore::Slicer column_slicer_;  
  casacore::Slicer array_slicer_;   
  std::unique_ptr<base::UVWCalculator> uvw_calculator_;
  base::FlagCounter flag_counter_;
  common::NSTimer timer_;
};
 
}  // namespace steps
}  // namespace dp3
 
#endif