Ignore:
Timestamp:
09/16/11 14:02:21 (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:

Test Programs: test_importasdm_sd

Put in Release Notes: Yes/No?

Module(s): Module Names change impacts.

Description: Describe your changes here...

Refactoring the code.


File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/external-alma/asdm2ASAP/ASDMReader.cc

    r2299 r2301  
    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() ) ) {
Note: See TracChangeset for help on using the changeset viewer.