DPInfo.h

Go to the documentation of this file.

// DPInfo.h: General info about DP3 data processing attributes like averaging
// Copyright (C) 2023 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
 
#ifndef DP3_BASE_DPINFO_H_
#define DP3_BASE_DPINFO_H_
 
#include <set>
 
#include <aocommon/polarization.h>
 
#include <casacore/measures/Measures/MDirection.h>
#include <casacore/measures/Measures/MPosition.h>
#include <casacore/measures/Measures/MeasureHolder.h>
#include <casacore/casa/Arrays/Vector.h>
#include <casacore/casa/Containers/Record.h>
 
#include "Direction.h"
 
namespace dp3 {
namespace base {
 
 
 
class DPInfo {
 public:
  explicit DPInfo(unsigned int n_correlations = 0,
                  unsigned int n_original_channels = 0,
                  std::string antenna_set = std::string());
 
  void setTimes(double first_time, double last_time, double time_interval);
 
  void setMsName(const std::string& ms_name) { ms_name_ = ms_name; }
 
  void setMsNames(const std::string& ms_name,
                  const std::string& data_column_name,
                  const std::string& flag_column_name,
                  const std::string& weight_column_name);
 
  void setIsBDAIntervalFactorInteger(bool isIntervalInteger) {
    bda_interval_factor_is_integer_ = isIntervalInteger;
  }
 
  void setTimeIntervalAndSteps(double timeInterval, unsigned int ntime) {
    time_interval_ = timeInterval;
    n_times_ = ntime;
  }
 
  void setChannels(std::vector<double>&& chanFreqs,
                   std::vector<double>&& chanWidths,
                   std::vector<double>&& resolutions = std::vector<double>(),
                   std::vector<double>&& effectiveBW = std::vector<double>(),
                   double refFreq = 0, int spectralWindow = 0);
 
  //         in Hz. If omitted/empty, channel widths are used.
  void setChannels(std::vector<std::vector<double>>&& chanFreqs,
                   std::vector<std::vector<double>>&& chanWidths,
                   std::vector<std::vector<double>>&& resolutions =
                       std::vector<std::vector<double>>(),
                   std::vector<std::vector<double>>&& effectiveBW =
                       std::vector<std::vector<double>>(),
                   double refFreq = 0, int spectralWindow = 0);
 
  void setArrayInformation(const casacore::MPosition& arrayPos,
                           const casacore::MDirection& phaseCenter,
                           const casacore::MDirection& delayCenter,
                           const casacore::MDirection& tileBeamDir);
 
  void setAntennas(const std::vector<std::string>& antNames,
                   const std::vector<double>& antDiam,
                   const std::vector<casacore::MPosition>& antPos,
                   const std::vector<int>& ant1, const std::vector<int>& ant2);
 
  void SelectChannels(unsigned int start_channel, unsigned int n_channels);
 
  void SelectBaselines(const std::vector<unsigned int>& baselines);
 
  unsigned int update(unsigned int chanAvg, unsigned int timeAvg);
 
  void update(std::vector<unsigned int>&& timeAvg);
 
  void RemoveUnusedAntennas();
 
  void setPhaseCenter(const casacore::MDirection& phase_center) {
    phase_center_ = phase_center;
  }
 
  void setPolarizations(
      const std::set<aocommon::PolarizationEnum>& polarizations) {
    polarizations_ = polarizations;
  }
 
