Line data    Source code

       1             : /*
       2             :  * SysCalRecord.h
       3             :  *
       4             :  *  Created on: Jan 27, 2016
       5             :  *      Author: nakazato
       6             :  */
       7             : 
       8             : #ifndef SINGLEDISH_FILLER_SYSCALRECORD_H_
       9             : #define SINGLEDISH_FILLER_SYSCALRECORD_H_
      10             : 
      11             : #include <casacore/casa/BasicSL/String.h>
      12             : #include <casacore/casa/OS/Path.h>
      13             : #include <casacore/measures/Measures/MPosition.h>
      14             : #include <casacore/ms/MeasurementSets/MeasurementSet.h>
      15             : #include <casacore/ms/MeasurementSets/MSSysCal.h>
      16             : #include <casacore/ms/MeasurementSets/MSSysCalColumns.h>
      17             : 
      18             : namespace casa { //# NAMESPACE CASA - BEGIN
      19             : namespace sdfiller { //# NAMESPACE SDFILLER - BEGIN
      20             : 
      21             : struct SysCalRecord {
      22             :   typedef casacore::MSSysCal AssociatingTable;
      23             :   typedef casacore::MSSysCalColumns AssociatingColumns;
      24             : 
      25             :   // mandatory
      26             :   casacore::Int antenna_id;
      27             :   casacore::Int feed_id;
      28             :   casacore::Int spw_id;
      29             :   casacore::Double time;
      30             :   casacore::Double interval;
      31             : 
      32             :   // optional
      33             :   casacore::Vector<casacore::Float> tcal;
      34             :   casacore::Matrix<casacore::Float> tcal_spectrum;
      35             :   casacore::Vector<casacore::Float> tsys;
      36             :   casacore::Matrix<casacore::Float> tsys_spectrum;
      37             : 
      38             :   // method
      39       14174 :   void clear() {
      40       14174 :     antenna_id = -1;
      41       14174 :     feed_id = -1;
      42       14174 :     spw_id = -1;
      43       14174 :     time = 0.0;
      44       14174 :     interval = 0.0;
      45       14174 :     tcal.resize();
      46       14174 :     tcal_spectrum.resize();
      47       14174 :     tsys.resize();
      48       14174 :     tsys_spectrum.resize();
      49       14174 :   }
      50             : 
      51             :   SysCalRecord &operator=(SysCalRecord const &other) {
      52             :     antenna_id = other.antenna_id;
      53             :     feed_id = other.feed_id;
      54             :     spw_id = other.spw_id;
      55             :     time = other.time;
      56             :     interval = other.interval;
      57             :     tcal = other.tcal;
      58             :     tcal_spectrum = other.tcal_spectrum;
      59             :     tsys = other.tsys;
      60             :     tsys_spectrum = other.tsys_spectrum;
      61             :     return *this;
      62             :   }
      63             : 
      64             :   void add(AssociatingTable &table, AssociatingColumns &/*columns*/) {
      65             :     table.addRow(1, true);
      66             :   }
      67             : 
      68          17 :   casacore::Bool fill(casacore::uInt irow, AssociatingColumns &columns) {
      69          17 :     if (columns.nrow() <= irow) {
      70           0 :       return false;
      71             :     }
      72             : 
      73          17 :     columns.antennaId().put(irow, antenna_id);
      74          17 :     columns.feedId().put(irow, feed_id);
      75          17 :     columns.spectralWindowId().put(irow, spw_id);
      76          17 :     columns.time().put(irow, time);
      77          17 :     columns.interval().put(irow, interval);
      78          17 :     if (tcal.size() > 0) {
      79           0 :       columns.tcal().put(irow, tcal);
      80             :     }
      81          17 :     if (tcal_spectrum.size() > 0) {
      82           5 :       columns.tcalSpectrum().put(irow, tcal_spectrum);
      83             :     }
      84          17 :     if (tsys.size() > 0) {
      85          12 :       columns.tsys().put(irow, tsys);
      86             :     }
      87          17 :     if (tsys_spectrum.size() > 0) {
      88           5 :       columns.tsysSpectrum().put(irow, tsys_spectrum);
      89             :     }
      90          17 :     return true;
      91             :   }
      92             : };
      93             : 
      94             : struct SysCalTableRecord {
      95             :   enum Status {
      96             :     Spectral, Scalar, NotDefined
      97             :   };
      98          17 :   SysCalTableRecord(casacore::MeasurementSet *ms, casacore::uInt irow, SysCalRecord const &record) :
      99          17 :       ms_(ms), columns_(ms->sysCal()), irow_(irow) {
     100          17 :     antenna_id = record.antenna_id;
     101          17 :     feed_id = record.feed_id;
     102          17 :     spw_id = record.spw_id;
     103          17 :     casacore::ScalarColumn<casacore::Int> num_chan_column(ms_->spectralWindow(), "NUM_CHAN");
     104          17 :     num_chan = num_chan_column(spw_id);
     105          17 :     if (record.tsys_spectrum.empty()) {
     106          12 :       num_corr = record.tsys.size();
     107          12 :       tsys_status = Status::Scalar;
     108          12 :       if (record.tsys.empty()) {
     109           0 :         tsys_nominal = -1.0f;
     110           0 :         tsys_status = Status::NotDefined;
     111             :       } else {
     112          12 :         tsys_nominal = record.tsys[0];
     113             :       }
     114             :     } else {
     115           5 :       num_corr = record.tsys_spectrum.shape()[0];
     116           5 :       tsys_status = Status::Spectral;
     117           5 :       tsys_nominal = record.tsys_spectrum(0, 0);
     118             :     }
     119          17 :     if (record.tcal_spectrum.empty()) {
     120          12 :       tcal_status = Status::Scalar;
     121          12 :       if (record.tcal.empty()) {
     122          12 :         tcal_nominal = -1.0f;
     123          12 :         tcal_status = Status::NotDefined;
     124             :       } else {
     125           0 :         tcal_nominal = record.tcal[0];
     126             :       }
     127             :     } else {
     128           5 :       tcal_status = Status::Spectral;
     129           5 :       tcal_nominal = record.tcal_spectrum(0, 0);
     130             :     }
     131          17 :   }
     132          31 :   SysCalTableRecord(SysCalTableRecord const &other) :
     133          31 :       ms_(other.ms_), columns_(ms_->sysCal()), irow_(other.irow_) {
     134          31 :     antenna_id = other.antenna_id;
     135          31 :     feed_id = other.feed_id;
     136          31 :     spw_id = other.spw_id;
     137          31 :     num_chan = other.num_chan;
     138          31 :     num_corr = other.num_corr;
     139          31 :     tsys_status = other.tsys_status;
     140          31 :     tcal_status = other.tcal_status;
     141          31 :     tsys_nominal = other.tsys_nominal;
     142          31 :     tcal_nominal = other.tcal_nominal;
     143          31 :   }
     144             :   casacore::Int antenna_id;
     145             :   casacore::Int feed_id;
     146             :   casacore::Int spw_id;
     147             :   casacore::Int num_chan;
     148             :   casacore::Int num_corr;
     149             :   Status tsys_status;
     150             :   Status tcal_status;
     151             :   casacore::Float tsys_nominal;
     152             :   casacore::Float tcal_nominal;
     153             : 
     154             :   // returns true if two SysCalTableRecord objects are exactly same
     155             :   bool operator==(SysCalTableRecord const &record) {
     156             :     casacore::String ms_name = casacore::Path(ms_->tableName()).resolvedName();
     157             :     casacore::String ms_name_record = casacore::Path(record.ms_->tableName()).resolvedName();
     158             :     return ms_name == ms_name_record && irow_ == record.irow_
     159             :         && antenna_id == record.antenna_id && feed_id == record.feed_id
     160             :         && spw_id == record.spw_id && num_chan == record.num_chan
     161             :         && num_corr == record.num_corr && tsys_status == record.tsys_status
     162             :         && tcal_status == record.tcal_status
     163             :         && tsys_nominal == record.tsys_nominal
     164             :         && tcal_nominal == record.tcal_nominal;
     165             :   }
     166             : 
     167             :   // returns true if given SysCalRecord is effectively the same
     168       35699 :   bool operator==(SysCalRecord const &record) {
     169       71398 :     bool is_meta_equal = antenna_id == record.antenna_id
     170       35699 :         && feed_id == record.feed_id && spw_id == record.spw_id;
     171       35699 :     if (!is_meta_equal) {
     172       25440 :       return false;
     173             :     }
     174             : 
     175             :     bool is_tsys_same;
     176       10259 :     if (tsys_status == Status::Spectral) {
     177         190 :       is_tsys_same = num_chan > 0
     178          95 :           && (casacore::uInt) num_chan == record.tsys_spectrum.ncolumn() && num_corr > 0
     179          95 :           && (casacore::uInt) num_corr == record.tsys_spectrum.nrow()
     180          95 :           && tsys_nominal == record.tsys_spectrum(0, 0)
     181         190 :           && allEQ(columns_.tsysSpectrum()(irow_), record.tsys_spectrum);
     182       10164 :     } else if (tsys_status == Status::Scalar) {
     183       10164 :       is_tsys_same = num_corr > 0 && (casacore::uInt) num_corr == record.tsys.size()
     184       10164 :           && tsys_nominal == record.tsys[0]
     185       20328 :           && allEQ(columns_.tsys()(irow_), record.tsys);
     186             :     } else {
     187           0 :       is_tsys_same = record.tsys_spectrum.empty() && record.tsys.empty();
     188             :     }
     189             : 
     190       10259 :     if (!is_tsys_same) {
     191           0 :       return false;
     192             :     }
     193             : 
     194             :     bool is_tcal_same;
     195       10259 :     if (tcal_status == Status::Spectral) {
     196         190 :       is_tcal_same = num_chan > 0
     197          95 :           && (casacore::uInt) num_chan == record.tcal_spectrum.ncolumn() && num_corr > 0
     198          95 :           && (casacore::uInt) num_corr == record.tcal_spectrum.nrow()
     199          95 :           && tcal_nominal == record.tcal_spectrum(0, 0)
     200         190 :           && allEQ(columns_.tcalSpectrum()(irow_), record.tcal_spectrum);
     201       10164 :     } else if (tcal_status == Status::Scalar) {
     202           0 :       is_tcal_same = num_corr > 0 && (casacore::uInt) num_corr == record.tcal.size()
     203           0 :           && tcal_nominal == record.tcal[0]
     204           0 :           && allEQ(columns_.tcal()(irow_), record.tcal);
     205             :     } else {
     206       10164 :       is_tcal_same = record.tcal_spectrum.empty() && record.tcal.empty();
     207             :     }
     208             : 
     209       10259 :     if (!is_tcal_same) {
     210           0 :       return false;
     211             :     }
     212             : 
     213       10259 :     return true;
     214             :   }
     215             : 
     216             : private:
     217             :   casacore::MeasurementSet *ms_;
     218             :   casacore::MSSysCalColumns columns_;
     219             :   casacore::uInt irow_;
     220             : };
     221             : 
     222             : } //# NAMESPACE SDFILLER - END
     223             : } //# NAMESPACE CASA - END
     224             : 
     225             : #endif /* SINGLEDISH_FILLER_SYSCALRECORD_H_ */