Line data    Source code

       1             : //# CalBuffer.cc: Implementation of CalBuffer.h
       2             : //# Copyright (C) 1996,1997,1998,2001,2003
       3             : //# Associated Universities, Inc. Washington DC, USA.
       4             : //#
       5             : //# This library is free software; you can redistribute it and/or modify it
       6             : //# under the terms of the GNU Library General Public License as published by
       7             : //# the Free Software Foundation; either version 2 of the License, or (at your
       8             : //# option) any later version.
       9             : //#
      10             : //# This library is distributed in the hope that it will be useful, but WITHOUT
      11             : //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
      12             : //# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
      13             : //# License for more details.
      14             : //#
      15             : //# You should have received a copy of the GNU Library General Public License
      16             : //# along with this library; if not, write to the Free Software Foundation,
      17             : //# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
      18             : //#
      19             : //# Correspondence concerning AIPS++ should be addressed as follows:
      20             : //#        Internet email: casa-feedback@nrao.edu.
      21             : //#        Postal address: AIPS++ Project Office
      22             : //#                        National Radio Astronomy Observatory
      23             : //#                        520 Edgemont Road
      24             : //#                        Charlottesville, VA 22903-2475 USA
      25             : //#
      26             : //# $Id$
      27             : //----------------------------------------------------------------------------
      28             : 
      29             : #include <synthesis/CalTables/CalBuffer.h>
      30             : 
      31             : using namespace casacore;
      32             : namespace casa { //# NAMESPACE CASA - BEGIN
      33             : 
      34             : //----------------------------------------------------------------------------
      35             : 
      36           0 : CalBuffer::CalBuffer() :
      37           0 :   connectedToIter_p(false), calMainCol_p(NULL)
      38             : {
      39             : // Null constructor
      40             : // Output to private data:
      41             : //    connectedToIter_p  Bool                 true if connected to iterator
      42             : //    calMainCol_p       CalMainColumns*      Ptr to cal main col accessor
      43             : //    time_p             Vector<Double>&      Time
      44             : //    timeMeas_p         Vector<MEpoch>&      Time as a Measure
      45             : //    timeEP_p           Vector<Double>&      Extended precision time
      46             : //    interval_p         Vector<Double>&      Time interval
      47             : //    antenna1_p         Vector<Int>&         Antenna 1
      48             : //    feed1_p            Vector<Int>&         Feed 1
      49             : //    fieldId_p          Vector<Int>&         Field id.
      50             : //    arrayId_p          Vector<Int>&         Array id.
      51             : //    obsId_p            Vector<Int>&         Observation id.
      52             : //    scanNo_p           Vector<Int>&         Scan no.
      53             : //    processorId_p      Vector<Int>&         Processor id.
      54             : //    stateId_p          Vector<Int>&         State id.
      55             : //    phaseId_p          Vector<Int>&         Phase id.
      56             : //    pulsarBin_p        Vector<Int>&         Pulsar bin
      57             : //    pulsarGateId_p     Vector<Int>&         Pulsar gate id.
      58             : //    freqGrp_p          Vector<Int>&         Frequency group
      59             : //    freqGrpName_p      Vector<String>&      Frequency group name
      60             : //    fieldName_p        Vector<String>&      Field name
      61             : //    fieldCode_p        Vector<String>&      Field code
      62             : //    sourceName_p       Vector<String>&      Source name
      63             : //    sourceCode_p       Vector<String>&      Source code
      64             : //    calGrp_p           Vector<Int>&         Calibration group
      65             : //    gain_p             Array<Complex>&      Gain
      66             : //    refAnt_p           Array<Int>&          Reference antenna
      67             : //    refFeed_p          Array<Int>&          Reference feed
      68             : //    refReceptor_p      Array<Int>&          Reference receptor
      69             : //    refFreq_p          Array<Double>&       Reference frequency
      70             : //    measFreqRef_p      Vector<Int>&         Frequency measures ref.
      71             : //    refDir_p           Array<Double>&       Reference direction
      72             : //    measDirRef_p       Vector<Int>&         Direction measures ref.
      73             : //    calDescId_p        Vector<Int>&         CAL_DESC id.
      74             : //    calHistoryId_p     Vector<Int>&         CAL_HISTORY id.
      75             : //    timeOK_p           Bool                 Time cache ok
      76             : //    timeMeasOK_p       Bool                 Time as a Measure cache ok
      77             : //    timeEPOK_p         Bool                 Extended precision time cache ok
      78             : //    intervalOK_p       Bool                 Time interval cache ok
      79             : //    antenna1OK_p       Bool                 Antenna 1 cache ok
      80             : //    feed1OK_p          Bool                 Feed 1 cache ok
      81             : //    fieldIdOK_p        Bool                 Field id. cache ok
      82             : //    arrayIdOK_p        Bool                 Array id. cache ok
      83             : //    obsIdOK_p          Bool                 Observation id. cache ok
      84             : //    scanNoOK_p         Bool                 Scan no. cache ok
      85             : //    processorIdOK_p    Bool                 Processor id. cache ok
      86             : //    stateIdOK_p        Bool                 State id. cache ok
      87             : //    phaseIdOK_p        Bool                 Phase id. cache ok
      88             : //    pulsarBinOK_p      Bool                 Pulsar bin cache ok
      89             : //    pulsarGateIdOK_p   Bool                 Pulsar gate id. cache ok
      90             : //    freqGrpOK_p        Bool                 Frequency group cache ok
      91             : //    freqGrpNameOK_p    Bool                 Frequency group name cache ok
      92             : //    fieldNameOK_p      Bool                 Field name cache ok
      93             : //    fieldCodeOK_p      Bool                 Field code cache ok
      94             : //    sourceNameOK_p     Bool                 Source name cache ok
      95             : //    sourceCodeOK_p     Bool                 Source code cache ok
      96             : //    calGrpOK_p         Bool                 Calibration group cache ok
      97             : //    gainOK_p           Bool                 Gain cache ok
      98             : //    refAntOK_p         Bool                 Reference antenna cache ok
      99             : //    refFeedOK_p        Bool                 Reference feed cache ok
     100             : //    refReceptorOK_p    Bool                 Reference receptor cache ok
     101             : //    refFreqOK_p        Bool                 Reference frequency cache ok
     102             : //    measFreqRefOK_p    Bool                 Frequency measures ref. cache ok
     103             : //    refDirOK_p         Bool                 Reference direction cache ok
     104             : //    measDirRefOK_p     Bool                 Direction measures ref. cache ok
     105             : //    calDescIdOK_p      Bool                 CAL_DESC id. cache ok
     106             : //    calHistoryIdOK_p   Bool                 CAL_HISTORY id. cache ok
     107             : //
     108             :   // Invalidate cache 
     109           0 :   invalidate();
     110           0 : };
     111             : 
     112             : //----------------------------------------------------------------------------
     113             : 
     114           0 : CalBuffer::CalBuffer (CalIterBase& calIter) :
     115           0 :   connectedToIter_p(true), calMainCol_p(NULL)
     116             : {
     117             : // Construct from a calibration table iterator
     118             : // Input:
     119             : //    calIter            CalIterBase&         Calibration table iterator
     120             : // Output to private data:
     121             : //    connectedToIter_p  Bool                 true if connected to iterator
     122             : //    calMainCol_p       CalMainColumns*      Ptr to cal main col accessor
     123             : //    time_p             Vector<Double>&      Time
     124             : //    timeMeas_p         Vector<MEpoch>&      Time as a Measure
     125             : //    timeEP_p           Vector<Double>&      Extended precision time
     126             : //    interval_p         Vector<Double>&      Time interval
     127             : //    antenna1_p         Vector<Int>&         Antenna 1
     128             : //    feed1_p            Vector<Int>&         Feed 1
     129             : //    fieldId_p          Vector<Int>&         Field id.
     130             : //    arrayId_p          Vector<Int>&         Array id.
     131             : //    obsId_p            Vector<Int>&         Observation id.
     132             : //    scanNo_p           Vector<Int>&         Scan no.
     133             : //    processorId_p      Vector<Int>&         Processor id.
     134             : //    stateId_p          Vector<Int>&         State id.
     135             : //    phaseId_p          Vector<Int>&         Phase id.
     136             : //    pulsarBin_p        Vector<Int>&         Pulsar bin
     137             : //    pulsarGateId_p     Vector<Int>&         Pulsar gate id.
     138             : //    freqGrp_p          Vector<Int>&         Frequency group
     139             : //    freqGrpName_p      Vector<String>&      Frequency group name
     140             : //    fieldName_p        Vector<String>&      Field name
     141             : //    fieldCode_p        Vector<String>&      Field code
     142             : //    sourceName_p       Vector<String>&      Source name
     143             : //    sourceCode_p       Vector<String>&      Source code
     144             : //    calGrp_p           Vector<Int>&         Calibration group
     145             : //    gain_p             Array<Complex>&      Gain
     146             : //    refAnt_p           Array<Int>&          Reference antenna
     147             : //    refFeed_p          Array<Int>&          Reference feed
     148             : //    refReceptor_p      Array<Int>&          Reference receptor
     149             : //    refFreq_p          Array<Double>&       Reference frequency
     150             : //    measFreqRef_p      Vector<Int>&         Frequency measures ref.
     151             : //    refDir_p           Array<Double>&       Reference direction
     152             : //    measDirRef_p       Vector<Int>&         Direction measures ref.
     153             : //    calDescId_p        Vector<Int>&         CAL_DESC id.
     154             : //    calHistoryId_p     Vector<Int>&         CAL_HISTORY id.
     155             : //    timeOK_p           Bool                 Time cache ok
     156             : //    timeMeasOK_p       Bool                 Time as a Measure cache ok
     157             : //    timeEPOK_p         Bool                 Extended precision time cache ok
     158             : //    intervalOK_p       Bool                 Time interval cache ok
     159             : //    antenna1OK_p       Bool                 Antenna 1 cache ok
     160             : //    feed1OK_p          Bool                 Feed 1 cache ok
     161             : //    fieldIdOK_p        Bool                 Field id. cache ok
     162             : //    arrayIdOK_p        Bool                 Array id. cache ok
     163             : //    obsIdOK_p          Bool                 Observation id. cache ok
     164             : //    scanNoOK_p         Bool                 Scan no. cache ok
     165             : //    processorIdOK_p    Bool                 Processor id. cache ok
     166             : //    stateIdOK_p        Bool                 State id. cache ok
     167             : //    phaseIdOK_p        Bool                 Phase id. cache ok
     168             : //    pulsarBinOK_p      Bool                 Pulsar bin cache ok
     169             : //    pulsarGateIdOK_p   Bool                 Pulsar gate id. cache ok
     170             : //    freqGrpOK_p        Bool                 Frequency group cache ok
     171             : //    freqGrpNameOK_p    Bool                 Frequency group name cache ok
     172             : //    fieldNameOK_p      Bool                 Field name cache ok
     173             : //    fieldCodeOK_p      Bool                 Field code cache ok
     174             : //    sourceNameOK_p     Bool                 Source name cache ok
     175             : //    sourceCodeOK_p     Bool                 Source code cache ok
     176             : //    calGrpOK_p         Bool                 Calibration group cache ok
     177             : //    gainOK_p           Bool                 Gain cache ok
     178             : //    refAntOK_p         Bool                 Reference antenna cache ok
     179             : //    refFeedOK_p        Bool                 Reference feed cache ok
     180             : //    refReceptorOK_p    Bool                 Reference receptor cache ok
     181             : //    refFreqOK_p        Bool                 Reference frequency cache ok
     182             : //    measFreqRefOK_p    Bool                 Frequency measures ref. cache ok
     183             : //    refDirOK_p         Bool                 Reference direction cache ok
     184             : //    measDirRefOK_p     Bool                 Direction measures ref. cache ok
     185             : //    calDescIdOK_p      Bool                 CAL_DESC id. cache ok
     186             : //    calHistoryIdOK_p   Bool                 CAL_HISTORY id. cache ok
     187             : //
     188             :   // Invalidate cache
     189           0 :   invalidate();
     190             : 
     191             :   // Construct the cal main column accessor
     192           0 :   calMainCol_p = new CalMainColumns (calIter.subTable());
     193           0 : };
     194             : 
     195             : //----------------------------------------------------------------------------
     196             : 
     197           0 : CalBuffer::~CalBuffer()
     198             : {
     199             : // Destructor
     200             : // Output to private data:
     201             : //    calMainCol_p       CalMainColumns*      Ptr to cal main col accessor
     202             : //
     203           0 :   if (calMainCol_p) delete calMainCol_p;
     204           0 : };
     205             : 
     206             : //----------------------------------------------------------------------------
     207             : 
     208           0 : void CalBuffer::invalidate()
     209             : {
     210             : // Invalidate the current cache
     211             : // Output to private data:
     212             : //    timeOK_p           Bool                 Time cache ok
     213             : //    timeMeasOK_p       Bool                 Time as a Measure cache ok
     214             : //    timeEPOK_p         Bool                 Extended precision time cache ok
     215             : //    intervalOK_p       Bool                 Time interval cache ok
     216             : //    antenna1OK_p       Bool                 Antenna 1 cache ok
     217             : //    feed1OK_p          Bool                 Feed 1 cache ok
     218             : //    fieldIdOK_p        Bool                 Field id. cache ok
     219             : //    arrayIdOK_p        Bool                 Array id. cache ok
     220             : //    obsIdOK_p          Bool                 Observation id. cache ok
     221             : //    scanNoOK_p         Bool                 Scan no. cache ok
     222             : //    processorIdOK_p    Bool                 Processor id. cache ok
     223             : //    stateIdOK_p        Bool                 State id. cache ok
     224             : //    phaseIdOK_p        Bool                 Phase id. cache ok
     225             : //    pulsarBinOK_p      Bool                 Pulsar bin cache ok
     226             : //    pulsarGateIdOK_p   Bool                 Pulsar gate id. cache ok
     227             : //    freqGrpOK_p        Bool                 Frequency group cache ok
     228             : //    freqGrpNameOK_p    Bool                 Frequency group name cache ok
     229             : //    fieldNameOK_p      Bool                 Field name cache ok
     230             : //    fieldCodeOK_p      Bool                 Field code cache ok
     231             : //    sourceNameOK_p     Bool                 Source name cache ok
     232             : //    sourceCodeOK_p     Bool                 Source code cache ok
     233             : //    calGrpOK_p         Bool                 Calibration group cache ok
     234             : //    gainOK_p           Bool                 Gain cache ok
     235             : //    refAntOK_p         Bool                 Reference antenna cache ok
     236             : //    refFeedOK_p        Bool                 Reference feed cache ok
     237             : //    refReceptorOK_p    Bool                 Reference receptor cache ok
     238             : //    refFreqOK_p        Bool                 Reference frequency cache ok
     239             : //    measFreqRefOK_p    Bool                 Frequency measures ref. cache ok
     240             : //    refDirOK_p         Bool                 Reference direction cache ok
     241             : //    measDirRefOK_p     Bool                 Direction measures ref. cache ok
     242             : //    calDescIdOK_p      Bool                 CAL_DESC id. cache ok
     243             : //    calHistoryIdOK_p   Bool                 CAL_HISTORY id. cache ok
     244             : //
     245             :   // Set all cache flags to false
     246           0 :   timeOK_p = false;
     247           0 :   timeMeasOK_p = false;
     248           0 :   timeEPOK_p = false;
     249           0 :   intervalOK_p = false;
     250           0 :   antenna1OK_p = false;
     251           0 :   feed1OK_p = false;
     252           0 :   fieldIdOK_p = false;
     253           0 :   arrayIdOK_p = false;
     254           0 :   obsIdOK_p = false;
     255           0 :   scanNoOK_p = false;
     256           0 :   processorIdOK_p = false;
     257           0 :   stateIdOK_p = false;
     258           0 :   phaseIdOK_p = false;
     259           0 :   pulsarBinOK_p = false;
     260           0 :   pulsarGateIdOK_p = false;
     261           0 :   freqGrpOK_p = false;
     262           0 :   freqGrpNameOK_p = false;
     263           0 :   fieldNameOK_p = false;
     264           0 :   fieldCodeOK_p = false;
     265           0 :   sourceNameOK_p = false;
     266           0 :   sourceCodeOK_p = false;
     267           0 :   calGrpOK_p = false;
     268           0 :   gainOK_p = false;
     269           0 :   refAntOK_p = false;
     270           0 :   refFeedOK_p = false;
     271           0 :   refReceptorOK_p = false;
     272           0 :   refFreqOK_p = false;
     273           0 :   measFreqRefOK_p = false;
     274           0 :   refDirOK_p = false;
     275           0 :   measDirRefOK_p = false;
     276           0 :   calDescIdOK_p = false;
     277           0 :   calHistoryIdOK_p = false;
     278           0 : };
     279             : 
     280             : //----------------------------------------------------------------------------
     281             : 
     282           0 : Vector<Double>& CalBuffer::time()
     283             : {
     284             : // TIME data field accessor
     285             : // Input from private data:
     286             : //    connectedToIter_p  Bool                 true if connected to iterator
     287             : //    time_p             Vector<Double>&      Time
     288             : //
     289             :   // Fill local cache for this column if cache not valid
     290           0 :   if (connectedToIter_p) {
     291           0 :     if (!timeOK_p) {
     292           0 :       calMainCol_p->time().getColumn (time_p);
     293           0 :       timeOK_p = true;
     294             :     };
     295             :   };
     296           0 :   return time_p;
     297             : };
     298             : 
     299             : //----------------------------------------------------------------------------
     300             : 
     301           0 : Vector<Double>& CalBuffer::timeEP()
     302             : {
     303             : // TIME_EXTRA_PREC data field accessor
     304             : // Input from private data:
     305             : //    connectedToIter_p  Bool                 true if connected to iterator
     306             : //    timeEP_p           Vector<Double>&      Time EP
     307             : //
     308             :   // Fill local cache for this column if cache not valid
     309           0 :   if (connectedToIter_p) {
     310           0 :     if (!timeEPOK_p) {
     311           0 :       calMainCol_p->timeEP().getColumn (timeEP_p);
     312           0 :       timeEPOK_p = true;
     313             :     };
     314             :   };
     315           0 :   return timeEP_p;
     316             : };
     317             : 
     318             : //----------------------------------------------------------------------------
     319             : 
     320           0 : Vector<Double>& CalBuffer::interval()
     321             : {
     322             : // INTERVAL data field accessor
     323             : // Input from private data:
     324             : //    connectedToIter_p  Bool                 true if connected to iterator
     325             : //    interval_p         Vector<Double>&      Interval
     326             : //
     327             :   // Fill local cache for this column if cache not valid
     328           0 :   if (connectedToIter_p) {
     329           0 :     if (!intervalOK_p) {
     330           0 :       calMainCol_p->interval().getColumn (interval_p);
     331           0 :       intervalOK_p = true;
     332             :     };
     333             :   };
     334           0 :   return interval_p;
     335             : };
     336             : 
     337             : //----------------------------------------------------------------------------
     338             : 
     339           0 : Vector<Int>& CalBuffer::antenna1()
     340             : {
     341             : // ANTENNA1 data field accessor
     342             : // Input from private data:
     343             : //    connectedToIter_p  Bool                 true if connected to iterator
     344             : //    antenna1_p         Vector<Int>&         Antenna1
     345             : //
     346             :   // Fill local cache for this column if cache not valid
     347           0 :   if (connectedToIter_p) {
     348           0 :     if (!antenna1OK_p) {
     349           0 :       calMainCol_p->antenna1().getColumn (antenna1_p);
     350           0 :       antenna1OK_p = true;
     351             :     };
     352             :   };
     353           0 :   return antenna1_p;
     354             : };
     355             : 
     356             : //----------------------------------------------------------------------------
     357             : 
     358           0 : Vector<Int>& CalBuffer::feed1()
     359             : {
     360             : // FEED1 data field accessor
     361             : // Input from private data:
     362             : //    connectedToIter_p  Bool                 true if connected to iterator
     363             : //    feed1_p            Vector<Int>&         Feed1
     364             : //
     365             :   // Fill local cache for this column if cache not valid
     366           0 :   if (connectedToIter_p) {
     367           0 :     if (!feed1OK_p) {
     368           0 :       calMainCol_p->feed1().getColumn (feed1_p);
     369           0 :       feed1OK_p = true;
     370             :     };
     371             :   };
     372           0 :   return feed1_p;
     373             : };
     374             : 
     375             : //----------------------------------------------------------------------------
     376             : 
     377           0 : Vector<Int>& CalBuffer::fieldId()
     378             : {
     379             : // FIELD_ID data field accessor
     380             : // Input from private data:
     381             : //    connectedToIter_p  Bool                 true if connected to iterator
     382             : //    fieldId_p          Vector<Int>&         Field id.
     383             : //
     384             :   // Fill local cache for this column if cache not valid
     385           0 :   if (connectedToIter_p) {
     386           0 :     if (!fieldIdOK_p) {
     387           0 :       calMainCol_p->fieldId().getColumn (fieldId_p);
     388           0 :       fieldIdOK_p = true;
     389             :     };
     390             :   };
     391           0 :   return fieldId_p;
     392             : };
     393             : 
     394             : //----------------------------------------------------------------------------
     395             : 
     396           0 : Vector<Int>& CalBuffer::arrayId()
     397             : {
     398             : // ARRAY_ID data field accessor
     399             : // Input from private data:
     400             : //    connectedToIter_p  Bool                 true if connected to iterator
     401             : //    arrayId_p          Vector<Int>&         Array id.
     402             : //
     403             :   // Fill local cache for this column if cache not valid
     404           0 :   if (connectedToIter_p) {
     405           0 :     if (!arrayIdOK_p) {
     406           0 :       calMainCol_p->arrayId().getColumn (arrayId_p);
     407           0 :       arrayIdOK_p = true;
     408             :     };
     409             :   };
     410           0 :   return arrayId_p;
     411             : };
     412             : 
     413             : //----------------------------------------------------------------------------
     414             : 
     415           0 : Vector<Int>& CalBuffer::obsId()
     416             : {
     417             : // OBSERVATION_ID data field accessor
     418             : // Input from private data:
     419             : //    connectedToIter_p  Bool                 true if connected to iterator
     420             : //    obsId_p            Vector<Int>&         Obs id.
     421             : //
     422             :   // Fill local cache for this column if cache not valid
     423           0 :   if (connectedToIter_p) {
     424           0 :     if (!obsIdOK_p) {
     425           0 :       calMainCol_p->obsId().getColumn (obsId_p);
     426           0 :       obsIdOK_p = true;
     427             :     };
     428             :   };
     429           0 :   return obsId_p;
     430             : };
     431             : 
     432             : //----------------------------------------------------------------------------
     433             : 
     434           0 : Vector<Int>& CalBuffer::scanNo()
     435             : {
     436             : // SCAN_NUMBER data field accessor
     437             : // Input from private data:
     438             : //    connectedToIter_p  Bool                 true if connected to iterator
     439             : //    scanNo_p           Vector<Int>&         Scan no.
     440             : //
     441             :   // Fill local cache for this column if cache not valid
     442           0 :   if (connectedToIter_p) {
     443           0 :     if (!scanNoOK_p) {
     444           0 :       calMainCol_p->scanNo().getColumn (scanNo_p);
     445           0 :       scanNoOK_p = true;
     446             :     };
     447             :   };
     448           0 :   return scanNo_p;
     449             : };
     450             : 
     451             : //----------------------------------------------------------------------------
     452             : 
     453           0 : Vector<Int>& CalBuffer::processorId()
     454             : {
     455             : // PROCESSOR_ID data field accessor
     456             : // Input from private data:
     457             : //    connectedToIter_p  Bool                 true if connected to iterator
     458             : //    processorId_p      Vector<Int>&         Processor id.
     459             : //
     460             :   // Fill local cache for this column if cache not valid
     461           0 :   if (connectedToIter_p) {
     462           0 :     if (!processorIdOK_p) {
     463           0 :       calMainCol_p->processorId().getColumn (processorId_p);
     464           0 :       processorIdOK_p = true;
     465             :     };
     466             :   };
     467           0 :   return processorId_p;
     468             : };
     469             : 
     470             : //----------------------------------------------------------------------------
     471             : 
     472           0 : Vector<Int>& CalBuffer::stateId()
     473             : {
     474             : // STATE_ID data field accessor
     475             : // Input from private data:
     476             : //    connectedToIter_p  Bool                 true if connected to iterator
     477             : //    stateId_p          Vector<Int>&         State id.
     478             : //
     479             :   // Fill local cache for this column if cache not valid
     480           0 :   if (connectedToIter_p) {
     481           0 :     if (!stateIdOK_p) {
     482           0 :       calMainCol_p->stateId().getColumn (stateId_p);
     483           0 :       stateIdOK_p = true;
     484             :     };
     485             :   };
     486           0 :   return stateId_p;
     487             : };
     488             : 
     489             : //----------------------------------------------------------------------------
     490             : 
     491           0 : Vector<Int>& CalBuffer::phaseId()
     492             : {
     493             : // PHASE_ID data field accessor
     494             : // Input from private data:
     495             : //    connectedToIter_p  Bool                 true if connected to iterator
     496             : //    phaseId_p          Vector<Int>&         Phase id.
     497             : //
     498             :   // Fill local cache for this column if cache not valid
     499           0 :   if (connectedToIter_p) {
     500           0 :     if (!phaseIdOK_p) {
     501           0 :       calMainCol_p->phaseId().getColumn (phaseId_p);
     502           0 :       phaseIdOK_p = true;
     503             :     };
     504             :   };
     505           0 :   return phaseId_p;
     506             : };
     507             : 
     508             : //----------------------------------------------------------------------------
     509             : 
     510           0 : Vector<Int>& CalBuffer::pulsarBin()
     511             : {
     512             : // PULSAR_BIN data field accessor
     513             : // Input from private data:
     514             : //    connectedToIter_p  Bool                 true if connected to iterator
     515             : //    pulsarBin_p        Vector<Int>&         Pulsar bin
     516             : //
     517             :   // Fill local cache for this column if cache not valid
     518           0 :   if (connectedToIter_p) {
     519           0 :     if (!pulsarBinOK_p) {
     520           0 :       calMainCol_p->pulsarBin().getColumn (pulsarBin_p);
     521           0 :       pulsarBinOK_p = true;
     522             :     };
     523             :   };
     524           0 :   return pulsarBin_p;
     525             : };
     526             : 
     527             : //----------------------------------------------------------------------------
     528             : 
     529           0 : Vector<Int>& CalBuffer::pulsarGateId()
     530             : {
     531             : // PULSAR_GATE_ID data field accessor
     532             : // Input from private data:
     533             : //    connectedToIter_p  Bool                 true if connected to iterator
     534             : //    pulsarGateId_p     Vector<Int>&         Pulsar gate id.
     535             : //
     536             :   // Fill local cache for this column if cache not valid
     537           0 :   if (connectedToIter_p) {
     538           0 :     if (!pulsarGateIdOK_p) {
     539           0 :       calMainCol_p->pulsarGateId().getColumn (pulsarGateId_p);
     540           0 :       pulsarGateIdOK_p = true;
     541             :     };
     542             :   };
     543           0 :   return pulsarGateId_p;
     544             : };
     545             : 
     546             : //----------------------------------------------------------------------------
     547             : 
     548           0 : Vector<Int>& CalBuffer::freqGrp()
     549             : {
     550             : // FREQ_GROUP data field accessor
     551             : // Input from private data:
     552             : //    connectedToIter_p  Bool                 true if connected to iterator
     553             : //    freqGrp_p          Vector<Int>&         Frequency group
     554             : //
     555             :   // Fill local cache for this column if cache not valid
     556           0 :   if (connectedToIter_p) {
     557           0 :     if (!freqGrpOK_p) {
     558           0 :       calMainCol_p->freqGrp().getColumn (freqGrp_p);
     559           0 :       freqGrpOK_p = true;
     560             :     };
     561             :   };
     562           0 :   return freqGrp_p;
     563             : };
     564             : 
     565             : //----------------------------------------------------------------------------
     566             : 
     567           0 : Vector<String>& CalBuffer::freqGrpName()
     568             : {
     569             : // FREQ_GROUP_NAME data field accessor
     570             : // Input from private data:
     571             : //    connectedToIter_p  Bool                 true if connected to iterator
     572             : //    freqGrpName_p      Vector<String>&      Frequency group name
     573             : //
     574             :   // Fill local cache for this column if cache not valid
     575           0 :   if (connectedToIter_p) {
     576           0 :     if (!freqGrpNameOK_p) {
     577           0 :       calMainCol_p->freqGrpName().getColumn (freqGrpName_p);
     578           0 :       freqGrpNameOK_p = true;
     579             :     };
     580             :   };
     581           0 :   return freqGrpName_p;
     582             : };
     583             : 
     584             : //----------------------------------------------------------------------------
     585             : 
     586           0 : Vector<String>& CalBuffer::fieldName()
     587             : {
     588             : // FIELD_NAME data field accessor
     589             : // Input from private data:
     590             : //    connectedToIter_p  Bool                 true if connected to iterator
     591             : //    fieldName_p        Vector<String>&      Field name
     592             : //
     593             :   // Fill local cache for this column if cache not valid
     594           0 :   if (connectedToIter_p) {
     595           0 :     if (!fieldNameOK_p) {
     596           0 :       calMainCol_p->fieldName().getColumn (fieldName_p);
     597           0 :       fieldNameOK_p = true;
     598             :     };
     599             :   };
     600           0 :   return fieldName_p;
     601             : };
     602             : 
     603             : //----------------------------------------------------------------------------
     604             : 
     605           0 : Vector<String>& CalBuffer::fieldCode()
     606             : {
     607             : // FIELD_CODE data field accessor
     608             : // Input from private data:
     609             : //    connectedToIter_p  Bool                 true if connected to iterator
     610             : //    fieldCode_p        Vector<String>&      Field code
     611             : //
     612             :   // Fill local cache for this column if cache not valid
     613           0 :   if (connectedToIter_p) {
     614           0 :     if (!fieldCodeOK_p) {
     615           0 :       calMainCol_p->fieldCode().getColumn (fieldCode_p);
     616           0 :       fieldCodeOK_p = true;
     617             :     };
     618             :   };
     619           0 :   return fieldCode_p;
     620             : };
     621             : 
     622             : //----------------------------------------------------------------------------
     623             : 
     624           0 : Vector<String>& CalBuffer::sourceCode()
     625             : {
     626             : // FIELD_CODE data field accessor
     627             : // Input from private data:
     628             : //    connectedToIter_p  Bool                 true if connected to iterator
     629             : //    sourceCode_p       Vector<String>&      Source code
     630             : //
     631             :   // Fill local cache for this column if cache not valid
     632           0 :   if (connectedToIter_p) {
     633           0 :     if (!sourceCodeOK_p) {
     634           0 :       calMainCol_p->sourceCode().getColumn (sourceCode_p);
     635           0 :       sourceCodeOK_p = true;
     636             :     };
     637             :   };
     638           0 :   return sourceCode_p;
     639             : };
     640             : 
     641             : //----------------------------------------------------------------------------
     642             : 
     643           0 : Vector<Int>& CalBuffer::calGrp()
     644             : {
     645             : // CALIBRATION_GROUP data field accessor
     646             : // Input from private data:
     647             : //    connectedToIter_p  Bool                 true if connected to iterator
     648             : //    calGrp_p          Vector<Int>&          Calibration group
     649             : //
     650             :   // Fill local cache for this column if cache not valid
     651           0 :   if (connectedToIter_p) {
     652           0 :     if (!calGrpOK_p) {
     653           0 :       calMainCol_p->calGrp().getColumn (calGrp_p);
     654           0 :       calGrpOK_p = true;
     655             :     };
     656             :   };
     657           0 :   return calGrp_p;
     658             : };
     659             : 
     660             : //----------------------------------------------------------------------------
     661             : 
     662           0 : Array<Complex>& CalBuffer::gain()
     663             : {
     664             : // GAIN data field accessor
     665             : // Input from private data:
     666             : //    connectedToIter_p  Bool                 true if connected to iterator
     667             : //    gain_p             Array<Complex>&      Calibration gain
     668             : //
     669             :   // Fill local cache for this column if cache not valid
     670           0 :   if (connectedToIter_p) {
     671           0 :     if (!gainOK_p) {
     672           0 :       calMainCol_p->gain().getColumn (gain_p);
     673           0 :       gainOK_p = true;
     674             :     };
     675             :   };
     676           0 :   return gain_p;
     677             : };
     678             : 
     679             : //----------------------------------------------------------------------------
     680             : 
     681           0 : Array<Int>& CalBuffer::refAnt()
     682             : {
     683             : // REF_ANT data field accessor
     684             : // Input from private data:
     685             : //    connectedToIter_p  Bool                 true if connected to iterator
     686             : //    refAnt_p           Array<Int>&          Reference antenna
     687             : //
     688             :   // Fill local cache for this column if cache not valid
     689           0 :   if (connectedToIter_p) {
     690           0 :     if (!refAntOK_p) {
     691           0 :       calMainCol_p->refAnt().getColumn (refAnt_p);
     692           0 :       refAntOK_p = true;
     693             :     };
     694             :   };
     695           0 :   return refAnt_p;
     696             : };
     697             : 
     698             : //----------------------------------------------------------------------------
     699             : 
     700           0 : Array<Int>& CalBuffer::refFeed()
     701             : {
     702             : // REF_FEED data field accessor
     703             : // Input from private data:
     704             : //    connectedToIter_p  Bool                 true if connected to iterator
     705             : //    refFeed_p          Array<Int>&          Reference feed
     706             : //
     707             :   // Fill local cache for this column if cache not valid
     708           0 :   if (connectedToIter_p) {
     709           0 :     if (!refFeedOK_p) {
     710           0 :       calMainCol_p->refFeed().getColumn (refFeed_p);
     711           0 :       refFeedOK_p = true;
     712             :     };
     713             :   };
     714           0 :   return refFeed_p;
     715             : };
     716             : 
     717             : //----------------------------------------------------------------------------
     718             : 
     719           0 : Array<Int>& CalBuffer::refReceptor()
     720             : {
     721             : // REF_FEED data field accessor
     722             : // Input from private data:
     723             : //    connectedToIter_p  Bool                 true if connected to iterator
     724             : //    refReceptor_p      Array<Int>&          Reference receptor
     725             : //
     726             :   // Fill local cache for this column if cache not valid
     727           0 :   if (connectedToIter_p) {
     728           0 :     if (!refReceptorOK_p) {
     729           0 :       calMainCol_p->refReceptor().getColumn (refReceptor_p);
     730           0 :       refReceptorOK_p = true;
     731             :     };
     732             :   };
     733           0 :   return refReceptor_p;
     734             : };
     735             : 
     736             : //----------------------------------------------------------------------------
     737             : 
     738           0 : Array<Double>& CalBuffer::refFreq()
     739             : {
     740             : // REF_FREQUENCY data field accessor
     741             : // Input from private data:
     742             : //    connectedToIter_p  Bool                 true if connected to iterator
     743             : //    refFreq_p      Array<Double>&           Reference frequency
     744             : //
     745             :   // Fill local cache for this column if cache not valid
     746           0 :   if (connectedToIter_p) {
     747           0 :     if (!refFreqOK_p) {
     748           0 :       calMainCol_p->refFreq().getColumn (refFreq_p);
     749           0 :       refFreqOK_p = true;
     750             :     };
     751             :   };
     752           0 :   return refFreq_p;
     753             : };
     754             : 
     755             : //----------------------------------------------------------------------------
     756             : 
     757           0 : Vector<Int>& CalBuffer::measFreqRef()
     758             : {
     759             : // REF_FEED data field accessor
     760             : // Input from private data:
     761             : //    connectedToIter_p  Bool                 true if connected to iterator
     762             : //    measFreqRef_p      Vector<Int>&         Reference frequency frame
     763             : //
     764             :   // Fill local cache for this column if cache not valid
     765           0 :   if (connectedToIter_p) {
     766           0 :     if (!measFreqRefOK_p) {
     767           0 :       calMainCol_p->measFreqRef().getColumn (measFreqRef_p);
     768           0 :       measFreqRefOK_p = true;
     769             :     };
     770             :   };
     771           0 :   return measFreqRef_p;
     772             : };
     773             : 
     774             : //----------------------------------------------------------------------------
     775             : 
     776           0 : Array<Double>& CalBuffer::refDir()
     777             : {
     778             : // REF_DIRECTION data field accessor
     779             : // Input from private data:
     780             : //    connectedToIter_p  Bool                 true if connected to iterator
     781             : //    refDir_p      Array<Double>&            Reference direction
     782             : //
     783             :   // Fill local cache for this column if cache not valid
     784           0 :   if (connectedToIter_p) {
     785           0 :     if (!refDirOK_p) {
     786           0 :       calMainCol_p->refDir().getColumn (refDir_p);
     787           0 :       refDirOK_p = true;
     788             :     };
     789             :   };
     790           0 :   return refDir_p;
     791             : };
     792             : 
     793             : //----------------------------------------------------------------------------
     794             : 
     795           0 : Vector<Int>& CalBuffer::measDirRef()
     796             : {
     797             : // REF_DIRECTION data field accessor
     798             : // Input from private data:
     799             : //    connectedToIter_p  Bool                 true if connected to iterator
     800             : //    measDirRef_p      Vector<Int>&          Reference direction frame
     801             : //
     802             :   // Fill local cache for this column if cache not valid
     803           0 :   if (connectedToIter_p) {
     804           0 :     if (!measDirRefOK_p) {
     805           0 :       calMainCol_p->measDirRef().getColumn (measDirRef_p);
     806           0 :       measDirRefOK_p = true;
     807             :     };
     808             :   };
     809           0 :   return measDirRef_p;
     810             : };
     811             : 
     812             : //----------------------------------------------------------------------------
     813             : 
     814           0 : Vector<Int>& CalBuffer::calDescId()
     815             : {
     816             : // CAL_DESC_ID data field accessor
     817             : // Input from private data:
     818             : //    connectedToIter_p  Bool                 true if connected to iterator
     819             : //    calDescId_p        Vector<Int>&         Calibration format descriptor
     820             : //
     821             :   // Fill local cache for this column if cache not valid
     822           0 :   if (connectedToIter_p) {
     823           0 :     if (!calDescIdOK_p) {
     824           0 :       calMainCol_p->calDescId().getColumn (calDescId_p);
     825           0 :       calDescIdOK_p = true;
     826             :     };
     827             :   };
     828           0 :   return calDescId_p;
     829             : };
     830             : 
     831             : //----------------------------------------------------------------------------
     832             : 
     833           0 : Vector<Int>& CalBuffer::calHistoryId()
     834             : {
     835             : // CAL_HISTORY_ID data field accessor
     836             : // Input from private data:
     837             : //    connectedToIter_p  Bool                 true if connected to iterator
     838             : //    calHistoryId_p     Vector<Int>&         Calibration history identifier
     839             : //
     840             :   // Fill local cache for this column if cache not valid
     841           0 :   if (connectedToIter_p) {
     842           0 :     if (!calHistoryIdOK_p) {
     843           0 :       calMainCol_p->calHistoryId().getColumn (calHistoryId_p);
     844           0 :       calHistoryIdOK_p = true;
     845             :     };
     846             :   };
     847           0 :   return calHistoryId_p;
     848             : };
     849             : 
     850             : //----------------------------------------------------------------------------
     851             : 
     852             : 
     853             : } //# NAMESPACE CASA - END
     854             :