Line data    Source code

       1             : /*
       2             :  * Scantable2MSReader.cc
       3             :  *
       4             :  *  Created on: Jan 5, 2016
       5             :  *      Author: nakazato
       6             :  */
       7             : 
       8             : #include <singledishfiller/Filler/Scantable2MSReader.h>
       9             : 
      10             : #include <iostream>
      11             : #include <string>
      12             : 
      13             : #include <casacore/casa/OS/File.h>
      14             : #include <casacore/casa/Containers/Record.h>
      15             : #include <casacore/casa/Utilities/Regex.h>
      16             : #include <casacore/tables/Tables/TableRecord.h>
      17             : #include <casacore/casa/Arrays/Vector.h>
      18             : #include <casacore/casa/Arrays/ArrayMath.h>
      19             : #include <casacore/casa/IO/ArrayIO.h>
      20             : #include <casacore/tables/Tables/Table.h>
      21             : #include <casacore/measures/Measures/Stokes.h>
      22             : 
      23             : using namespace casacore;
      24             : 
      25             : namespace {
      26           0 : Double queryAntennaDiameter(String const &name) {
      27           0 :   String capitalized = name;
      28           0 :   capitalized.upcase();
      29           0 :   Double diameter = 0.0;
      30           0 :   if (capitalized.matches(Regex(".*(DV|DA|PM)[0-9]+$"))) {
      31           0 :     diameter = 12.0;
      32           0 :   } else if (capitalized.matches(Regex(".*CM[0-9]+$"))) {
      33           0 :     diameter = 7.0;
      34           0 :   } else if (capitalized.contains("GBT")) {
      35           0 :     diameter = 104.9;
      36           0 :   } else if (capitalized.contains("MOPRA")) {
      37           0 :     diameter = 22.0;
      38           0 :   } else if (capitalized.contains("PKS") || capitalized.contains("PARKS")) {
      39           0 :     diameter = 64.0;
      40           0 :   } else if (capitalized.contains("TIDBINBILLA")) {
      41           0 :     diameter = 70.0;
      42           0 :   } else if (capitalized.contains("CEDUNA")) {
      43           0 :     diameter = 30.0;
      44           0 :   } else if (capitalized.contains("HOBART")) {
      45           0 :     diameter = 26.0;
      46           0 :   } else if (capitalized.contains("APEX")) {
      47           0 :     diameter = 12.0;
      48           0 :   } else if (capitalized.contains("ASTE")) {
      49           0 :     diameter = 10.0;
      50           0 :   } else if (capitalized.contains("NRO")) {
      51           0 :     diameter = 45.0;
      52             :   }
      53             : 
      54           0 :   return diameter;
      55           0 : }
      56             : 
      57             : template<class T, class U>
      58           0 : U getMapValue(std::map<T, U> const mymap, T const key, U const default_value) {
      59           0 :   auto iter = mymap.find(key);
      60           0 :   if (iter != mymap.end()) {
      61           0 :     return iter->second;
      62             :   } else {
      63           0 :     return default_value;
      64             :   }
      65             : }
      66             : 
      67           0 : String getIntent(Int srctype) {
      68           0 :   static std::map<Int, String> intent_map;
      69           0 :   if (intent_map.size() == 0) {
      70           0 :     String sep1 = "#";
      71           0 :     String sep2 = ",";
      72           0 :     String target = "OBSERVE_TARGET";
      73           0 :     String atmcal = "CALIBRATE_ATMOSPHERE";
      74           0 :     String anycal = "CALIBRATE_SOMETHING";
      75           0 :     String onstr = "ON_SOURCE";
      76           0 :     String offstr = "OFF_SOURCE";
      77           0 :     String pswitch = "POSITION_SWITCH";
      78           0 :     String nod = "NOD";
      79           0 :     String fswitch = "FREQUENCY_SWITCH";
      80           0 :     String sigstr = "SIG";
      81           0 :     String refstr = "REF";
      82           0 :     String hot = "HOT";
      83           0 :     String warm = "WARM";
      84           0 :     String cold = "COLD";
      85           0 :     String unspecified = "UNSPECIFIED";
      86           0 :     String ftlow = "LOWER";
      87           0 :     String fthigh = "HIGHER";
      88           0 :     intent_map[0] = target + sep1 + onstr + sep2 + pswitch;
      89           0 :     intent_map[1] = target + sep1 + offstr + sep2 + pswitch;
      90           0 :     intent_map[2] = target + sep1 + onstr + sep2 + nod;
      91           0 :     intent_map[3] = target + sep1 + onstr + sep2 + fswitch + sep1 + sigstr;
      92           0 :     intent_map[4] = target + sep1 + onstr + sep2 + fswitch + sep1 + refstr;
      93           0 :     intent_map[6] = atmcal + sep1 + offstr + sep2 + unspecified;
      94           0 :     intent_map[7] = atmcal + sep1 + hot + sep2 + unspecified;
      95           0 :     intent_map[8] = atmcal + sep1 + warm + sep2 + unspecified;
      96           0 :     intent_map[9] = atmcal + sep1 + cold + sep2 + unspecified;
      97           0 :     intent_map[10] = atmcal + sep1 + onstr + sep2 + pswitch;
      98           0 :     intent_map[11] = atmcal + sep1 + offstr + sep2 + pswitch;
      99           0 :     intent_map[12] = atmcal + sep1 + onstr + sep2 + nod;
     100           0 :     intent_map[13] = atmcal + sep1 + onstr + sep2 + fswitch + sep1 + sigstr;
     101           0 :     intent_map[14] = atmcal + sep1 + offstr + sep2 + fswitch + sep1 + refstr;
     102           0 :     intent_map[20] = target + sep1 + onstr + sep2 + fswitch + sep1 + ftlow;
     103           0 :     intent_map[21] = target + sep1 + offstr + sep2 + fswitch + sep1 + ftlow;
     104           0 :     intent_map[26] = atmcal + sep1 + offstr + sep2 + fswitch + sep1 + ftlow;
     105           0 :     intent_map[27] = atmcal + sep1 + offstr + sep2 + fswitch + sep1 + ftlow;
     106           0 :     intent_map[28] = atmcal + sep1 + offstr + sep2 + fswitch + sep1 + ftlow;
     107           0 :     intent_map[29] = atmcal + sep1 + offstr + sep2 + fswitch + sep1 + ftlow;
     108           0 :     intent_map[30] = target + sep1 + onstr + sep2 + fswitch + sep1 + fthigh;
     109           0 :     intent_map[31] = target + sep1 + offstr + sep2 + fswitch + sep1 + fthigh;
     110           0 :     intent_map[36] = atmcal + sep1 + offstr + sep2 + fswitch + sep1 + fthigh;
     111           0 :     intent_map[37] = atmcal + sep1 + offstr + sep2 + fswitch + sep1 + fthigh;
     112           0 :     intent_map[38] = atmcal + sep1 + offstr + sep2 + fswitch + sep1 + fthigh;
     113           0 :     intent_map[39] = atmcal + sep1 + offstr + sep2 + fswitch + sep1 + fthigh;
     114           0 :     intent_map[90] = target + sep1 + onstr + sep2 + unspecified;
     115           0 :     intent_map[91] = target + sep1 + offstr + sep2 + unspecified;
     116           0 :     intent_map[92] = anycal + sep1 + offstr + sep2 + unspecified;
     117           0 :   }
     118           0 :   String default_type = "UNKNOWN_INTENT";
     119           0 :   return getMapValue(intent_map, srctype, default_type);
     120           0 : }
     121             : 
     122           0 : Int getSubscan(Int srctype) {
     123           0 :   static std::map<Int, Int> subscan_map;
     124           0 :   if (subscan_map.size() == 0) {
     125           0 :     subscan_map[0] = 1;
     126           0 :     subscan_map[1] = 2;
     127           0 :     subscan_map[2] = 1;
     128           0 :     subscan_map[3] = 1;
     129           0 :     subscan_map[4] = 2;
     130           0 :     subscan_map[6] = 1;
     131           0 :     subscan_map[7] = 2;
     132           0 :     subscan_map[8] = 3;
     133           0 :     subscan_map[9] = 4;
     134           0 :     subscan_map[10] = 5;
     135           0 :     subscan_map[11] = 6;
     136           0 :     subscan_map[12] = 7;
     137           0 :     subscan_map[13] = 8;
     138           0 :     subscan_map[14] = 9;
     139           0 :     subscan_map[20] = 1;
     140           0 :     subscan_map[21] = 2;
     141           0 :     subscan_map[26] = 1;
     142           0 :     subscan_map[27] = 2;
     143           0 :     subscan_map[28] = 3;
     144           0 :     subscan_map[29] = 4;
     145           0 :     subscan_map[30] = 3;
     146           0 :     subscan_map[31] = 4;
     147           0 :     subscan_map[36] = 5;
     148           0 :     subscan_map[37] = 6;
     149           0 :     subscan_map[38] = 7;
     150           0 :     subscan_map[39] = 8;
     151           0 :     subscan_map[90] = 1;
     152           0 :     subscan_map[91] = 2;
     153           0 :     subscan_map[92] = 1;
     154             :   }
     155           0 :   Int default_subscan = 1;
     156           0 :   return getMapValue(subscan_map, srctype, default_subscan);
     157             : }
     158             : 
     159           0 : casacore::Stokes::StokesTypes getPol(uInt const polno, casacore::String const poltype) {
     160           0 :         casacore::Stokes::StokesTypes stokes = casacore::Stokes::Undefined;
     161           0 :         if (poltype == "linear") {
     162           0 :                 switch (polno) {
     163           0 :                 case 0:
     164           0 :                         stokes = casacore::Stokes::XX;
     165           0 :                         break;
     166           0 :                 case 1:
     167           0 :                         stokes = casacore::Stokes::YY;
     168           0 :                         break;
     169           0 :                 case 2:
     170           0 :                         stokes = casacore::Stokes::XY;
     171           0 :                         break;
     172           0 :                 case 3:
     173           0 :                         stokes = casacore::Stokes::YX;
     174             :                 }
     175           0 :         } else if (poltype == "circular") {
     176           0 :                 switch (polno) {
     177           0 :                 case 0:
     178           0 :                         stokes = casacore::Stokes::RR;
     179           0 :                         break;
     180           0 :                 case 1:
     181           0 :                         stokes = casacore::Stokes::LL;
     182           0 :                         break;
     183           0 :                 case 2:
     184           0 :                         stokes = casacore::Stokes::RL;
     185           0 :                         break;
     186           0 :                 case 3:
     187           0 :                         stokes = casacore::Stokes::LR;
     188           0 :                         break;
     189             :                 }
     190           0 :         } else if (poltype == "stokes") {
     191           0 :                 switch (polno) {
     192           0 :                 case 0:
     193           0 :                         stokes = casacore::Stokes::I;
     194           0 :                         break;
     195           0 :                 case 1:
     196           0 :                         stokes = casacore::Stokes::Q;
     197           0 :                         break;
     198           0 :                 case 2:
     199           0 :                         stokes = casacore::Stokes::U;
     200           0 :                         break;
     201           0 :                 case 3:
     202           0 :                         stokes = casacore::Stokes::V;
     203           0 :                         break;
     204             :                 }
     205           0 :         } else if (poltype == "linpol") {
     206           0 :                 switch (polno) {
     207           0 :                 case 0:
     208           0 :                         stokes = casacore::Stokes::Plinear;
     209           0 :                         break;
     210           0 :                 case 1:
     211           0 :                         stokes = casacore::Stokes::Pangle;
     212           0 :                         break;
     213             :                 }
     214             :         } else {
     215           0 :                 throw casacore::AipsError(
     216           0 :                                 casacore::String("Invalid poltype") + poltype);
     217             :         }
     218           0 :         if (stokes == casacore::Stokes::Undefined) {
     219           0 :                 throw casacore::AipsError(
     220           0 :                                 casacore::String("Invalid polno for type ") + poltype);
     221             :         }
     222           0 :         return stokes;
     223             : }
     224             : }
     225             : 
     226             : using namespace casacore;
     227             : namespace casa { //# NAMESPACE CASA - BEGIN
     228             : 
     229             : using namespace sdfiller;
     230             : 
     231           0 : Scantable2MSReader::Scantable2MSReader(std::string const &scantable_name) :
     232           0 :     ReaderInterface(scantable_name), main_table_(nullptr), tcal_table_(),
     233           0 :     weather_table_(), scan_column_(), cycle_column_(), ifno_column_(),
     234           0 :     polno_column_(), beam_column_(), flagrow_column_(), time_column_(),
     235           0 :     interval_column_(), srctype_column_(), data_column_(), flag_column_(),
     236           0 :     direction_column_(), scanrate_column_(), fieldname_column_(),
     237           0 :     tsys_column_(), tcal_id_column_(), sorted_rows_(),
     238           0 :     get_antenna_row_([&](sdfiller::AntennaRecord &r) {return Scantable2MSReader::getAntennaRowImpl(r);}),
     239           0 :     get_field_row_([&](sdfiller::FieldRecord &r) {return Scantable2MSReader::getFieldRowImpl(r);}),
     240           0 :     get_observation_row_([&](sdfiller::ObservationRecord &r) {return Scantable2MSReader::getObservationRowImpl(r);}),
     241           0 :     get_processor_row_([&](sdfiller::ProcessorRecord &r) {return Scantable2MSReader::getProcessorRowImpl(r);}),
     242           0 :     get_source_row_([&](sdfiller::SourceRecord &r) {return Scantable2MSReader::getSourceRowImpl(r);}),
     243           0 :     get_spw_row_([&](sdfiller::SpectralWindowRecord &r) {return Scantable2MSReader::getSpectralWindowRowImpl(r);}),
     244           0 :     field_iter_(nullptr), freq_iter_(nullptr), source_iter_(nullptr) {
     245             : //  std::cout << "Scantabl2MSReader::Scantable2MSReader" << std::endl;
     246           0 : }
     247             : 
     248           0 : Scantable2MSReader::~Scantable2MSReader() {
     249             : //  std::cout << "Scantabl2MSReader::~Scantable2MSReader" << std::endl;
     250           0 : }
     251             : 
     252           0 : void Scantable2MSReader::initializeSpecific() {
     253             : //  std::cout << "Scantabl2MSReader::initialize" << std::endl;
     254           0 :   File f(name_);
     255           0 :   if (f.exists() and f.isDirectory()) {
     256           0 :     main_table_.reset(new Table(name_, Table::Old));
     257             :   } else {
     258           0 :     throw AipsError("Input data doesn't exist or is invalid");
     259             :   }
     260             : 
     261             :   // subtables
     262           0 :   tcal_table_ = main_table_->keywordSet().asTable("TCAL");
     263           0 :   weather_table_ = main_table_->keywordSet().asTable("WEATHER");
     264             : 
     265             :   // attach columns
     266           0 :   scan_column_.attach(*main_table_, "SCANNO");
     267           0 :   cycle_column_.attach(*main_table_, "CYCLENO");
     268           0 :   ifno_column_.attach(*main_table_, "IFNO");
     269           0 :   polno_column_.attach(*main_table_, "POLNO");
     270           0 :   beam_column_.attach(*main_table_, "BEAMNO");
     271           0 :   flagrow_column_.attach(*main_table_, "FLAGROW");
     272           0 :   time_column_.attach(*main_table_, "TIME");
     273           0 :   interval_column_.attach(*main_table_, "INTERVAL");
     274           0 :   srctype_column_.attach(*main_table_, "SRCTYPE");
     275           0 :   data_column_.attach(*main_table_, "SPECTRA");
     276           0 :   flag_column_.attach(*main_table_, "FLAGTRA");
     277           0 :   direction_column_.attach(*main_table_, "DIRECTION");
     278           0 :   scanrate_column_.attach(*main_table_, "SCANRATE");
     279           0 :   fieldname_column_.attach(*main_table_, "FIELDNAME");
     280           0 :   tsys_column_.attach(*main_table_, "TSYS");
     281           0 :   tcal_id_column_.attach(*main_table_, "TCAL_ID");
     282           0 :   weather_id_column_.attach(*main_table_, "WEATHER_ID");
     283             : 
     284           0 :   tcal_column_.attach(tcal_table_, "TCAL");
     285             : 
     286           0 :   temperature_column_.attach(weather_table_, "TEMPERATURE");
     287           0 :   pressure_column_.attach(weather_table_, "PRESSURE");
     288           0 :   humidity_column_.attach(weather_table_, "HUMIDITY");
     289           0 :   wind_speed_column_.attach(weather_table_, "WINDSPEED");
     290           0 :   wind_direction_column_.attach(weather_table_, "WINDAZ");
     291             : 
     292             :   // get sort index
     293           0 :   Sort s;
     294           0 :   Vector<Double> time_list = time_column_.getColumn();
     295           0 :   s.sortKey(time_list.data(), TpDouble, 0, Sort::Ascending);
     296           0 :   Vector<uInt> beamno_list = beam_column_.getColumn();
     297           0 :   s.sortKey(beamno_list.data(), TpUInt, 0, Sort::Ascending);
     298           0 :   Vector<uInt> ifno_list = ifno_column_.getColumn();
     299           0 :   s.sortKey(ifno_list.data(), TpUInt, 0, Sort::Ascending);
     300           0 :   Vector<uInt> polno_list = polno_column_.getColumn();
     301           0 :   s.sortKey(polno_list.data(), TpUInt, 0, Sort::Ascending);
     302           0 :   uInt n = s.sort(sorted_rows_, main_table_->nrow());
     303           0 :   if (n != main_table_->nrow()) {
     304           0 :     AipsError("Internal problem when sorting rows");
     305             :   }
     306             : //  for (uInt i = 0; i < n; ++i) {
     307             : //    uInt j = sorted_rows_[i];
     308             : //    printf("id %3u row %3u T %10.3f B %2u S %2u P %2u\n", i, j, time_list[j],
     309             : //        beamno_list[j], ifno_list[j], polno_list[j]);
     310             : //  }
     311             : 
     312             :   // TCAL_ID mapping
     313           0 :   ScalarColumn<uInt> id_column(tcal_table_, "ID");
     314           0 :   tcal_id_map_.clear();
     315           0 :   for (uInt i = 0; i < tcal_table_.nrow(); ++i) {
     316           0 :     tcal_id_map_[id_column(i)] = i;
     317             :   }
     318             : 
     319             :   // WEATHER_ID mapping
     320           0 :   id_column.attach(weather_table_, "ID");
     321           0 :   weather_id_map_.clear();
     322           0 :   for (uInt i = 0; i < weather_table_.nrow(); ++i) {
     323           0 :     weather_id_map_[id_column(i)] = i;
     324             :   }
     325             : 
     326             :   // polarization type from header
     327           0 :   pol_type_ = main_table_->keywordSet().asString("POLTYPE");
     328           0 : }
     329             : 
     330           0 : void Scantable2MSReader::finalizeSpecific() {
     331             : //  std::cout << "Scantabl2MSReader::finalize" << std::endl;
     332           0 : }
     333             : 
     334           0 : Bool Scantable2MSReader::getAntennaRowImpl(AntennaRecord &record) {
     335             : //  std::cout << "Scantabl2MSReader::getAntennaRowImpl" << std::endl;
     336           0 :   TableRecord const &header = main_table_->keywordSet();
     337             : 
     338             :   // header antenna name is constructed as <ObservatoryName>//<AntennaName>@<StationName>
     339           0 :   String header_antenna_name = header.asString("AntennaName");
     340           0 :   String::size_type separator = header_antenna_name.find("//");
     341           0 :   String antenna_name;
     342           0 :   if (separator != String::npos) {
     343           0 :     antenna_name = header_antenna_name.substr(separator + 2);
     344             :   } else {
     345           0 :     antenna_name = header_antenna_name;
     346             :   }
     347           0 :   separator = antenna_name.find("@");
     348           0 :   if (separator != String::npos) {
     349           0 :     record.station = antenna_name.substr(separator + 1);
     350           0 :     record.name = antenna_name.substr(0, separator);
     351             :   } else {
     352           0 :     record.station = "";
     353           0 :     record.name = antenna_name;
     354             :   }
     355           0 :   record.dish_diameter = queryAntennaDiameter(record.name);
     356           0 :   record.type = "GROUND-BASED";
     357           0 :   record.mount = "ALT-AZ";
     358             : 
     359             :   Vector<Double> antenna_position_value = header.asArrayDouble(
     360           0 :       "AntennaPosition");
     361           0 :   Vector<Quantity> antenna_position_quant(3);
     362           0 :   antenna_position_quant[0] = Quantity(antenna_position_value[0], "m");
     363           0 :   antenna_position_quant[1] = Quantity(antenna_position_value[1], "m");
     364           0 :   antenna_position_quant[2] = Quantity(antenna_position_value[2], "m");
     365           0 :   record.position = MPosition(MVPosition(antenna_position_quant),
     366           0 :       MPosition::ITRF);
     367             : 
     368             :   // only one entry so redirect function pointer to noMoreRowImpl
     369           0 :   get_antenna_row_ = [&](sdfiller::AntennaRecord &r) {return Scantable2MSReader::noMoreRowImpl<AntennaRecord>(r);};
     370             : 
     371           0 :   return true;
     372           0 : }
     373             : 
     374           0 : Bool Scantable2MSReader::getObservationRowImpl(ObservationRecord &record) {
     375             : //  std::cout << "Scantabl2MSReader::getObservationRowImpl" << std::endl;
     376             : 
     377           0 :   ScalarColumn<Double> column(*main_table_, "TIME");
     378           0 :   Vector<Double> time_list = column.getColumn();
     379           0 :   if (record.time_range.size() != 2) {
     380           0 :     record.time_range.resize(2);
     381             :   }
     382           0 :   minMax(record.time_range[0], record.time_range[1], time_list);
     383           0 :   TableRecord const &header = main_table_->keywordSet();
     384           0 :   record.observer = header.asString("Observer");
     385           0 :   record.project = header.asString("Project");
     386             :   // header antenna name is constructed as <ObservatoryName>//<AntennaName>@<StationName>
     387           0 :   String header_antenna_name = header.asString("AntennaName");
     388           0 :   String::size_type separator = header_antenna_name.find("//");
     389           0 :   if (separator != String::npos) {
     390           0 :     record.telescope_name = header_antenna_name.substr(0, separator);
     391             :   } else {
     392           0 :     separator = header_antenna_name.find("@");
     393           0 :     record.telescope_name = header_antenna_name.substr(0, separator);
     394             :   }
     395             : 
     396             :   // only one entry so redirect function pointer to noMoreRowImpl
     397           0 :   get_observation_row_ = [&](sdfiller::ObservationRecord &r) {return Scantable2MSReader::noMoreRowImpl<ObservationRecord>(r);};
     398             : 
     399           0 :   return true;
     400           0 : }
     401             : 
     402           0 : Bool Scantable2MSReader::getProcessorRowImpl(ProcessorRecord &/*record*/) {
     403             : //  std::cout << "Scantabl2MSReader::getProcessorRowImpl" << std::endl;
     404             : 
     405             :   // just add empty row once
     406             : 
     407             :   // only one entry so redirect function pointer to noMoreRowImpl
     408           0 :   get_processor_row_ = [&](sdfiller::ProcessorRecord &r) {return Scantable2MSReader::noMoreRowImpl<ProcessorRecord>(r);};
     409             : 
     410           0 :   return true;
     411             : }
     412             : 
     413           0 : Bool Scantable2MSReader::getSourceRowImpl(SourceRecord &record) {
     414           0 :   return getRowImplTemplate(source_iter_, record, get_source_row_);
     415             : }
     416             : 
     417           0 : Bool Scantable2MSReader::getFieldRowImpl(FieldRecord &record) {
     418           0 :   return getRowImplTemplate(field_iter_, record, get_field_row_, &field_map_);
     419             : }
     420             : 
     421           0 : Bool Scantable2MSReader::getSpectralWindowRowImpl(
     422             :     SpectralWindowRecord &record) {
     423           0 :   return getRowImplTemplate(freq_iter_, record, get_spw_row_, &num_chan_map_);
     424             : }
     425             : 
     426           0 : Bool Scantable2MSReader::getData(size_t irow, DataRecord &record) {
     427             : //  std::cout << "Scantable2MSReader::getData(irow=" << irow << ")" << std::endl;
     428             : 
     429           0 :   if (irow >= main_table_->nrow()) {
     430           0 :     return false;
     431             :   }
     432             : 
     433           0 :   constexpr double kDay2Sec = 86400.0;
     434           0 :   uInt index = sorted_rows_[irow];
     435             : //  std::cout << "Accessing row " << index << std::endl;
     436             : 
     437           0 :   time_column_.get(index, record.time);
     438           0 :   record.time *= kDay2Sec;
     439           0 :   interval_column_.get(index, record.interval);
     440             : //  std::cout << "TIME=" << record.time << " INTERVAL=" << record.interval
     441             : //      << std::endl;
     442           0 :   Int srctype = srctype_column_(index);
     443           0 :   record.intent = getIntent(srctype);
     444           0 :   record.scan = (Int) scan_column_(index);
     445           0 :   record.subscan = getSubscan(srctype);
     446           0 :   String field_name = fieldname_column_.get(index);
     447           0 :   record.field_id = field_map_[field_name];
     448           0 :   record.antenna_id = (Int) 0;
     449           0 :   direction_column_.get(index, record.direction_vector);
     450           0 :   scanrate_column_.get(index, record.scan_rate);
     451           0 :   record.feed_id = (Int) beam_column_(index);
     452           0 :   record.spw_id = (Int) ifno_column_(index);
     453             :   uInt polno;
     454           0 :   polno_column_.get(index, polno);
     455           0 :   record.pol = getPol(polno, pol_type_);
     456           0 :   record.pol_type = pol_type_;
     457             : //  std::cout << "set data size to " << num_chan_map_[record.spw_id] << " shape "
     458             : //      << record.data.shape() << std::endl;
     459           0 :   record.setDataSize(num_chan_map_[record.spw_id]);
     460           0 :   data_column_.get(index, record.data);
     461           0 :   Vector<uChar> flag = flag_column_(index);
     462           0 :   convertArray(record.flag, flag);
     463           0 :   uInt flagrow = flagrow_column_(index);
     464           0 :   Bool bflagrow = (flagrow != 0);
     465           0 :   record.flag_row = bflagrow;
     466             : 
     467           0 :   if (tsys_column_.isDefined(index)) {
     468             : //    std::cout << "set tsys size to " << tsys_column_.shape(index)[0]
     469             : //        << " shape " << record.tsys.shape() << std::endl;
     470           0 :     record.setTsysSize(tsys_column_.shape(index)[0]);
     471           0 :     Vector<Float> tsys = tsys_column_(index);
     472           0 :     if (!allEQ(tsys, 1.0f) || !allEQ(tsys, 0.0f)) {
     473           0 :       record.tsys = tsys;
     474             :     }
     475           0 :   }
     476             : 
     477           0 :   uInt tcal_id = tcal_id_column_(index);
     478           0 :   auto iter = tcal_id_map_.find(tcal_id);
     479           0 :   if (iter != tcal_id_map_.end()) {
     480           0 :     uInt tcal_row = iter->second;
     481             : //    std::cout << "set tsys size to " << tcal_column.shape(0)[0] << " shape "
     482             : //        << record.tcal.shape() << std::endl;
     483           0 :     record.setTcalSize(tcal_column_.shape(tcal_row)[0]);
     484           0 :     Vector<Float> tcal = tcal_column_(tcal_row);
     485           0 :     if (!allEQ(tcal, 1.0f) || !allEQ(tcal, 0.0f)) {
     486           0 :       record.tcal = tcal;
     487             :     }
     488           0 :   }
     489             : 
     490           0 :   uInt weather_id = weather_id_column_(index);
     491           0 :   auto iter2 = weather_id_map_.find(weather_id);
     492           0 :   if (iter2 != weather_id_map_.end()) {
     493           0 :     uInt weather_row = iter2->second;
     494           0 :     record.temperature = temperature_column_(weather_row);
     495           0 :     record.pressure = pressure_column_(weather_row);
     496           0 :     record.rel_humidity = humidity_column_(weather_row);
     497           0 :     record.wind_speed = wind_speed_column_(weather_row);
     498           0 :     record.wind_direction = wind_direction_column_(weather_row);
     499             :   }
     500             : 
     501           0 :   return true;
     502           0 : }
     503             : 
     504             : } //# NAMESPACE CASA - END