  const std::string& msName() const { return ms_name_; }
  const std::string& dataColumnName() const { return data_column_name_; }
  const std::string& flagColumnName() const { return flag_column_name_; }
  const std::string& weightColumnName() const { return weight_column_name_; }
  const std::string& antennaSet() const { return antenna_set_; }
  unsigned int ncorr() const { return n_correlations_; }
  unsigned int nchan() const { return n_channels_; }
  unsigned int startchan() const { return start_channel_; }
  unsigned int origNChan() const { return original_n_channels_; }
  unsigned int nchanAvg() const { return channel_averaging_factor_; }
  unsigned int nantenna() const { return antenna_names_.size(); }
  unsigned int nbaselines() const { return antenna1_.size(); }
  unsigned int ntime() const { return n_times_; }
  unsigned int ntimeAvg(unsigned int baseline = 0) const {
    return time_averaging_factors_[baseline];
  }
  const std::vector<unsigned int>& ntimeAvgs() const {
    return time_averaging_factors_;
  }
  double startTime() const { return first_time_ - 0.5 * time_interval_; }
  double firstTime() const { return first_time_; }
  double lastTime() const { return last_time_; }
  double timeInterval() const { return time_interval_; }
  bool isBDAIntervalFactorInteger() const {
    return bda_interval_factor_is_integer_;
  }
  const std::vector<int>& getAnt1() const { return antenna1_; }
  const std::vector<int>& getAnt2() const { return antenna2_; }
  const std::vector<std::string>& antennaNames() const {
    return antenna_names_;
  }
  const std::vector<std::string> GetUsedAntennaNames() const;
  const std::vector<double>& antennaDiam() const { return antenna_diameters_; }
  const std::vector<casacore::MPosition>& antennaPos() const {
    return antenna_positions_;
  }
  const casacore::MPosition& arrayPos() const { return array_position_; }
  const casacore::MPosition arrayPosCopy() const {
    return copyMeasure(casacore::MeasureHolder(array_position_)).asMPosition();
  }
  const casacore::MDirection& originalPhaseCenter() const {
    return original_phase_center_;
  }
  const casacore::MDirection& phaseCenter() const { return phase_center_; }
  const casacore::MDirection phaseCenterCopy() const {
    return copyMeasure(casacore::MeasureHolder(phase_center_)).asMDirection();
  }
  Direction phaseCenterDirection() const;
  const casacore::MDirection& delayCenter() const { return delay_center_; }
  const casacore::MDirection delayCenterCopy() const {
    return copyMeasure(casacore::MeasureHolder(delay_center_)).asMDirection();
  }
  const casacore::MDirection& tileBeamDir() const {
    return tile_beam_direction_;
  }
  const casacore::MDirection tileBeamDirCopy() const {
    return copyMeasure(casacore::MeasureHolder(tile_beam_direction_))
        .asMDirection();
  }
  const std::vector<double>& chanFreqs(std::size_t baseline = 0) const {
    return channel_frequencies_[baseline];
  }
  const std::vector<std::vector<double>>& BdaChanFreqs() const {
    return channel_frequencies_;
  }
  const std::vector<double>& chanWidths(std::size_t baseline = 0) const {
    return channel_widths_[baseline];
  }
  const std::vector<std::vector<double>>& BdaChanWidths() const {
    return channel_widths_;
  }
  const std::vector<double>& resolutions(std::size_t baseline = 0) const {
    return resolutions_[baseline];
  }
  const std::vector<double>& effectiveBW(std::size_t baseline = 0) const {
    return effective_bandwidth_[baseline];
  }
  bool hasBDAChannels() const {
    return channel_frequencies_.size() == nbaselines();
  }
  double totalBW() const { return total_bandwidth_; }
  double refFreq() const { return reference_frequency_; }
  int spectralWindow() const { return spectral_window_; }
 
  const std::vector<int>& antennaUsed() const { return antennas_used_; }
 
  const std::vector<int>& antennaMap() const { return antenna_map_; }
 
  bool metaChanged() const { return meta_changed_; }
 
  void setMetaChanged() { meta_changed_ = true; }
  void clearMetaChanged() { meta_changed_ = false; }
 
  const std::vector<int>& getAutoCorrIndex() const;
 
  const std::vector<double>& getBaselineLengths() const;
 
  int beamCorrectionMode() const { return beam_correction_mode_; }
 
  void setBeamCorrectionMode(int mode) { beam_correction_mode_ = mode; }
 
  const casacore::MDirection& beamCorrectionDir() const {
    return beam_correction_direction_;
  }
  void setBeamCorrectionDir(const casacore::MDirection& dir) {
    beam_correction_direction_ = dir;
  }
 
  bool channelsAreRegular() const;
 
  const std::set<aocommon::PolarizationEnum>& polarizations() const {
    return polarizations_;
  }
 
  const std::map<std::string, Direction>& GetDirections() const {
    return extra_directions_;
  }
 
  std::map<std::string, Direction>& GetDirections() {
    return extra_directions_;
  }
 
 private:
  void setAntUsed();
 
  static casacore::MeasureHolder copyMeasure(
      const casacore::MeasureHolder fromMeas);
 
  bool meta_changed_;  
  std::string ms_name_;
  std::string data_column_name_;
  std::string flag_column_name_;
  std::string weight_column_name_;
  std::string antenna_set_;
  unsigned int n_correlations_;
  unsigned int start_channel_;
  unsigned int original_n_channels_;
  unsigned int n_channels_;
  unsigned int channel_averaging_factor_;
  std::vector<unsigned int> time_averaging_factors_;
  double
      first_time_;    
  double last_time_;  
  double time_interval_;  
  unsigned int n_times_;  
  bool bda_interval_factor_is_integer_{false};  // INTEGER_INTERVAL_FACTORS in
                                                // [BDA_TIME_AXIS}
  casacore::MDirection original_phase_center_;
  casacore::MDirection phase_center_;
  casacore::MDirection delay_center_;
  casacore::MDirection tile_beam_direction_;
  std::map<std::string, Direction> extra_directions_;
  int beam_correction_mode_;
  casacore::MDirection beam_correction_direction_;
  casacore::MPosition array_position_;
  std::vector<std::vector<double>> channel_frequencies_;
  std::vector<std::vector<double>> channel_widths_;
  std::vector<std::vector<double>> resolutions_;
  std::vector<std::vector<double>> effective_bandwidth_;
  double total_bandwidth_;
  double reference_frequency_;
  int spectral_window_;
  std::vector<std::string> antenna_names_;
  std::vector<double> antenna_diameters_;
  std::vector<casacore::MPosition> antenna_positions_;
  std::vector<int> antennas_used_;
  std::vector<int> antenna_map_;
  std::vector<int> antenna1_;
  std::vector<int> antenna2_;
  mutable std::vector<double> baseline_lengths_;
  mutable std::vector<int> auto_correlation_indices_;
  std::set<aocommon::PolarizationEnum> polarizations_;
};
 
}  // namespace base
}  // namespace dp3
 
#endif  // DP3_BASE_DPINFO_H_