Ignore:
Timestamp:
09/16/11 14:09:32 (13 years ago)
Author:
Takeshi Nakazato
Message:

New Development: No

JIRA Issue: Yes CAS-1913

Ready for Test: Yes

Interface Changes: No

What Interface Changed: Please list interface changes

Test Programs: test_importasdm_sd

Put in Release Notes: Yes/No

Module(s): Module Names change impacts.

Description: Describe your changes here...

Merged refactoring the code in trunk (r2301).


Location:
branches/casa-prerelease/pre-asap
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • branches/casa-prerelease/pre-asap

    • Property svn:mergeinfo changed
      /trunk (added)merged: 2301

  • branches/casa-prerelease/pre-asap/external-alma

  • branches/casa-prerelease/pre-asap/external-alma/asdm2ASAP/ASDMFiller.cc

    r2273 r2302  
    103103
    104104  // CYCLENO
    105   unsigned int cycleno = 0 ;
     105  //unsigned int cycleno = 0 ;
     106  map< unsigned int, unsigned int > cycleno ;
     107  map< unsigned int, unsigned int >::iterator citer ;
    106108
    107109  for ( unsigned int ifield = 0 ; ifield < numFieldId ; ifield++ ) {
    … …  
    130132
    131133        // scan and subscan
    132         unsigned int scanno = reader_->getScanNo() ;
     134        //unsigned int scanno = reader_->getScanNo() ;
     135        unsigned int scanno = reader_->getScanNoOfCurrentRow() ;
    133136        //uInt subscanno = reader_->getSubscanNo() ;
     137        citer = cycleno.find( scanno ) ;
     138        if ( citer == cycleno.end() )
     139          cycleno[scanno] = 0 ;
    134140
    135141        // set data
    … …  
    147153
    148154        for ( unsigned int idata = 0 ; idata < numData ; idata++ ) {
     155          // prepare to extract binary data
     156          reader_->prepareData( idata ) ;
    149157
    150158          // subscan number
    151           unsigned int subscanno = reader_->getSubscanNo( idata ) ;
     159          //unsigned int subscanno = reader_->getSubscanNo( idata ) ;
     160          unsigned int subscanno = reader_->getSubscanNo() ;
    152161
    153162          // IFNO
    154           uInt ifno = reader_->getIFNo( idata ) ;
    155 
    156           // rest frequency
    157           vector<double> rf = reader_->getRestFrequency( idata ) ;
     163          //uInt ifno = reader_->getIFNo( idata ) ;
     164          uInt ifno = reader_->getIFNo() ;
     165
     166          // source spec
     167          int srctype = reader_->getSrcType( scanno, subscanno ) ;
     168          string srcname ;
     169          string fieldname ;
     170          vector<double> srcDirection ;
     171          vector<double> srcProperMotion ;
     172          double sysVel ;
     173          vector<double> rf ;
     174          //reader_->getSourceProperty( idata,
     175          //                            srcname,
     176          //                            fieldname,
     177          //                            srcDirection,
     178          //                            srcProperMotion,
     179          //                            sysVel,
     180          //                            rf ) ;
     181          reader_->getSourceProperty( srcname,
     182                                      fieldname,
     183                                      srcDirection,
     184                                      srcProperMotion,
     185                                      sysVel,
     186                                      rf ) ;
    158187         
    159188          // fill MOLECULE_ID and add MOLECULES row if necessary
    … …  
    164193         
    165194          // time and interval
    166           casa::Double mjd = (casa::Double)(reader_->getTime( idata )) ;
    167           casa::Double interval = (casa::Double)(reader_->getInterval( idata )) ;
     195          //casa::Double mjd = (casa::Double)(reader_->getTime( idata )) ;
     196          //casa::Double interval = (casa::Double)(reader_->getInterval( idata )) ;
     197          casa::Double mjd = (casa::Double)(reader_->getTime()) ;
     198          casa::Double interval = (casa::Double)(reader_->getInterval()) ;
    168199
    169200          // fill TIME and INTERVAL
    170201          setTime( mjd, interval ) ;
    171 
    172 
    173           // source spec
    174           string srcname = reader_->getSourceName( idata ) ;
    175           string fieldname = reader_->getFieldName( idata ) ;
    176           int srctype = reader_->getSrcType( scanno, subscanno ) ;
    177           vector<double> srcDirection = reader_->getSourceDirection( idata ) ;
    178           //vector<double> srcDirection ;
    179           //string srcDirRef ;
    180           //reader_->getSourceDirection( idata, srcDirection, srcDirRef ) ;
    181           vector<double> srcProperMotion = reader_->getSourceProperMotion( idata ) ;
    182           double sysVel = reader_->getSysVel( idata ) ;
    183202         
    184203          // fill SRCNAME, SRCTYPE, FIELDNAME, SRCDIRECTION, SRCPROPERMOTION, and SRCVELOCITY
    … …  
    192211
    193212          // fill FLAGROW
    194           unsigned int flagrow = reader_->getFlagRow( idata ) ;
     213          //unsigned int flagrow = reader_->getFlagRow( idata ) ;
     214          unsigned int flagrow = reader_->getFlagRow() ;
    195215          setFlagrow( (uInt)flagrow ) ;
    196216
    … …  
    201221          float windspeed ;
    202222          float windaz ;
    203           reader_->getWeatherInfo( idata,
    204                                    temperature,
     223          //reader_->getWeatherInfo( idata,
     224          //                         temperature,
     225          //                         pressure,
     226          //                         humidity,
     227          //                         windspeed,
     228          //                         windaz ) ;
     229          reader_->getWeatherInfo( temperature,
    205230                                   pressure,
    206231                                   humidity,
    … …  
    218243          double el ;
    219244          vector<double> srate ;
    220           reader_->getPointingInfo( idata,
    221                                     dir,
     245          //reader_->getPointingInfo( idata,
     246          //                          dir,
     247          //                          az,
     248          //                          el,
     249          //                          srate ) ;
     250          reader_->getPointingInfo( dir,
    222251                                    az,
    223252                                    el,
    … …  
    246275          }
    247276          else {
    248             reader_->getFrequency( idata, refpix, refval, incr, freqref ) ;
     277            //reader_->getFrequency( idata, refpix, refval, incr, freqref ) ;
     278            reader_->getFrequency( refpix, refval, incr, freqref ) ;
    249279            refval = (double)toLSRK( casa::Double(refval),
    250280                                     String(freqref),
    … …  
    261291
    262292          // loop on polarization
    263           vector<unsigned int> dataShape = reader_->getDataShape( idata ) ;
     293          //vector<unsigned int> dataShape = reader_->getDataShape( idata ) ;
     294          vector<unsigned int> dataShape = reader_->getDataShape() ;
    264295//           ostringstream oss ;
    265296//           for ( unsigned int i = 0 ; i < dataShape.size() ; i++ ) {
    … …  
    280311
    281312          // OPACITY
    282           vector<float> tau = reader_->getOpacity( idata ) ;
     313          //vector<float> tau = reader_->getOpacity( idata ) ;
     314          vector<float> tau = reader_->getOpacity() ;
    283315          Vector<casa::Float> opacity = toVector( tau, numPol ) ;
    284316
    285317          // SPECTRA, FLAGTRA, TSYS, TCAL
    286           float *sp = reader_->getSpectrum( idata ) ;
     318          //float *sp = reader_->getSpectrum( idata ) ;
     319          float *sp = reader_->getSpectrum() ;
    287320          vector< vector<float> > ts ;
    288321          vector< vector<float> > tc ;
    289           reader_->getTcalAndTsys( idata, tc, ts ) ;
     322          //reader_->getTcalAndTsys( idata, tc, ts ) ;
     323          reader_->getTcalAndTsys( tc, ts ) ;
    290324          Matrix<casa::Float> spectra = toMatrix( sp, numPol, numChan ) ;
    291325          Vector<uChar> flagtra( numChan, 0 ) ;
    … …  
    300334
    301335            // fill SCANNO, CYCLENO, IFNO, POLNO, and BEAMNO
    302             setIndex( (uInt)scanno-1, (uInt)cycleno, ifno, ipol, beamno ) ;
     336            setIndex( (uInt)scanno-1, (uInt)cycleno[scanno], ifno, ipol, beamno ) ;
    303337
    304338            // fill SPECTRA, FLAGTRA, TSYS
    … …  
    316350
    317351          // increment CYCLENO
    318           cycleno++ ;
     352          cycleno[scanno]++ ;
    319353        }
    320354      }

  • branches/casa-prerelease/pre-asap/external-alma/asdm2ASAP/ASDMReader.cc

    r2299 r2302  
    11#include <iostream>
    22#include <sstream>
     3#include "limits.h"
     4#include "float.h"
    35
    46#include <measures/Measures/MEpoch.h>
    … …  
    2830    antennaId_( -1 ),
    2931    antennaName_( "" ),
     32    stationName_( "" ),
    3033    row_(-1),
    3134    apc_(AP_CORRECTED),
    32     className_("ASDMReader")
     35    className_("ASDMReader"),
     36    dataIndex_( UINT_MAX ),
     37    //antennaRow_p( 0 ),
     38    //stationRow_p( 0 ),
     39    specWinRow_p( 0 ),
     40    polarizationRow_p( 0 ),
     41    fieldRow_p( 0 )
    3342{
    3443  configDescIdList_.resize(0) ;
    … …  
    166175  // create ASDM object
    167176  asdm_ = new ASDM() ;
    168   // avoid unwanted message to stdout
    169   //ostringstream oss ;
    170   //streambuf *buforg = cout.rdbuf(oss.rdbuf()) ;
    171177  asdm_->setFromFile( filename ) ;
    172   //cout.rdbuf(buforg) ;
    173 
     178
     179  AntennaTable &atab = asdm_->getAntenna() ;
     180  AntennaRow *antennaRow ;
    174181  if ( antennaId_ == -1 ) {
    175     AntennaTable &atab = asdm_->getAntenna() ;
    176182    vector<AntennaRow *> rows = atab.get() ;
    177183    int idx = -1 ;
    … …  
    189195      antennaId_ = idx ;
    190196    }
    191   }
     197    antennaTag_ = Tag( antennaId_, TagType::Antenna ) ;
     198    antennaRow = rows[antennaId_] ;
     199  }
     200  else {
     201    antennaTag_ = Tag( antennaId_, TagType::Antenna ) ;
     202    antennaRow = atab.getRowByKey( antennaTag_ ) ;
     203    if ( antennaRow == 0 ) {
     204      close() ;
     205      throw (casa::AipsError( "AntennaId " + casa::String::toString(antennaId_) + " is invalid." ) ) ;
     206    }
     207  }
     208 
    192209
    193210  // set antenna name
    194211  if ( antennaName_.size() == 0 ) {
    195     AntennaTable &atab = asdm_->getAntenna() ;
    196     Tag tag( antennaId_, TagType::Antenna ) ;
    197     AntennaRow *arow = atab.getRowByKey( tag ) ;
    198     if ( arow == 0 ) {
    199       close() ;
    200       throw (casa::AipsError( tag.toString() + " not found." )) ;
    201     }
    202     else {
    203       antennaName_ = casa::String( arow->getName() ) ;
    204     }
    205   }
     212    antennaName_ = casa::String( antennaRow->getName() ) ;
     213  }
     214
     215  // get Station row
     216  StationRow *stationRow = antennaRow->getStationUsingStationId() ;
     217
     218  // station name
     219  stationName_ = casa::String( stationRow->getName() ) ;
     220
     221  // antenna position
     222  antennaPosition_.resize( 3 ) ;
     223  vector<Length> antpos = stationRow->getPosition() ;
     224  for ( casa::uInt i = 0 ; i < 3 ; i++ )
     225    antennaPosition_[i] = Quantity( casa::Double( antpos[i].get() ), Unit( "m" ) ) ;
    206226
    207227  // create SDMBinData object
    … …  
    266286  ExecBlockRow *ebrow = ebtab.get()[0] ;
    267287  casa::String telescopeName( ebrow->getTelescopeName() ) ;
    268   AntennaTable &atab = asdm_->getAntenna() ;
    269   AntennaRow *arow = atab.getRowByKey( Tag( antennaId_, TagType::Antenna ) ) ;
    270   //StationTable &stab = asdm_->getStation() ;
    271   //StationRow *srow = stab.getRowByKey( arow->getStationId() ) ;
    272   StationRow *srow = arow->getStationUsingStationId() ;
    273   casa::String stationName( srow->getName() ) ;
     288  //casa::String stationName( stationRow_p->getName() ) ;
    274289
    275290  // antennaname
    276291  // <telescopeName>//<antennaName>@stationName
    277   antennaname = telescopeName + "//" + antennaName_ + "@" + stationName ;
     292  antennaname = telescopeName + "//" + antennaName_ + "@" + stationName_ ;
    278293  //logsink_->postLocally( LogMessage("antennaName = "+antennaname,LogOrigin(className_,funcName,WHERE)) ) ;
    279294
    280295  // antennaposition
    281   //vector<Length> antpos = arow->getPosition() ;
    282   vector<Length> antpos = srow->getPosition() ;
    283296  antennaposition.resize( 3 ) ;
    284297  for ( casa::uInt i = 0 ; i < 3 ; i++ )
    285     antennaposition[i] = casa::Double( antpos[i].get() ) ;
     298    antennaposition[i] = antennaPosition_[i].getValue( Unit("m") ) ;
    286299
    287300  // observer
    … …  
    521534  casa::Bool status = true ;
    522535  row_ = irow ;
     536  execBlockTag_ = mainRow_[row_]->getExecBlockId() ;
    523537
    524538  unsigned int cdid = mainRow_[row_]->getConfigDescriptionId().getTagValue() ;
    … …  
    579593    return false ;
    580594}
    581 
    582 // casa::Vector<casa::uInt> ASDMReader::getDataDescIdList( casa::uInt cdid )
    583 // {
    584 //   Tag cdTag( (unsigned int)cdid, TagType::ConfigDescription ) ;
    585 //   ConfigDescriptionRow *cdrow = asdm_->getConfigDescription().getRowByKey( cdTag ) ;
    586 //   vector<Tag> ddTags = cdrow->getDataDescriptionId() ;
    587 //   casa::Vector<casa::uInt> ddidList( ddTags.size() ) ;
    588 //   for ( unsigned int idd = 0 ; idd < ddTags.size() ; idd++ ) {
    589 //     ddidList[idd] = ddTags[idd].getTagValue() ;
    590 //   }
    591 //   return ddidList ;
    592 // }
    593 
    594 // casa::Vector<casa::uInt> ASDMReader::getSwitchCycleIdList( casa::uInt cdid )
    595 // {
    596 //   Tag cdTag( (unsigned int)cdid, TagType::ConfigDescription ) ;
    597 //   ConfigDescriptionRow *cdrow = asdm_->getConfigDescription().getRowByKey( cdTag ) ;
    598 //   vector<Tag> scTags = cdrow->getSwitchCycleId() ;
    599 //   casa::Vector<casa::uInt> scidList( scTags.size() ) ;
    600 //   for ( unsigned int idd = 0 ; idd < scTags.size() ; idd++ ) {
    601 //     scidList[idd] = scTags[idd].getTagValue() ;
    602 //   }
    603 //   return scidList ;
    604 // }
    605 
    606 // casa::Vector<casa::uInt> ASDMReader::getFeedIdList( casa::uInt cdid )
    607 // {
    608 //   casa::String funcName = "getFeedIdList" ;
    609 //   
    610 //   Tag cdTag( (unsigned int)cdid, TagType::ConfigDescription ) ;
    611 //   ConfigDescriptionRow *cdrow = asdm_->getConfigDescription().getRowByKey( cdTag ) ;
    612 //   casa::Vector<casa::uInt> feedIdList ;
    613 //   vector<int> feedIds = cdrow->getFeedId() ;
    614 //   for ( unsigned int ife = 0 ; ife < feedIds.size() ; ife++ ) {
    615 //     logsink_->postLocally( LogMessage("feedIds["+String::toString(ife)+"]="+String::toString(feedIds[ife]),LogOrigin(className_,funcName,WHERE)) ) ;
    616 //     if ( casa::anyEQ( feedIdList, casa::uInt( feedIds[ife] ) ) )
    617 //       continue ;
    618 //     if ( casa::anyEQ( feedIdList_, casa::uInt( feedIds[ife] ) ) ) {
    619 //       casa::uInt oldsize = feedIdList.size() ;
    620 //       feedIdList.resize( oldsize+1, true ) ;
    621 //       feedIdList[oldsize] = casa::uInt( feedIds[ife] ) ;
    622 //     }
    623 //   }
    624 //   logsink_->postLocally( LogMessage("feedIdList.size() = "+String::toString(feedIdList.size()),LogOrigin(className_,funcName,WHERE)) ) ;
    625 //   return feedIdList ;
    626 // }
    627595
    628596casa::Bool ASDMReader::setData()
    … …  
    686654}
    687655
     656void ASDMReader::prepareData( unsigned int idx )
     657{
     658  unsigned int i = dataIdList_[idx] ;
     659  if ( i != dataIndex_ ) {
     660    dataIndex_ = dataIdList_[idx] ;
     661    Tag dataDescTag( vmsData_->v_dataDescId[dataIndex_], TagType::DataDescription ) ;
     662    DataDescriptionRow *dataDescRow = asdm_->getDataDescription().getRowByKey( dataDescTag ) ;
     663    specWinTag_ = dataDescRow->getSpectralWindowId() ;
     664    specWinRow_p = dataDescRow->getSpectralWindowUsingSpectralWindowId() ;
     665    polarizationRow_p = dataDescRow->getPolarizationUsingPolOrHoloId() ;
     666    Tag fieldTag( vmsData_->v_fieldId[dataIndex_], TagType::Field ) ;
     667    fieldRow_p = asdm_->getField().getRowByKey( fieldTag ) ;
     668    double startSec = vmsData_->v_time[dataIndex_] - 0.5 * vmsData_->v_interval[dataIndex_] ;
     669    timeInterval_ = ArrayTimeInterval( startSec*s2d, vmsData_->v_interval[dataIndex_]*s2d ) ;
     670  }
     671}
     672
    688673casa::uInt ASDMReader::getIFNo( unsigned int idx )
    689674{
    690   Tag ddTag( vmsData_->v_dataDescId[dataIdList_[idx]], TagType::DataDescription ) ;
    691   DataDescriptionRow *ddrow = asdm_->getDataDescription().getRowByKey( ddTag ) ;
    692   Tag spwid = ddrow->getSpectralWindowId() ;
    693   map<Tag,casa::uInt>::iterator iter = ifno_.find( spwid ) ;
     675  prepareData( idx ) ;
     676  return getIFNo() ;
     677}
     678
     679casa::uInt ASDMReader::getIFNo()
     680{
     681  map<Tag,casa::uInt>::iterator iter = ifno_.find( specWinTag_ ) ;
    694682  if ( iter != ifno_.end() )
    695683    return iter->second ;
    … …  
    701689int ASDMReader::getNumPol( unsigned int idx )
    702690{
    703   Tag ddTag( vmsData_->v_dataDescId[dataIdList_[idx]], TagType::DataDescription ) ;
    704   DataDescriptionRow *ddrow = asdm_->getDataDescription().getRowByKey( ddTag ) ;
    705   PolarizationRow *polrow = ddrow->getPolarizationUsingPolOrHoloId() ;
    706   return polrow->getNumCorr() ;
     691  prepareData( idx ) ;
     692  return getNumPol() ;
     693}
     694
     695int ASDMReader::getNumPol()
     696{
     697  return polarizationRow_p->getNumCorr() ;
    707698}
    708699
    … …  
    713704                               string &freqref )
    714705{
     706  prepareData( idx ) ;
     707  getFrequency( refpix, refval, incr, freqref ) ;
     708}
     709
     710void ASDMReader::getFrequency( double &refpix,
     711                               double &refval,
     712                               double &incr,
     713                               string &freqref )
     714{
    715715  casa::String funcName = "getFrequency" ;
    716716
    717   Tag ddTag( vmsData_->v_dataDescId[dataIdList_[idx]], TagType::DataDescription ) ;
    718   DataDescriptionRow *ddrow = asdm_->getDataDescription().getRowByKey( ddTag ) ;
    719   //Tag spwid = ddrow->getSpectralWindowId() ;
    720   SpectralWindowRow *spwrow = ddrow->getSpectralWindowUsingSpectralWindowId() ;
    721   int nchan = spwrow->getNumChan() ;
     717  int nchan = specWinRow_p->getNumChan() ;
    722718  freqref = "TOPO" ;
    723   if ( spwrow->isMeasFreqRefExists() )
    724     freqref = CFrequencyReferenceCode::toString( spwrow->getMeasFreqRef() ) ;
     719  if ( specWinRow_p->isMeasFreqRefExists() )
     720    freqref = CFrequencyReferenceCode::toString( specWinRow_p->getMeasFreqRef() ) ;
    725721  if ( nchan == 1 ) {
    726722    //logsink_->postLocally( LogMessage("channel averaged data",LogOrigin(className_,funcName,WHERE)) ) ;
    727723    refpix = 0.0 ;
    728     incr = spwrow->getTotBandwidth().get() ;
    729     if ( spwrow->isChanFreqStartExists() ) {
    730       refval = spwrow->getChanFreqStart().get() ;
    731     }
    732     else if ( spwrow->isChanFreqArrayExists() ) {
    733       refval = spwrow->getChanFreqArray()[0].get() ;
     724    incr = specWinRow_p->getTotBandwidth().get() ;
     725    if ( specWinRow_p->isChanFreqStartExists() ) {
     726      refval = specWinRow_p->getChanFreqStart().get() ;
     727    }
     728    else if ( specWinRow_p->isChanFreqArrayExists() ) {
     729      refval = specWinRow_p->getChanFreqArray()[0].get() ;
    734730    }
    735731    else {
    … …  
    742738    refpix = 0.5 * ( (double)nchan - 1.0 ) ;
    743739    int ic = ( nchan - 1 ) / 2 ;
    744     if ( spwrow->isChanWidthExists() ) {
    745       incr = spwrow->getChanWidth().get() ;
    746     }
    747     else if ( spwrow->isChanWidthArrayExists() ) {
    748       incr = spwrow->getChanWidthArray()[0].get() ;
     740    if ( specWinRow_p->isChanWidthExists() ) {
     741      incr = specWinRow_p->getChanWidth().get() ;
     742    }
     743    else if ( specWinRow_p->isChanWidthArrayExists() ) {
     744      incr = specWinRow_p->getChanWidthArray()[0].get() ;
    749745    }
    750746    else {
    751747      throw (casa::AipsError( "Either chanWidthArray or chanWidth must exist." )) ;
    752748    }     
    753     if ( spwrow->isChanFreqStepExists() ) {
    754       if ( spwrow->getChanFreqStep().get() < 0.0 )
     749    if ( specWinRow_p->isChanFreqStepExists() ) {
     750      if ( specWinRow_p->getChanFreqStep().get() < 0.0 )
    755751        incr *= -1.0 ;
    756752    }
    757     else if ( spwrow->isChanFreqArrayExists() ) {
    758       vector<Frequency> chanFreqArr = spwrow->getChanFreqArray() ;
     753    else if ( specWinRow_p->isChanFreqArrayExists() ) {
     754      vector<Frequency> chanFreqArr = specWinRow_p->getChanFreqArray() ;
    759755      if ( chanFreqArr[0].get() > chanFreqArr[1].get() )
    760756        incr *= -1.0 ;
    … …  
    763759      throw (casa::AipsError( "Either chanFreqArray or chanFreqStep must exist." )) ;
    764760    }         
    765     if ( spwrow->isChanFreqStartExists() ) {
    766       refval = spwrow->getChanFreqStart().get() + refpix * incr ;
    767     }
    768     else if ( spwrow->isChanFreqArrayExists() ) {
    769       refval = spwrow->getChanFreqArray()[ic].get() ;
     761    if ( specWinRow_p->isChanFreqStartExists() ) {
     762      refval = specWinRow_p->getChanFreqStart().get() + refpix * incr ;
     763    }
     764    else if ( specWinRow_p->isChanFreqArrayExists() ) {
     765      refval = specWinRow_p->getChanFreqArray()[ic].get() ;
    770766    }
    771767    else {
    … …  
    778774    refpix = 0.5 * ( (double)nchan - 1.0 ) ;
    779775    int ic = nchan / 2 ;
    780     if ( spwrow->isChanWidthExists() ) {
    781       incr = spwrow->getChanWidth().get() ;
    782     }
    783     else if ( spwrow->isChanWidthArrayExists() ) {
    784       incr = spwrow->getChanWidthArray()[0].get() ;
     776    if ( specWinRow_p->isChanWidthExists() ) {
     777      incr = specWinRow_p->getChanWidth().get() ;
     778    }
     779    else if ( specWinRow_p->isChanWidthArrayExists() ) {
     780      incr = specWinRow_p->getChanWidthArray()[0].get() ;
    785781    }
    786782    else {
    787783      throw (casa::AipsError( "Either chanWidthArray or chanWidth must exist." )) ;
    788784    }
    789     if ( spwrow->isChanFreqStepExists() ) {
    790       if ( spwrow->getChanFreqStep().get() < 0.0 )
     785    if ( specWinRow_p->isChanFreqStepExists() ) {
     786      if ( specWinRow_p->getChanFreqStep().get() < 0.0 )
    791787        incr *= -1.0 ;
    792788    }
    793     else if ( spwrow->isChanFreqArrayExists() ) {
    794       vector<Frequency> chanFreqArr = spwrow->getChanFreqArray() ;
     789    else if ( specWinRow_p->isChanFreqArrayExists() ) {
     790      vector<Frequency> chanFreqArr = specWinRow_p->getChanFreqArray() ;
    795791      if ( chanFreqArr[0].get() > chanFreqArr[1].get() )
    796792        incr *= -1.0 ;
    … …  
    799795      throw (casa::AipsError( "Either chanFreqArray or chanFreqStep must exist." )) ;
    800796    }         
    801     if ( spwrow->isChanFreqStartExists() ) {
    802       refval = spwrow->getChanFreqStart().get() + refpix * incr ;
    803     }
    804     else if ( spwrow->isChanFreqArrayExists() ) {
    805       vector<Frequency> freqs = spwrow->getChanFreqArray() ;
     797    if ( specWinRow_p->isChanFreqStartExists() ) {
     798      refval = specWinRow_p->getChanFreqStart().get() + refpix * incr ;
     799    }
     800    else if ( specWinRow_p->isChanFreqArrayExists() ) {
     801      vector<Frequency> freqs = specWinRow_p->getChanFreqArray() ;
    806802      refval = 0.5 * ( freqs[ic-1].get() + freqs[ic].get() ) ;     
    807803    }
    … …  
    812808}
    813809
    814 vector<double> ASDMReader::getRestFrequency( unsigned int idx )
    815 {
    816   vector<double> rf( 0 ) ;
    817   unsigned int index = dataIdList_[idx] ;
    818   //ArrayTimeInterval tint( vmsData_->v_time[index]*s2d, vmsData_->v_interval[index]*s2d ) ;
    819   double startSec = vmsData_->v_time[index] - 0.5 * vmsData_->v_interval[index] ;
    820   ArrayTimeInterval tint( startSec*s2d, vmsData_->v_interval[index]*s2d ) ;
    821   Tag ddtag( vmsData_->v_dataDescId[index], TagType::DataDescription ) ;
    822   Tag spwtag = asdm_->getDataDescription().getRowByKey(ddtag)->getSpectralWindowId() ;
    823   Tag ftag( vmsData_->v_fieldId[index], TagType::Field ) ;
    824   FieldRow *frow = asdm_->getField().getRowByKey( ftag ) ;
    825   if ( frow->isSourceIdExists() ) {
    826     //logsink_->postLocally( LogMessage("sourceId exists",LogOrigin(className_,funcName,WHERE)) ) ;
    827     int sid = frow->getSourceId() ;
    828     SourceRow *srow = asdm_->getSource().getRowByKey( sid, tint, spwtag ) ;
     810double ASDMReader::getTime( unsigned int idx )
     811{
     812  prepareData( idx ) ;
     813  return getTime() ;
     814}
     815
     816double ASDMReader::getTime()
     817{
     818  double tsec = vmsData_->v_time[dataIndex_] ;
     819  return tsec * s2d ;
     820}
     821
     822double ASDMReader::getInterval( unsigned int idx )
     823{
     824  prepareData( idx ) ;
     825  return getInterval() ;
     826}
     827
     828double ASDMReader::getInterval()
     829{
     830  return vmsData_->v_interval[dataIndex_] ;
     831}
     832
     833void ASDMReader::getSourceProperty( unsigned int idx,
     834                                    string &srcname,
     835                                    string &fieldname,
     836                                    vector<double> &srcdir,
     837                                    vector<double> &srcpm,
     838                                    double &sysvel,
     839                                    vector<double> &restfreq )
     840{
     841  prepareData( idx ) ;
     842  getSourceProperty( srcname, fieldname, srcdir, srcpm, sysvel, restfreq ) ;
     843}
     844
     845void ASDMReader::getSourceProperty( string &srcname,
     846                                    string &fieldname,
     847                                    vector<double> &srcdir,
     848                                    vector<double> &srcpm,
     849                                    double &sysvel,
     850                                    vector<double> &restfreq )
     851{
     852  ostringstream oss ;
     853  oss << fieldRow_p->getFieldName() << "__" << vmsData_->v_fieldId[dataIndex_] ;
     854  fieldname = oss.str() ;
     855  if ( fieldRow_p->isSourceIdExists() ) {
     856    int sourceId = fieldRow_p->getSourceId() ;
     857    SourceRow *srow = asdm_->getSource().getRowByKey( sourceId, timeInterval_, specWinTag_ ) ;
     858
     859    // source name
     860    srcname = srow->getSourceName() ;
     861
     862    // source direction
     863    vector<Angle> srcdirA = srow->getDirection() ;
     864    srcdir.resize( 2 ) ;
     865    srcdir[0] = limitedAngle( srcdirA[0].get() ) ;
     866    srcdir[1] = limitedAngle( srcdirA[1].get() ) ;
     867    if ( srow->isDirectionCodeExists() ) {
     868      DirectionReferenceCode dircode = srow->getDirectionCode() ;
     869      //logsink_->postLocally( LogMessage("dircode="+CDirectionReferenceCode::toString(dircode),LogOrigin(className_,funcName,WHERE)) ) ;
     870      if ( dircode != J2000 ) {
     871        // if not J2000, need direction conversion
     872        String ref( CDirectionReferenceCode::toString( dircode ) ) ;
     873        double mjd = vmsData_->v_time[dataIndex_] * s2d ;
     874        srcdir = toJ2000( srcdir, ref, mjd, antennaPosition_ ) ;
     875      }
     876    }
     877
     878    // source proper motion
     879    srcpm.resize( 2 ) ;
     880    vector<AngularRate> srcpmA = srow->getProperMotion() ;
     881    srcpm[0] = srcpmA[0].get() ;
     882    srcpm[1] = srcpmA[1].get() ;
     883
     884    // systemic velocity
     885    if ( srow->isSysVelExists() ) {
     886      vector<Speed> sysvelV = srow->getSysVel() ;
     887      if ( sysvelV.size() > 0 )
     888        sysvel = sysvelV[0].get() ;
     889    }
     890    else {
     891      sysvel = 0.0 ;
     892    }
     893
     894    // rest frequency
    829895    if ( srow->isRestFrequencyExists() ) {
    830896      //logsink_->postLocally( LogMessage("restFrequency exists",LogOrigin(className_,funcName,WHERE)) ) ;
    831       vector<Frequency> restfreq = srow->getRestFrequency() ;
    832       rf.resize( restfreq.size() ) ;
     897      vector<Frequency> rf = srow->getRestFrequency() ;
     898      restfreq.resize( rf.size() ) ;
    833899      for ( unsigned int i = 0 ; i < restfreq.size() ; i++ )
    834         rf[i] = restfreq[i].get() ;
    835     }
    836   }
    837   return rf ;
    838 }
    839 
    840 double ASDMReader::getTime( unsigned int idx )
    841 {
    842   double tsec = vmsData_->v_time[dataIdList_[idx]] ;
    843   return tsec * s2d ;
    844 }
    845 
    846 double ASDMReader::getInterval( unsigned int idx )
    847 {
    848   return vmsData_->v_interval[dataIdList_[idx]] ;
    849 }
    850 
    851 string ASDMReader::getSourceName( unsigned int idx )
    852 {
    853   unsigned int index = dataIdList_[idx] ;
    854   //ArrayTimeInterval tint( vmsData_->v_time[index]*s2d, vmsData_->v_interval[index]*s2d ) ;
    855   double startSec = vmsData_->v_time[index] - 0.5 * vmsData_->v_interval[index] ;
    856   ArrayTimeInterval tint( startSec*s2d, vmsData_->v_interval[index]*s2d ) ;
    857   Tag ddtag( vmsData_->v_dataDescId[index], TagType::DataDescription ) ;
    858   Tag spwtag = asdm_->getDataDescription().getRowByKey(ddtag)->getSpectralWindowId() ;
    859   Tag ftag( vmsData_->v_fieldId[index], TagType::Field ) ;
    860   FieldRow *frow = asdm_->getField().getRowByKey( ftag ) ;
    861   string srcname ;
    862   if ( frow->isSourceIdExists() ) {
    863     //logsink_->postLocally( LogMessage("sourceId exists",LogOrigin(className_,funcName,WHERE)) ) ;
    864     int sid = frow->getSourceId() ;
    865     SourceRow *srow = asdm_->getSource().getRowByKey( sid, tint, spwtag ) ;
    866     srcname = srow->getSourceName() ;
     900        restfreq[i] = rf[i].get() ;
     901    }
     902    else {
     903      restfreq.resize( 0 ) ;
     904    }
    867905  }
    868906  else {
    869     srcname = frow->getFieldName() ;
    870   }
    871   return srcname ;
    872 }
    873 
    874 string ASDMReader::getFieldName( unsigned int idx )
    875 {
    876   int fid = vmsData_->v_fieldId[dataIdList_[idx]] ;
    877   Tag ftag( fid, TagType::Field ) ;
    878   FieldRow *frow = asdm_->getField().getRowByKey( ftag ) ;
    879   ostringstream oss ;
    880   oss << frow->getFieldName() << "__" << fid ;
    881   return oss.str() ;
     907    srcname = fieldRow_p->getFieldName() ;
     908    srcdir.resize( 2 ) ;
     909    srcdir[0] = 0.0 ;
     910    srcdir[1] = 0.0 ;
     911    srcpm = srcdir ;
     912    sysvel = 0.0 ;
     913    restfreq.resize( 0 ) ;
     914  }
    882915}
    883916
    … …  
    886919{
    887920  int srctype = SrcType::NOTYPE ;
    888   Tag ebtag = mainRow_[row_]->getExecBlockId() ;
    889   ScanRow *scanrow = asdm_->getScan().getRowByKey( ebtag, (int)scan ) ;
     921  ScanRow *scanrow = asdm_->getScan().getRowByKey( execBlockTag_, (int)scan ) ;
    890922  ScanIntent scanIntent = scanrow->getScanIntent()[0] ;
    891   SubscanRow *subrow = asdm_->getSubscan().getRowByKey( ebtag, (int)scan, (int)subscan ) ;
     923  SubscanRow *subrow = asdm_->getSubscan().getRowByKey( execBlockTag_, (int)scan, (int)subscan ) ;
    892924  SubscanIntent subIntent = subrow->getSubscanIntent() ;
    893925  SwitchingMode swmode = NO_SWITCHING ;
    … …  
    9971029unsigned int ASDMReader::getSubscanNo( unsigned int idx )
    9981030{
     1031  prepareData( idx ) ;
     1032  return getSubscanNo() ;
     1033}
     1034
     1035unsigned int ASDMReader::getSubscanNo()
     1036{
    9991037  //logsink_->postLocally( LogMessage("subscan"+String::toString(vmsData_->v_msState[dataIdList_[idx]].subscanNum)+": obsmode="+String::toString(vmsData_->v_msState[dataIdList_[idx]].obsMode),LogOrigin(className_,funcName,WHERE)) ) ;
    1000   return vmsData_->v_msState[dataIdList_[idx]].subscanNum ;
    1001 }
    1002 
    1003 vector<double> ASDMReader::getSourceDirection( unsigned int idx )
    1004 {
    1005   vector<double> dir( 2, 0.0 ) ;
    1006   unsigned int index = dataIdList_[idx] ;
    1007   //ArrayTimeInterval tint( vmsData_->v_time[index]*s2d, vmsData_->v_interval[index]*s2d ) ;
    1008   double startSec = vmsData_->v_time[index] - 0.5 * vmsData_->v_interval[index] ;
    1009   ArrayTimeInterval tint( startSec*s2d, vmsData_->v_interval[index]*s2d ) ;
    1010   Tag ddtag( vmsData_->v_dataDescId[index], TagType::DataDescription ) ;
    1011   Tag spwtag = asdm_->getDataDescription().getRowByKey(ddtag)->getSpectralWindowId() ;
    1012   Tag ftag( vmsData_->v_fieldId[index], TagType::Field ) ;
    1013   FieldRow *frow = asdm_->getField().getRowByKey( ftag ) ;
    1014   string srcname ;
    1015   if ( frow->isSourceIdExists() ) {
    1016     //logsink_->postLocally( LogMessage("sourceId exists",LogOrigin(className_,funcName,WHERE)) ) ;
    1017     int sid = frow->getSourceId() ;
    1018     SourceRow *srow = asdm_->getSource().getRowByKey( sid, tint, spwtag ) ;
    1019     vector<Angle> srcdir = srow->getDirection() ;
    1020     dir[0] = limitedAngle( srcdir[0].get() ) ;
    1021     dir[1] = limitedAngle( srcdir[1].get() ) ;
    1022     if ( srow->isDirectionCodeExists() ) {
    1023       DirectionReferenceCode dircode = srow->getDirectionCode() ;
    1024       //logsink_->postLocally( LogMessage("dircode="+CDirectionReferenceCode::toString(dircode),LogOrigin(className_,funcName,WHERE)) ) ;
    1025       if ( dircode != J2000 ) {
    1026         // if not J2000, need direction conversion
    1027         string ref = CDirectionReferenceCode::toString( dircode ) ;
    1028         double mjd = vmsData_->v_time[index] * s2d ;
    1029         Tag atag( antennaId_, TagType::Antenna ) ;
    1030         AntennaRow *arow = asdm_->getAntenna().getRowByKey( atag ) ;
    1031         StationRow *srow = arow->getStationUsingStationId() ;
    1032         vector<Length> antposL = srow->getPosition() ;
    1033         casa::Vector<casa::Double> antpos( 3 ) ;
    1034         for ( int i = 0 ; i < 3 ; i++ )
    1035           antpos[i] = antposL[i].get() ;
    1036         dir = toJ2000( dir, ref, mjd, antpos ) ;
    1037       }
    1038     }
    1039   }
    1040   return dir ;
    1041 }
    1042 
    1043 void ASDMReader::getSourceDirection( unsigned int idx,
    1044                                      vector<double> &dir,
    1045                                      string &ref )
    1046 {
    1047   dir.resize( 2 ) ;
    1048   dir[0] = 0.0 ;
    1049   dir[1] = 0.0 ;
    1050   ref = "J2000" ;
    1051   unsigned int index = dataIdList_[idx] ;
    1052   //ArrayTimeInterval tint( vmsData_->v_time[index]*s2d, vmsData_->v_interval[index]*s2d ) ;
    1053   double startSec = vmsData_->v_time[index] - 0.5 * vmsData_->v_interval[index] ;
    1054   ArrayTimeInterval tint( startSec*s2d, vmsData_->v_interval[index]*s2d ) ;
    1055   Tag ddtag( vmsData_->v_dataDescId[index], TagType::DataDescription ) ;
    1056   Tag spwtag = asdm_->getDataDescription().getRowByKey(ddtag)->getSpectralWindowId() ;
    1057   Tag ftag( vmsData_->v_fieldId[index], TagType::Field ) ;
    1058   FieldRow *frow = asdm_->getField().getRowByKey( ftag ) ;
    1059   string srcname ;
    1060   if ( frow->isSourceIdExists() ) {
    1061     //logsink_->postLocally( LogMessage("sourceId exists",LogOrigin(className_,funcName,WHERE)) ) ;
    1062     int sid = frow->getSourceId() ;
    1063     SourceRow *srow = asdm_->getSource().getRowByKey( sid, tint, spwtag ) ;
    1064     vector<Angle> srcdir = srow->getDirection() ;
    1065     if ( srow->isDirectionCodeExists() ) {
    1066       ref = CDirectionReferenceCode::toString( srow->getDirectionCode() ) ;
    1067     }
    1068     dir[0] = limitedAngle( srcdir[0].get() ) ;
    1069     dir[1] = limitedAngle( srcdir[1].get() ) ;
    1070   }
     1038  return vmsData_->v_msState[dataIndex_].subscanNum ;
    10711039}
    10721040
    … …  
    10851053}
    10861054
    1087 vector<double> ASDMReader::getSourceProperMotion( unsigned int idx )
    1088 {
    1089   vector<double> pm( 2, 0.0 ) ;
    1090   unsigned int index = dataIdList_[idx] ;
    1091   //ArrayTimeInterval tint( vmsData_->v_time[index]*s2d, vmsData_->v_interval[index]*s2d ) ;
    1092   double startSec = vmsData_->v_time[index] - 0.5 * vmsData_->v_interval[index] ;
    1093   ArrayTimeInterval tint( startSec*s2d, vmsData_->v_interval[index]*s2d ) ;
    1094   Tag ddtag( vmsData_->v_dataDescId[index], TagType::DataDescription ) ;
    1095   Tag spwtag = asdm_->getDataDescription().getRowByKey(ddtag)->getSpectralWindowId() ;
    1096   Tag ftag( vmsData_->v_fieldId[index], TagType::Field ) ;
    1097   FieldRow *frow = asdm_->getField().getRowByKey( ftag ) ;
    1098   string srcname ;
    1099   if ( frow->isSourceIdExists() ) {
    1100     //logsink_->postLocally( LogMessage("sourceId exists",LogOrigin(className_,funcName,WHERE)) ) ;
    1101     int sid = frow->getSourceId() ;
    1102     SourceRow *srow = asdm_->getSource().getRowByKey( sid, tint, spwtag ) ;
    1103     vector<AngularRate> srcpm = srow->getProperMotion() ;
    1104     pm[0] = srcpm[0].get() ;
    1105     pm[1] = srcpm[1].get() ;
    1106   }
    1107   return pm ;
    1108 }
    1109 
    1110 double ASDMReader::getSysVel( unsigned int idx )
    1111 {
    1112   double sysvel = 0.0 ;
    1113   unsigned int index = dataIdList_[idx] ;
    1114   //ArrayTimeInterval tint( vmsData_->v_time[index]*s2d, vmsData_->v_interval[index]*s2d ) ;
    1115   double startSec = vmsData_->v_time[index] - 0.5 * vmsData_->v_interval[index] ;
    1116   ArrayTimeInterval tint( startSec*s2d, vmsData_->v_interval[index]*s2d ) ;
    1117   Tag ddtag( vmsData_->v_dataDescId[index], TagType::DataDescription ) ;
    1118   Tag spwtag = asdm_->getDataDescription().getRowByKey(ddtag)->getSpectralWindowId() ;
    1119   Tag ftag( vmsData_->v_fieldId[index], TagType::Field ) ;
    1120   FieldRow *frow = asdm_->getField().getRowByKey( ftag ) ;
    1121   string srcname ;
    1122   if ( frow->isSourceIdExists() ) {
    1123     //logsink_->postLocally( LogMessage("sourceId exists",LogOrigin(className_,funcName,WHERE)) ) ;
    1124     int sid = frow->getSourceId() ;
    1125     SourceRow *srow = asdm_->getSource().getRowByKey( sid, tint, spwtag ) ;
    1126     if ( srow->isSysVelExists() ) {
    1127       vector<Speed> sysvelV = srow->getSysVel() ;
    1128       if ( sysvelV.size() > 0 )
    1129         sysvel = sysvelV[0].get() ;
    1130     }
    1131   }
    1132   return sysvel ;
    1133 }
    1134 
    11351055unsigned int ASDMReader::getFlagRow( unsigned int idx )
    11361056{
    1137   return vmsData_->v_flag[dataIdList_[idx]] ;
     1057  prepareData( idx ) ;
     1058  return getFlagRow() ;
     1059}
     1060
     1061unsigned int ASDMReader::getFlagRow()
     1062{
     1063  return vmsData_->v_flag[dataIndex_] ;
    11381064}
    11391065
    11401066vector<unsigned int> ASDMReader::getDataShape( unsigned int idx )
    11411067{
    1142   return vmsData_->vv_dataShape[dataIdList_[idx]] ;
     1068  prepareData( idx ) ;
     1069  return getDataShape() ;
     1070}
     1071
     1072vector<unsigned int> ASDMReader::getDataShape()
     1073{
     1074  return vmsData_->vv_dataShape[dataIndex_] ;
    11431075}
    11441076
    11451077float * ASDMReader::getSpectrum( unsigned int idx )
    11461078{
    1147   map<AtmPhaseCorrection, float*> data = vmsData_->v_m_data[dataIdList_[idx]] ;
     1079  prepareData( idx ) ;
     1080  return getSpectrum() ;
     1081}
     1082
     1083float * ASDMReader::getSpectrum()
     1084{
     1085  map<AtmPhaseCorrection, float*> data = vmsData_->v_m_data[dataIndex_] ;
    11481086  //map<AtmPhaseCorrection, float*>::iterator iter = data.find(AP_UNCORRECTED) ;
    11491087  map<AtmPhaseCorrection, float*>::iterator iter = data.find(apc_) ;
    … …  
    11521090}
    11531091
    1154 // bool * ASDMReader::getFlagChannel( unsigned int idx )
    1155 // {
    1156 //   return 0 ;
    1157 // }
    1158 
    11591092vector< vector<float> > ASDMReader::getTsys( unsigned int idx )
    11601093{
     1094  prepareData( idx ) ;
     1095  return getTsys() ;
     1096}
     1097
     1098vector< vector<float> > ASDMReader::getTsys()
     1099{
    11611100  vector< vector<float> > defaultTsys( 1, vector<float>( 1, 1.0 ) ) ;
    1162   SysCalRow *scrow = getSysCalRow( idx ) ;
     1101  SysCalRow *scrow = getSysCalRow() ;
    11631102  if ( scrow != 0 && scrow->isTsysSpectrumExists() ) {
    11641103    vector< vector<Temperature> > tsysSpec = scrow->getTsysSpectrum() ;
    … …  
    11881127vector< vector<float> > ASDMReader::getTcal( unsigned int idx )
    11891128{
     1129  prepareData( idx ) ;
     1130  return getTcal() ;
     1131}
     1132
     1133vector< vector<float> > ASDMReader::getTcal()
     1134{
    11901135  vector< vector<float> > defaultTcal( 1, vector<float>( 1, 1.0 ) ) ;
    1191   SysCalRow *scrow = getSysCalRow( idx ) ;
     1136  SysCalRow *scrow = getSysCalRow() ;
    11921137  if ( scrow != 0 && scrow->isTcalSpectrumExists() ) {
    11931138    vector< vector<Temperature> > tcalSpec = scrow->getTcalSpectrum() ;
    … …  
    12191164                                 vector< vector<float> > &tsys )
    12201165{
     1166  prepareData( idx ) ;
     1167  getTcalAndTsys( tcal, tsys ) ;
     1168}
     1169
     1170void ASDMReader::getTcalAndTsys( vector< vector<float> > &tcal,
     1171                                 vector< vector<float> > &tsys )
     1172{
    12211173  String funcName = "getTcalAndTsys" ;
    12221174
    12231175  vector< vector<float> > defaultT( 1, vector<float>( 1, 1.0 ) ) ;
    1224   SysCalRow *scrow = getSysCalRow( idx ) ;
     1176  SysCalRow *scrow = getSysCalRow() ;
    12251177  if ( scrow == 0 ) {
    12261178    tcal = defaultT ;
    … …  
    12631215vector<float> ASDMReader::getOpacity( unsigned int idx )
    12641216{
     1217  prepareData( idx ) ;
     1218  return getOpacity() ;
     1219}
     1220
     1221vector<float> ASDMReader::getOpacity()
     1222{
    12651223  vector<float> tau(0) ;
    12661224  CalAtmosphereTable &atmtab = asdm_->getCalAtmosphere() ;
    12671225  unsigned int nrow = atmtab.size() ;
    12681226  if ( nrow > 0 ) {
    1269     unsigned int index = dataIdList_[idx] ;
    1270     //ArrayTimeInterval tint( vmsData_->v_time[index]*s2d, vmsData_->v_interval[index]*s2d ) ;
    1271     double startSec = vmsData_->v_time[index] - 0.5 * vmsData_->v_interval[index] ;
    1272     ArrayTimeInterval tint( startSec*s2d, vmsData_->v_interval[index]*s2d ) ;
    12731227    //int feedid = vmsData_->v_feedId1[index] ;
    1274     //Tag atag( antennaId_, TagType::Antenna ) ;
    1275     //Tag ddtag( vmsData_->v_dataDescId[index], TagType::DataDescription ) ;
    1276     //DataDescriptionRow *ddrow = asdm_->getDataDescription().getRowByKey(ddtag) ;
    1277     //Tag spwtag = ddrow->getSpectralWindowId() ;
    1278     //SpectralWindowRow *spwrow = ddrow->getSpectralWindowUsingSpectralWindowId() ;
    12791228    //BasebandName bbname = spwrow->getBasebandName() ;
    12801229    //FeedRow *frow = asdm_->getFeed().getRowByKey( atag, spwtag, tint, feedid ) ;
    … …  
    12841233    //ReceiverBand rb = rrows[0]->getFrequencyBand() ;
    12851234    int row0 = -1 ;
    1286     double eps = tint.getStart().getMJD() ;
     1235    double eps = DBL_MAX ;
    12871236    for ( unsigned int irow = 0 ; irow < nrow ; irow++ ) {
    12881237      CalAtmosphereRow *atmrow = atmrows[irow] ;
    … …  
    12931242        continue ;
    12941243      else {
    1295         double dt = tint.getStart().getMJD() - atmrow->getEndValidTime().getMJD() ;
     1244        double dt = timeInterval_.getStart().getMJD() - atmrow->getEndValidTime().getMJD() ;
    12961245        if ( dt >= 0 && dt < eps ) {
    12971246          eps = dt ;
    … …  
    13191268                                 float &windaz )
    13201269{
     1270  prepareData( idx ) ;
     1271  getWeatherInfo( temperature, pressure, humidity, windspeed, windaz ) ;
     1272}
     1273
     1274void ASDMReader::getWeatherInfo( float &temperature,
     1275                                 float &pressure,
     1276                                 float &humidity,
     1277                                 float &windspeed,
     1278                                 float &windaz )
     1279{
    13211280  casa::String funcName = "getWeatherInfo" ;
    13221281
    … …  
    13331292    return ;
    13341293
    1335   unsigned int index = dataIdList_[idx] ;
    1336   //Tag anttag( antennaId_, TagType::Antenna ) ;
    1337   //Tag sttag = (asdm_->getAntenna().getRowByKey( anttag ))->getStationId() ;
    13381294  Tag sttag( (unsigned int)weatherStationId_, TagType::Station ) ;
    1339   //ArrayTimeInterval tint( vmsData_->v_time[index]*s2d, vmsData_->v_interval[index]*s2d ) ;
    1340   double startSec = vmsData_->v_time[index] - 0.5 * vmsData_->v_interval[index] ;
    1341   ArrayTimeInterval tint( startSec*s2d, vmsData_->v_interval[index]*s2d ) ;
    13421295  //WeatherRow *wrow = wtab.getRowByKey( sttag, tint ) ;
    13431296  vector<WeatherRow *> *wrows = wtab.getByContext( sttag ) ;
    … …  
    13451298  unsigned int nrow = wrows->size() ;
    13461299  //logsink_->postLocally( LogMessage("There are "+String::toString(nrow)+" rows for given context: stationId "+String::toString(weatherStationId_),LogOrigin(className_,funcName,WHERE)) ) ;
    1347   ArrayTime startTime = getMidTime( tint ) ;
     1300  ArrayTime startTime = getMidTime( timeInterval_ ) ;
    13481301  if ( startTime < (*wrows)[0]->getTimeInterval().getStart() ) {
    13491302    temperature = (*wrows)[0]->getTemperature().get() ;
    … …  
    14051358    return -1 ;
    14061359
    1407   Tag atag( antennaId_, TagType::Antenna ) ;
    1408   Tag stag = (asdm_->getAntenna().getRowByKey( atag ))->getStationId() ;
    14091360  vector<double> apos( 3 ) ;
    14101361  StationTable &stab = asdm_->getStation() ;
    1411   StationRow *srow = stab.getRowByKey( stag ) ;
    1412   vector<Length> pos = srow->getPosition() ;
    1413   apos[0] = pos[0].get() ;
    1414   apos[1] = pos[1].get() ;
    1415   apos[2] = pos[2].get() ;
     1362  apos[0] = antennaPosition_[0].getValue( Unit("m") ) ;
     1363  apos[1] = antennaPosition_[1].getValue( Unit("m") ) ;
     1364  apos[2] = antennaPosition_[2].getValue( Unit("m") ) ;
    14161365 
    1417   double eps = 1.0e20 ;
     1366  double eps = DBL_MAX ;
    14181367  int retval = -1 ;
    14191368  for ( unsigned int ir = 0 ; ir < weatherStation_.size() ; ir++ ) {
    1420     srow = stab.getRowByKey( weatherStation_[ir] ) ;
     1369    StationRow *srow = stab.getRowByKey( weatherStation_[ir] ) ;
    14211370    vector<Length> wpos = srow->getPosition() ;
    14221371    double dist = (apos[0]-wpos[0].get())*(apos[0]-wpos[0].get())
    … …  
    14371386                                  vector<double> &srate )
    14381387{
     1388  prepareData( idx ) ;
     1389  getPointingInfo( dir, az, el, srate ) ;
     1390}
     1391
     1392void ASDMReader::getPointingInfo( vector<double> &dir,
     1393                                  double &az,
     1394                                  double &el,
     1395                                  vector<double> &srate )
     1396{
    14391397  String funcName = "getPointingInfo" ;
    14401398
    … …  
    14441402  srate.resize(0) ;
    14451403
    1446   Tag atag( antennaId_, TagType::Antenna ) ;
    1447   unsigned int index = dataIdList_[idx] ;
    1448   vector<PointingRow *> *prows = asdm_->getPointing().getByContext( atag ) ;
     1404  //Tag atag( antennaId_, TagType::Antenna ) ;
     1405  //unsigned int index = dataIdList_[idx] ;
     1406  //vector<PointingRow *> *prows = asdm_->getPointing().getByContext( atag ) ;
     1407  vector<PointingRow *> *prows = asdm_->getPointing().getByContext( antennaTag_ ) ;
    14491408
    14501409  if ( prows == 0 )
    … …  
    14541413  PointingRow *qrow ;
    14551414  //ArrayTimeInterval tint( vmsData_->v_time[index]*s2d, vmsData_->v_interval[index]*s2d ) ;
    1456   double startSec = vmsData_->v_time[index] - 0.5 * vmsData_->v_interval[index] ;
    1457   ArrayTimeInterval tint( startSec*s2d, vmsData_->v_interval[index]*s2d ) ;
     1415  //double startSec = vmsData_->v_time[index] - 0.5 * vmsData_->v_interval[index] ;
     1416  //ArrayTimeInterval tint( startSec*s2d, vmsData_->v_interval[index]*s2d ) ;
    14581417
    14591418  unsigned int nrow = prows->size() ;
    … …  
    14751434  el = 0.0 ;
    14761435  //double tcen = 0.0 ;
    1477   double tcen = getMidTime( tint ).getMJD() ;
     1436  //double tcen = getMidTime( tint ).getMJD() ;
     1437  double tcen = getMidTime( timeInterval_ ).getMJD() ;
    14781438
    14791439  //
    … …  
    14921452  ArrayTimeInterval pTime1 = (*prows)[nrow-1]->getTimeInterval() ;
    14931453  //if ( tint.getStartInMJD()+tint.getDurationInDays() < pTime0.getStartInMJD() ) {
    1494   if ( getEndTime( tint ) < getStartTime( pTime0 ) ) {
     1454  //if ( getEndTime( tint ) < getStartTime( pTime0 ) ) {
     1455  if ( getEndTime( timeInterval_ ) < getStartTime( pTime0 ) ) {
    14951456    logsink_->postLocally( LogMessage( "ArrayTimeInterval out of bounds: no data for given position (tint < ptime)", LogOrigin(className_,funcName,WHERE), LogMessage::WARN ) ) ;
    14961457    prow = (*prows)[0] ;
    … …  
    15041465  }
    15051466  //else if ( tint.getStartInMJD() > pTime1.getStartInMJD()+pTime1.getDurationInDays() ) {
    1506   else if ( getStartTime( tint ) > getEndTime( pTime1 ) ) {
     1467  //else if ( getStartTime( tint ) > getEndTime( pTime1 ) ) {
     1468  else if ( getStartTime( timeInterval_ ) > getEndTime( pTime1 ) ) {
    15071469    logsink_->postLocally( LogMessage( "ArrayTimeInterval out of bounds: no data for given position (tint > ptime)", LogOrigin(className_,funcName,WHERE), LogMessage::WARN ) ) ;
    15081470    prow = (*prows)[nrow-1] ;
    … …  
    15231485  }
    15241486  else {
    1525     ArrayTime startTime = tint.getStart() ;
    1526     ArrayTime endTime = getEndTime( tint ) ;
     1487    //ArrayTime startTime = tint.getStart() ;
     1488    //ArrayTime endTime = getEndTime( tint ) ;
     1489    ArrayTime startTime = timeInterval_.getStart() ;
     1490    ArrayTime endTime = getEndTime( timeInterval_ ) ;
    15271491    int row0 = -1 ;
    15281492    int row1 = -1 ;
    15291493    int row2 = -1 ;
    1530     double dt0 = getMidTime( tint ).getMJD() ;
     1494    //double dt0 = getMidTime( tint ).getMJD() ;
     1495    double dt0 = getMidTime( timeInterval_ ).getMJD() ;
    15311496    for ( unsigned int irow = 0 ; irow < nrow ; irow++ ) {
    15321497      prow = (*prows)[irow] ;
    1533       double dt = getMidTime( tint ).getMJD() - getMidTime( prow->getTimeInterval() ).getMJD() ;
     1498      //double dt = getMidTime( tint ).getMJD() - getMidTime( prow->getTimeInterval() ).getMJD() ;
     1499      double dt = getMidTime( timeInterval_ ).getMJD() - getMidTime( prow->getTimeInterval() ).getMJD() ;
    15341500      if ( dt > 0 && dt < dt0 ) {
    15351501        dt0 = dt ;
    … …  
    16361602            for ( int isam = 0 ; isam < numSample ; isam++ ) {
    16371603              //if ( tint.overlaps( stime[isam] ) ) {
    1638               if ( tint.contains( stime[isam] ) ) {
     1604              //if ( tint.contains( stime[isam] ) ) {
     1605              if ( timeInterval_.contains( stime[isam] ) ) {
    16391606                az += dirA[isam][0] ;
    16401607                el += dirA[isam][1] ;
    … …  
    16531620              ArrayTimeInterval stime( sampleStart+isam*sampleInterval, sampleInterval ) ;
    16541621              //if ( tint.overlaps( stime ) ) {
    1655               if ( tint.contains( stime ) ) {
     1622              //if ( tint.contains( stime ) ) {
     1623              if ( timeInterval_.contains( stime ) ) {
    16561624                az += dirA[isam][0] ;
    16571625                el += dirA[isam][1] ;
    … …  
    16731641    }
    16741642   
    1675     AntennaRow *arow = asdm_->getAntenna().getRowByKey( Tag( antennaId_, TagType::Antenna ) ) ;
    1676     StationRow *srow = arow->getStationUsingStationId() ;
    1677     vector<Length> antposL = srow->getPosition() ;
    1678     casa::Vector<casa::Double> antpos( 3 ) ;
    1679     for ( int i = 0 ; i < 3 ; i++ )
    1680       antpos[i] = antposL[i].get() ;
    1681     //logsink_->postLocally( LogMessage("tcen = "+String::toString(tcen),LogOrigin(className_,funcName,WHERE)) ) ;
    1682     //logsink_->postLocally( LogMessage("antpos = "+String::toString(antpos),LogOrigin(className_,funcName,WHERE)) ) ;
    1683     toJ2000( dir, az, el, tcen, antpos ) ;
    1684 
     1643    toJ2000( dir, az, el, tcen, antennaPosition_ ) ;
    16851644  }
    16861645
    … …  
    17041663
    17051664void ASDMReader::toJ2000( vector<double> &dir,
    1706                           double az,
    1707                           double el,
    1708                           double mjd,
    1709                           casa::Vector<casa::Double> antpos )
     1665                          double &az,
     1666                          double &el,
     1667                          double &mjd,
     1668                          casa::Vector<casa::Quantity> &antpos )
     1669//                          casa::Vector<casa::Double> antpos )
    17101670{
    17111671  String funcName = "toJ2000" ;
    17121672
     1673  String ref = "AZELGEO" ;
    17131674  vector<double> azel( 2 ) ;
    17141675  azel[0] = az ;
    17151676  azel[1] = el ;
    1716   dir = toJ2000( azel, "AZELGEO", mjd, antpos ) ;
    1717 }
    1718 
    1719 vector<double> ASDMReader::toJ2000( vector<double> dir,
    1720                                     casa::String dirref,
    1721                                     double mjd,
    1722                                     casa::Vector<casa::Double> antpos )
     1677  dir = toJ2000( azel, ref, mjd, antpos ) ;
     1678}
     1679
     1680vector<double> ASDMReader::toJ2000( vector<double> &dir,
     1681                                    casa::String &dirref,
     1682                                    double &mjd,
     1683                                    casa::Vector<casa::Quantity> &antpos )
     1684//                                    casa::Vector<casa::Double> antpos )
    17231685{
    17241686  casa::String funcName = "toJ2000" ;
    … …  
    17271689  if ( dirref != "J2000" ) {
    17281690    casa::MEpoch me( casa::Quantity( (casa::Double)mjd, "d" ), casa::MEpoch::UTC ) ;
    1729     casa::Vector<casa::Quantity> qantpos( 3 ) ;
    1730     qantpos[0] = casa::Quantity( antpos[0], "m" ) ;
    1731     qantpos[1] = casa::Quantity( antpos[1], "m" ) ;
    1732     qantpos[2] = casa::Quantity( antpos[2], "m" ) ;
    1733     casa::MPosition mp( casa::MVPosition( qantpos ),
     1691    casa::MPosition mp( casa::MVPosition( antpos ),
    17341692                        casa::MPosition::ITRF ) ;
    17351693    //ostringstream oss ;
    … …  
    18271785SysCalRow *ASDMReader::getSysCalRow( unsigned int idx )
    18281786{
     1787  prepareData( idx ) ;
     1788  return getSysCalRow() ;
     1789}
     1790
     1791SysCalRow *ASDMReader::getSysCalRow()
     1792{
    18291793  String funcName = "getSysCalRow" ;
    18301794
    18311795  SysCalRow *row = 0 ;
    1832   unsigned int index = dataIdList_[idx] ;
    1833   Tag anttag( antennaId_, TagType::Antenna ) ;
    1834   int feedid = vmsData_->v_feedId1[index] ;
    1835   //ArrayTimeInterval tint( vmsData_->v_time[index]*s2d, vmsData_->v_interval[index]*s2d ) ;
    1836   double startSec = vmsData_->v_time[index] - 0.5 * vmsData_->v_interval[index] ;
    1837   ArrayTimeInterval tint( startSec*s2d, vmsData_->v_interval[index]*s2d ) ;
    1838   Tag ddtag( vmsData_->v_dataDescId[index], TagType::DataDescription ) ;
    1839   Tag spwtag = asdm_->getDataDescription().getRowByKey(ddtag)->getSpectralWindowId() ;
    1840   //int nchan = asdm_->getSpectralWindow().getRowByKey(spwtag)->getNumChan() ;
    1841   vector< vector<float> > defaultTsys( 1, vector<float>( 1, 1.0 ) ) ;
     1796  int feedid = vmsData_->v_feedId1[dataIndex_] ;
    18421797  SysCalTable &sctab = asdm_->getSysCal() ;
    1843   //vector<SysCalRow *> rows = sctab.get() ;
    1844   vector<SysCalRow *> *rows = sctab.getByContext( anttag, spwtag, feedid ) ;
     1798  vector<SysCalRow *> *rows = sctab.getByContext( antennaTag_, specWinTag_, feedid ) ;
    18451799  //if ( nrow == 0 ) {
    18461800  if ( rows == 0 ) {
    … …  
    18551809      scindex = 0 ;
    18561810    }
    1857     else if ( getEndTime( tint ) <= getStartTime( (*rows)[0]->getTimeInterval() ) )
     1811    else if ( getEndTime( timeInterval_ ) <= getStartTime( (*rows)[0]->getTimeInterval() ) )
    18581812      scindex = 0 ;
    18591813    else {
    18601814      for ( unsigned int irow = 0 ; irow < nrow-1 ; irow++ ) {
    1861         ArrayTime t = getMidTime( tint ) ;
     1815        ArrayTime t = getMidTime( timeInterval_ ) ;
    18621816        if ( t > getStartTime( (*rows)[irow]->getTimeInterval() )
    18631817             && t <= getStartTime( (*rows)[irow+1]->getTimeInterval() ) ) {

  • branches/casa-prerelease/pre-asap/external-alma/asdm2ASAP/ASDMReader.h

    r2254 r2302  
    143143   * @return scan number
    144144   **/
    145   unsigned int getScanNo() { return (unsigned int)(mainRow_[row_]->getScanNumber()) ; } ;
     145  unsigned int getScanNoOfCurrentRow() { return (unsigned int)(mainRow_[row_]->getScanNumber()) ; } ;
    146146
    147147  /**
    … …  
    150150   * @return subscan number
    151151   **/
    152   unsigned int getSubscanNo() { return (unsigned int)(mainRow_[row_]->getSubscanNumber()) ; } ;
     152  unsigned int getSubscanNoOfCurrentRow() { return (unsigned int)(mainRow_[row_]->getSubscanNumber()) ; } ;
     153
     154  /**
     155   * set data index
     156   *
     157   * @param idx for vmsData_
     158   **/
     159  void prepareData( unsigned int idx ) ;
    153160
    154161  /**
    … …  
    159166   **/
    160167  unsigned int getSubscanNo( unsigned int idx ) ;
     168  unsigned int getSubscanNo() ;
    161169
    162170  /**
    … …  
    167175   **/
    168176  casa::uInt getIFNo( unsigned int idx ) ;
     177  casa::uInt getIFNo() ;
    169178
    170179  /**
    … …  
    175184   **/
    176185  int getNumPol( unsigned int idx ) ;
     186  int getNumPol() ;
    177187
    178188  /**
    … …  
    190200                     double &incr,
    191201                     std::string &freqref ) ;
    192 
    193   /**
    194    * get rest frequencies for given index
    195    *
    196    * @param idx for vmsData_
    197    * @return rest frequencies
    198    **/
    199   vector<double> getRestFrequency( unsigned int idx ) ;
     202  void getFrequency( double &refpix,
     203                     double &refval,
     204                     double &incr,
     205                     std::string &freqref ) ;
    200206
    201207  /**
    … …  
    206212   **/
    207213  double getTime( unsigned int idx ) ;
     214  double getTime() ;
    208215
    209216  /**
    … …  
    214221   **/
    215222  double getInterval( unsigned int idx ) ;
    216 
    217   /**
    218    * get source name for given index
    219    *
    220    * @param idx for vmsData_
    221    * @return source name
    222    **/
    223   string getSourceName( unsigned int idx ) ;
    224 
    225   /**
    226    * get field name for given index
    227    * field name = fieldName + "__" + fieldId
    228    *
    229    * @param idx for vmsData_
    230    * @return field name
    231    **/
    232   string getFieldName( unsigned int idx ) ;
    233 
    234   /**
    235    * get source direction for given index
    236    *
    237    * @param idx for vmsData_
    238    * @return source direction as vector<double>
    239    **/
    240   std::vector<double> getSourceDirection( unsigned int idx ) ;
    241   void getSourceDirection( unsigned int idx,
    242                            std::vector<double> &dir,
    243                            std::string &ref  ) ;
     223  double getInterval() ;
    244224
    245225  /**
    … …  
    253233 
    254234  /**
    255    * get source proper motion for given index
    256    *
    257    * @param idx for vmsData_
    258    * @return source proper motion as vector<double>
    259    **/
    260   std::vector<double> getSourceProperMotion( unsigned int idx ) ;
    261 
    262   /**
    263    * get systemic velocity of the source for given index
    264    * at the moment return 0-th element of sysVel vector
    265    *
    266    * @param idx for vmsData_
    267    * @return systemic velocity of the source
    268    **/
    269   double getSysVel( unsigned int idx ) ;
    270 
    271   /**
    272235   * get row-based flag for given index
    273236   *
    … …  
    276239   **/
    277240  unsigned int getFlagRow( unsigned int idx ) ;
     241  unsigned int getFlagRow() ;
    278242
    279243  /**
    … …  
    284248   **/
    285249  std::vector<unsigned int> getDataShape( unsigned int idx ) ;
     250  std::vector<unsigned int> getDataShape() ;
    286251
    287252  /**
    … …  
    292257   **/
    293258  float *getSpectrum( unsigned int idx ) ;
    294 
    295   /**
    296    * get channel flag data for given index
    297    *
    298    * @param idx for vmsData_
    299    * @return channel flag
    300    **/
    301   //bool *getFlagChannel( unsigned int idx ) ;
     259  float *getSpectrum() ;
     260
     261  /**
     262   * get Tsys for given index
     263   *
     264   * @param idx for vmsData_
     265   * @return Tsys
     266   **/
     267  std::vector< std::vector<float> > getTsys( unsigned int idx ) ;
     268  std::vector< std::vector<float> > getTsys() ;
    302269 
    303270  /**
    304    * get Tsys for given index
    305    *
    306    * @param idx for vmsData_
    307    * @return Tsys
    308    **/
    309   std::vector< std::vector<float> > getTsys( unsigned int idx ) ;
    310  
    311   /**
    312271   * get Tcal for given index
    313272   *
    … …  
    316275   **/
    317276  std::vector< std::vector<float> > getTcal( unsigned int idx ) ;
     277  std::vector< std::vector<float> > getTcal() ;
    318278
    319279  /**
    … …  
    327287                       std::vector< std::vector<float> > &tcal,
    328288                       std::vector< std::vector<float> > &tsys ) ;
     289  void getTcalAndTsys( std::vector< std::vector<float> > &tcal,
     290                       std::vector< std::vector<float> > &tsys ) ;
    329291 
    330292  /**
    … …  
    335297   **/
    336298  std::vector<float> getOpacity( unsigned int idx ) ;
     299  std::vector<float> getOpacity() ;
    337300 
    338301  /**
    … …  
    352315                       float &windspeed,
    353316                       float &windaz ) ;
     317  void getWeatherInfo( float &temperature,
     318                       float &pressure,
     319                       float &humidity,
     320                       float &windspeed,
     321                       float &windaz ) ;
    354322
    355323  /**
    … …  
    367335                        double &el,
    368336                        std::vector<double> &srate ) ;
     337  void getPointingInfo( std::vector<double> &dir,
     338                        double &az,
     339                        double &el,
     340                        std::vector<double> &srate ) ;
    369341
    370342  /**
    … …  
    379351
    380352  /**
    381    * get list of dataDescId for given configDescId
    382    *
    383    * @param configDescId
    384    * @return list of dataDescId
    385    **/
    386 //   casa::Vector<casa::uInt> getDataDescIdList( casa::uInt cdid ) ;
    387 
    388   /**
    389    * get list of switchCycleId for given configDescId
    390    *
    391    * @param configDescId
    392    * @return list of dataDescId
    393    **/
    394 //   casa::Vector<casa::uInt> getSwitchCycleIdList( casa::uInt cdid ) ;
    395 
    396   /**
    397    * get list of feedId for given configDescId
    398    *
    399    * only return list of feedId that corresponds to specified antenna.
    400    *
    401    * @param configDescId
    402    * @return list of valid feedId
    403    **/
    404 //   casa::Vector<casa::uInt> getFeedIdList( casa::uInt cdid ) ;
     353   * get source properties
     354   *
     355   * @param idx for vmsData_
     356   * @param srcname source name
     357   * @param fieldname field name
     358   * @param srcdir source direction
     359   * @param srcpm source proper motion
     360   * @param sysvel systemic velocity of the source
     361   * @param restfreq rest frequency
     362   **/
     363  void getSourceProperty( unsigned int idx,
     364                          std::string &srcname,
     365                          std::string &fieldname,
     366                          std::vector<double> &srcdir,
     367                          std::vector<double> &srcpm,
     368                          double &sysvel,
     369                          std::vector<double> &restfreq ) ;
     370  void getSourceProperty( std::string &srcname,
     371                          std::string &fieldname,
     372                          std::vector<double> &srcdir,
     373                          std::vector<double> &srcpm,
     374                          double &sysvel,
     375                          std::vector<double> &restfreq ) ;
    405376
    406377  /**
    … …  
    516487   **/
    517488  void toJ2000( std::vector<double> &dir,
    518                 double az,
    519                 double el,
    520                 double mjd,
    521                 casa::Vector<casa::Double> antpos ) ;
     489                double &az,
     490                double &el,
     491                double &mjd,
     492                casa::Vector<casa::Quantity> &antpos ) ;
    522493
    523494  /**
    … …  
    530501  * @return new direction
    531502  **/
    532   std::vector<double> toJ2000( std::vector<double> dir,
    533                                casa::String dirref,
    534                                double mjd,
    535                                casa::Vector<casa::Double> antpos ) ;
     503  std::vector<double> toJ2000( std::vector<double> &dir,
     504                               casa::String &dirref,
     505                               double &mjd,
     506                               casa::Vector<casa::Quantity> &antpos ) ;
    536507  /**
    537508   * get nIF
    … …  
    548519   **/
    549520  asdm::SysCalRow *getSysCalRow( unsigned int idx ) ;
     521  asdm::SysCalRow *getSysCalRow() ;
    550522
    551523  /**
    … …  
    595567   * vector< unsigned int > v_flag
    596568   **/
    597   const sdmbin::VMSData *vmsData_ ;
     569  const sdmbin::VMSData *vmsData_ ;
     570 
    598571  casa::Int antennaId_ ; // antenna id
    599572  casa::String antennaName_ ; // antenna name
    600   casa::Vector<asdm::MainRow *> mainRow_ ; // list of pointers to all Main rows
     573  casa::String stationName_ ; // station name
     574  casa::Vector<casa::Quantity> antennaPosition_ ; // antenna position
    601575  casa::Vector<casa::uInt> configDescIdList_ ; // list of valid configDescriptionId
    602576  casa::Vector<casa::uInt> feedIdList_ ; // list of valid feedId
    … …  
    615589  casa::CountedPtr<casa::LogSinkInterface> logsink_ ; // Logger
    616590  casa::String className_ ;
     591  unsigned int dataIndex_ ;
     592
     593  // Tables/Rows for ASDM
     594  casa::Vector<asdm::MainRow *> mainRow_ ; // list of pointers to all Main rows
     595  //asdm::AntennaRow *antennaRow_p ; // pointer to target Antenna row
     596  //asdm::StationRow *stationRow_p ; // pointer to target Station row that target antenna is located
     597  asdm::SpectralWindowRow *specWinRow_p ; // pointer to SpectralWindow row
     598  asdm::PolarizationRow *polarizationRow_p ; // pointer to Polarization row
     599  asdm::FieldRow *fieldRow_p ; // pointer to Field row
     600
     601  // Tags
     602  asdm::Tag antennaTag_ ;
     603  asdm::Tag specWinTag_ ;
     604  asdm::Tag execBlockTag_ ;
     605
     606  // time
     607  asdm::ArrayTimeInterval timeInterval_ ;
    617608} ;
    618609#endif // ASAP_ASDM_READER_H
Note: See TracChangeset for help on using the changeset viewer.