Line data    Source code

       1             : /*
       2             :  * SDDoubleCircleGainCal.h
       3             :  *
       4             :  *  Created on: May 31, 2016
       5             :  *      Author: nakazato
       6             :  */
       7             : 
       8             : #ifndef SYNTHESIS_MEASUREMENTCOMPONENTS_SDDOUBLECIRCLEGAINCALIMPL_H_
       9             : #define SYNTHESIS_MEASUREMENTCOMPONENTS_SDDOUBLECIRCLEGAINCALIMPL_H_
      10             : 
      11             : #include <map>
      12             : #include <list>
      13             : 
      14             : #include <casacore/casa/aipstype.h>
      15             : #include <casacore/casa/Arrays/Cube.h>
      16             : #include <casacore/casa/Arrays/Matrix.h>
      17             : #include <casacore/casa/Arrays/Vector.h>
      18             : #include <casacore/casa/Logging/LogIO.h>
      19             : #include <casacore/casa/BasicSL/Constants.h>
      20             : #include <casacore/casa/Containers/Block.h>
      21             : 
      22             : namespace casa { // namespace casa START
      23             : 
      24             : class TimeRangeKey {
      25             : public:
      26             :   struct Less {
      27      331174 :     bool operator()(TimeRangeKey const &a, TimeRangeKey const &b) const {
      28     1324696 :       for (size_t i = 0; i < 3; ++i) {
      29      993522 :         if (a.meta_[i] != b.meta_[i]) {
      30           0 :           return a.meta_[i] < b.meta_[i];
      31             :         }
      32             :       }
      33             :       // a.meta_ == b.meta_
      34      331174 :       return false;
      35             :     }
      36             :   };
      37      165596 :   TimeRangeKey(casacore::Int const field_id, casacore::Int const antenna_id,
      38      165596 :   casacore::Int const feed_id) :
      39      165596 :       meta_(3) {
      40      165596 :     meta_[0] = field_id;
      41      165596 :     meta_[1] = antenna_id;
      42      165596 :     meta_[2] = feed_id;
      43      165596 :   }
      44      165605 :   ~TimeRangeKey() = default;
      45             : private:
      46             :   casacore::Block<casacore::Int> meta_;
      47             :   TimeRangeKey() = delete;
      48             : };
      49             : 
      50             : typedef std::pair<casacore::Double, casacore::Double> TimeRange;
      51             : typedef std::list<TimeRange> TimeRangeList;
      52             : 
      53             : class TimeRangeListTool {
      54             : public:
      55    14933490 :   static bool InRange(TimeRange const &timerange, casacore::Double const current_time) {
      56    14933490 :     auto const time_from = timerange.first * (1.0 - casacore::C::dbl_epsilon);
      57    14933490 :     auto const time_to = timerange.second * (1.0 + casacore::C::dbl_epsilon);
      58    14933490 :     return time_from < current_time && current_time < time_to;
      59             :   }
      60             : 
      61      165578 :   static bool InRange(TimeRangeList const &timerange_list, casacore::Double const current_time) {
      62    15092418 :     for (auto iter = timerange_list.begin(); iter != timerange_list.end(); ++iter) {
      63    14933490 :       if (InRange(*iter, current_time)) {
      64        6650 :         return true;
      65             :       }
      66             :     }
      67      158928 :     return false;
      68             :   }
      69             : };
      70             : 
      71             : class SDDoubleCircleGainCalImpl {
      72             : public:
      73             :   SDDoubleCircleGainCalImpl();
      74             :   virtual ~SDDoubleCircleGainCalImpl();
      75             : 
      76             :   // getter
      77             :   // get size of the central region in radian
      78             :   casacore::Double getCentralRegion() const {
      79             :     return central_region_;
      80             :   }
      81           9 :   casacore::Bool isSmoothingActive() const {
      82           9 :     return do_smooth_;
      83             :   }
      84             :   // get smoothing size
      85             :   casacore::Int getSmoothingSize() const {
      86             :     return smooth_size_;
      87             :   }
      88             :   // get observing frequency in Hz
      89          27 :   casacore::Double getObservingFrequency() const {
      90          27 :     return observing_frequency_;
      91             :   }
      92             :   // get antenna diameter in meter
      93          27 :   casacore::Double getAntennaDiameter() const {
      94          27 :     return antenna_diameter_;
      95             :   }
      96             : 
      97             :   // primvary beam size in radian
      98             :   casacore::Double getPrimaryBeamSize() const;
      99             : 
     100             :   // default smoothing size
     101             :   casacore::Int getDefaultSmoothingSize() const;
     102             : 
     103             :   // get radius of the central region in radian
     104             :   casacore::Double getRadius();
     105             : 
     106             :   // get effective smoothing size
     107             :   casacore::Int getEffectiveSmoothingSize();
     108             : 
     109             :   // setter
     110             :   // set radius of the central region in radian
     111          18 :   void setCentralRegion(casacore::Double value) {
     112          18 :     central_region_ = value;
     113          18 :   }
     114             : 
     115             :   // activate smoothing and set smoothing size
     116          18 :   void setSmoothing(casacore::Int size) {
     117          18 :     do_smooth_ = true;
     118          18 :     smooth_size_ = size;
     119          18 :   }
     120             : 
     121             :   // deactivate smoothing
     122           0 :   void unsetSmoothing() {
     123           0 :     do_smooth_ = false;
     124           0 :     smooth_size_ = -1;
     125           0 :   }
     126             : 
     127             :   // set observing frequency in Hz
     128          27 :   void setObservingFrequency(casacore::Double value) {
     129          27 :     observing_frequency_ = value;
     130          27 :   }
     131             : 
     132             :   // set antenna diameter in meter
     133          27 :   void setAntennaDiameter(casacore::Double value) {
     134          27 :     antenna_diameter_ = value;
     135          27 :   }
     136             : 
     137             :   // gain calibration
     138             :   // based on Stephen White's IDL script
     139             :   void calibrate(casacore::Cube<casacore::Float> const &data,
     140             :   casacore::Vector<casacore::Double> const &time,
     141             :   casacore::Matrix<casacore::Double> const &direction,
     142             :   casacore::Vector<casacore::Double> &gain_time,
     143             :   casacore::Cube<casacore::Float> &gain);
     144             :   // subspecies that take into account flag (false: valid, true: invalid)
     145             :   void calibrate(casacore::Cube<casacore::Float> const &data,
     146             :   casacore::Cube<casacore::Bool> const &flag,
     147             :   casacore::Vector<casacore::Double> const &time,
     148             :   casacore::Matrix<casacore::Double> const &direction,
     149             :   casacore::Vector<casacore::Double> &gain_time,
     150             :   casacore::Cube<casacore::Float> &gain,
     151             :   casacore::Cube<casacore::Bool> &gain_flag);
     152             : 
     153             :   // gain calibration implementation
     154             :   void doCalibrate(casacore::Vector<casacore::Double> &gain_time,
     155             :   casacore::Cube<casacore::Float> &gain,
     156             :   casacore::Cube<casacore::Bool> &gain_flag);
     157             : 
     158             :   // find time range that observed central region
     159             :   bool findTimeRange(casacore::Vector<casacore::Double> const &time,
     160             :   casacore::Vector<casacore::Double> const &interval,
     161             :   casacore::Matrix<casacore::Double> const &direction,
     162             :       TimeRangeList &timerange);
     163             : 
     164             :   // apply gain factor
     165             : //  void apply(casacore::Vector<casacore::Double> const &gain_time,
     166             : //      casacore::Cube<casacore::Float> const &gain,
     167             : //      casacore::Vector<casacore::Double> const &time,
     168             : //      casacore::Cube<casacore::Float> &data);
     169             : 
     170             : private:
     171             :   // radius of the central region [rad]
     172             :   casacore::Double central_region_;
     173             : 
     174             :   // flag for smoothing
     175             :   casacore::Bool do_smooth_;
     176             : 
     177             :   // smoothing size
     178             :   casacore::Int smooth_size_;
     179             : 
     180             :   // parameter for primary beam size determination
     181             :   // observing frequency [Hz]
     182             :   casacore::Double observing_frequency_;
     183             : 
     184             :   // antenna diameter [m]
     185             :   casacore::Double antenna_diameter_;
     186             : 
     187             :   // logger
     188             :   casacore::LogIO logger_;
     189             : 
     190             :   // find data within radius
     191             :   void findDataWithinRadius(casacore::Double const radius,
     192             :   casacore::Vector<casacore::Double> const &time,
     193             :   casacore::Cube<casacore::Float> const &data,
     194             :   casacore::Matrix<casacore::Double> const &direction,
     195             :   casacore::Vector<casacore::Double> &gain_time,
     196             :   casacore::Cube<casacore::Float> &gain);
     197             :   void findDataWithinRadius(casacore::Double const radius,
     198             :   casacore::Vector<casacore::Double> const &time,
     199             :   casacore::Cube<casacore::Float> const &data,
     200             :   casacore::Cube<casacore::Bool> const &flag,
     201             :   casacore::Matrix<casacore::Double> const &direction,
     202             :   casacore::Vector<casacore::Double> &gain_time,
     203             :   casacore::Cube<casacore::Float> &gain,
     204             :   casacore::Cube<casacore::Bool> &gain_flag);
     205             : };
     206             : 
     207             : } // namespace casa END
     208             : 
     209             : #endif /* SYNTHESIS_MEASUREMENTCOMPONENTS_SDDOUBLECIRCLEGAINCALIMPL_H_ */