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/oldasdm2ASAP/OldASDMReader.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_("OldASDMReader")
     35    className_("OldASDMReader"),
     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) ;
    … …  
    168177  asdm_->setFromFile( filename ) ;
    169178
     179  AntennaTable &atab = asdm_->getAntenna() ;
     180  AntennaRow *antennaRow ;
    170181  if ( antennaId_ == -1 ) {
    171     AntennaTable &atab = asdm_->getAntenna() ;
    172182    vector<AntennaRow *> rows = atab.get() ;
    173183    int idx = -1 ;
    … …  
    185195      antennaId_ = idx ;
    186196    }
    187   }
     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 
    188209
    189210  // set antenna name
    190211  if ( antennaName_.size() == 0 ) {
    191     AntennaTable &atab = asdm_->getAntenna() ;
    192     Tag tag( antennaId_, TagType::Antenna ) ;
    193     AntennaRow *arow = atab.getRowByKey( tag ) ;
    194     if ( arow == 0 ) {
    195       close() ;
    196       throw (casa::AipsError( tag.toString() + " not found." )) ;
    197     }
    198     else {
    199       antennaName_ = casa::String( arow->getName() ) ;
    200     }
    201   }
     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" ) ) ;
    202226
    203227  // create SDMBinData object
    … …  
    213237  processStation() ;
    214238
    215   logsink_->postLocally( LogMessage(  "antennaId_ = "+String::toString(antennaId_), LogOrigin(className_,funcName,WHERE) ) ) ;
    216   logsink_->postLocally( LogMessage(  "antennaName_ = "+antennaName_, LogOrigin(className_,funcName,WHERE) ) ) ;
     239  //logsink_->postLocally( LogMessage(  "antennaId_ = "+String::toString(antennaId_), LogOrigin(className_,funcName,WHERE) ) ) ;
     240  //logsink_->postLocally( LogMessage(  "antennaName_ = "+antennaName_, LogOrigin(className_,funcName,WHERE) ) ) ;
    217241
    218242  return true ;
    … …  
    262286  ExecBlockRow *ebrow = ebtab.get()[0] ;
    263287  casa::String telescopeName( ebrow->getTelescopeName() ) ;
    264   AntennaTable &atab = asdm_->getAntenna() ;
    265   AntennaRow *arow = atab.getRowByKey( Tag( antennaId_, TagType::Antenna ) ) ;
    266   //StationTable &stab = asdm_->getStation() ;
    267   //StationRow *srow = stab.getRowByKey( arow->getStationId() ) ;
    268   StationRow *srow = arow->getStationUsingStationId() ;
    269   casa::String stationName( srow->getName() ) ;
     288  //casa::String stationName( stationRow_p->getName() ) ;
    270289
    271290  // antennaname
    272291  // <telescopeName>//<antennaName>@stationName
    273   antennaname = telescopeName + "//" + antennaName_ + "@" + stationName ;
     292  antennaname = telescopeName + "//" + antennaName_ + "@" + stationName_ ;
    274293  //logsink_->postLocally( LogMessage("antennaName = "+antennaname,LogOrigin(className_,funcName,WHERE)) ) ;
    275294
    276295  // antennaposition
    277   //vector<Length> antpos = arow->getPosition() ;
    278   vector<Length> antpos = srow->getPosition() ;
    279296  antennaposition.resize( 3 ) ;
    280297  for ( casa::uInt i = 0 ; i < 3 ; i++ )
    281     antennaposition[i] = casa::Double( antpos[i].get() ) ;
     298    antennaposition[i] = antennaPosition_[i].getValue( Unit("m") ) ;
    282299
    283300  // observer
    … …  
    517534  casa::Bool status = true ;
    518535  row_ = irow ;
     536  execBlockTag_ = mainRow_[row_]->getExecBlockId() ;
    519537
    520538  unsigned int cdid = mainRow_[row_]->getConfigDescriptionId().getTagValue() ;
    … …  
    575593    return false ;
    576594}
    577 
    578 // casa::Vector<casa::uInt> OldASDMReader::getDataDescIdList( casa::uInt cdid )
    579 // {
    580 //   Tag cdTag( (unsigned int)cdid, TagType::ConfigDescription ) ;
    581 //   ConfigDescriptionRow *cdrow = asdm_->getConfigDescription().getRowByKey( cdTag ) ;
    582 //   vector<Tag> ddTags = cdrow->getDataDescriptionId() ;
    583 //   casa::Vector<casa::uInt> ddidList( ddTags.size() ) ;
    584 //   for ( unsigned int idd = 0 ; idd < ddTags.size() ; idd++ ) {
    585 //     ddidList[idd] = ddTags[idd].getTagValue() ;
    586 //   }
    587 //   return ddidList ;
    588 // }
    589 
    590 // casa::Vector<casa::uInt> OldASDMReader::getSwitchCycleIdList( casa::uInt cdid )
    591 // {
    592 //   Tag cdTag( (unsigned int)cdid, TagType::ConfigDescription ) ;
    593 //   ConfigDescriptionRow *cdrow = asdm_->getConfigDescription().getRowByKey( cdTag ) ;
    594 //   vector<Tag> scTags = cdrow->getSwitchCycleId() ;
    595 //   casa::Vector<casa::uInt> scidList( scTags.size() ) ;
    596 //   for ( unsigned int idd = 0 ; idd < scTags.size() ; idd++ ) {
    597 //     scidList[idd] = scTags[idd].getTagValue() ;
    598 //   }
    599 //   return scidList ;
    600 // }
    601 
    602 // casa::Vector<casa::uInt> OldASDMReader::getFeedIdList( casa::uInt cdid )
    603 // {
    604 //   casa::String funcName = "getFeedIdList" ;
    605 //   
    606 //   Tag cdTag( (unsigned int)cdid, TagType::ConfigDescription ) ;
    607 //   ConfigDescriptionRow *cdrow = asdm_->getConfigDescription().getRowByKey( cdTag ) ;
    608 //   casa::Vector<casa::uInt> feedIdList ;
    609 //   vector<int> feedIds = cdrow->getFeedId() ;
    610 //   for ( unsigned int ife = 0 ; ife < feedIds.size() ; ife++ ) {
    611 //     logsink_->postLocally( LogMessage("feedIds["+String::toString(ife)+"]="+String::toString(feedIds[ife]),LogOrigin(className_,funcName,WHERE)) ) ;
    612 //     if ( casa::anyEQ( feedIdList, casa::uInt( feedIds[ife] ) ) )
    613 //       continue ;
    614 //     if ( casa::anyEQ( feedIdList_, casa::uInt( feedIds[ife] ) ) ) {
    615 //       casa::uInt oldsize = feedIdList.size() ;
    616 //       feedIdList.resize( oldsize+1, true ) ;
    617 //       feedIdList[oldsize] = casa::uInt( feedIds[ife] ) ;
    618 //     }
    619 //   }
    620 //   logsink_->postLocally( LogMessage("feedIdList.size() = "+String::toString(feedIdList.size()),LogOrigin(className_,funcName,WHERE)) ) ;
    621 //   return feedIdList ;
    622 // }
    623595
    624596casa::Bool OldASDMReader::setData()
    … …  
    682654}
    683655
     656void OldASDMReader::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
    684673casa::uInt OldASDMReader::getIFNo( unsigned int idx )
    685674{
    686   Tag ddTag( vmsData_->v_dataDescId[dataIdList_[idx]], TagType::DataDescription ) ;
    687   DataDescriptionRow *ddrow = asdm_->getDataDescription().getRowByKey( ddTag ) ;
    688   Tag spwid = ddrow->getSpectralWindowId() ;
    689   map<Tag,casa::uInt>::iterator iter = ifno_.find( spwid ) ;
     675  prepareData( idx ) ;
     676  return getIFNo() ;
     677}
     678
     679casa::uInt OldASDMReader::getIFNo()
     680{
     681  map<Tag,casa::uInt>::iterator iter = ifno_.find( specWinTag_ ) ;
    690682  if ( iter != ifno_.end() )
    691683    return iter->second ;
    … …  
    697689int OldASDMReader::getNumPol( unsigned int idx )
    698690{
    699   Tag ddTag( vmsData_->v_dataDescId[dataIdList_[idx]], TagType::DataDescription ) ;
    700   DataDescriptionRow *ddrow = asdm_->getDataDescription().getRowByKey( ddTag ) ;
    701   PolarizationRow *polrow = ddrow->getPolarizationUsingPolOrHoloId() ;
    702   return polrow->getNumCorr() ;
     691  prepareData( idx ) ;
     692  return getNumPol() ;
     693}
     694
     695int OldASDMReader::getNumPol()
     696{
     697  return polarizationRow_p->getNumCorr() ;
    703698}
    704699
    … …  
    709704                               string &freqref )
    710705{
     706  prepareData( idx ) ;
     707  getFrequency( refpix, refval, incr, freqref ) ;
     708}
     709
     710void OldASDMReader::getFrequency( double &refpix,
     711                               double &refval,
     712                               double &incr,
     713                               string &freqref )
     714{
    711715  casa::String funcName = "getFrequency" ;
    712716
    713   Tag ddTag( vmsData_->v_dataDescId[dataIdList_[idx]], TagType::DataDescription ) ;
    714   DataDescriptionRow *ddrow = asdm_->getDataDescription().getRowByKey( ddTag ) ;
    715   //Tag spwid = ddrow->getSpectralWindowId() ;
    716   SpectralWindowRow *spwrow = ddrow->getSpectralWindowUsingSpectralWindowId() ;
    717   int nchan = spwrow->getNumChan() ;
     717  int nchan = specWinRow_p->getNumChan() ;
    718718  freqref = "TOPO" ;
    719   if ( spwrow->isMeasFreqRefExists() )
    720     freqref = CFrequencyReferenceCode::toString( spwrow->getMeasFreqRef() ) ;
     719  if ( specWinRow_p->isMeasFreqRefExists() )
     720    freqref = CFrequencyReferenceCode::toString( specWinRow_p->getMeasFreqRef() ) ;
    721721  if ( nchan == 1 ) {
    722722    //logsink_->postLocally( LogMessage("channel averaged data",LogOrigin(className_,funcName,WHERE)) ) ;
    723723    refpix = 0.0 ;
    724     incr = spwrow->getTotBandwidth().get() ;
    725     if ( spwrow->isChanFreqStartExists() ) {
    726       refval = spwrow->getChanFreqStart().get() ;
    727     }
    728     else if ( spwrow->isChanFreqArrayExists() ) {
    729       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() ;
    730730    }
    731731    else {
    … …  
    738738    refpix = 0.5 * ( (double)nchan - 1.0 ) ;
    739739    int ic = ( nchan - 1 ) / 2 ;
    740     if ( spwrow->isChanWidthExists() ) {
    741       incr = spwrow->getChanWidth().get() ;
    742     }
    743     else if ( spwrow->isChanWidthArrayExists() ) {
    744       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() ;
    745745    }
    746746    else {
    747747      throw (casa::AipsError( "Either chanWidthArray or chanWidth must exist." )) ;
    748748    }     
    749     if ( spwrow->isChanFreqStepExists() ) {
    750       if ( spwrow->getChanFreqStep().get() < 0.0 )
     749    if ( specWinRow_p->isChanFreqStepExists() ) {
     750      if ( specWinRow_p->getChanFreqStep().get() < 0.0 )
    751751        incr *= -1.0 ;
    752752    }
    753     else if ( spwrow->isChanFreqArrayExists() ) {
    754       vector<Frequency> chanFreqArr = spwrow->getChanFreqArray() ;
     753    else if ( specWinRow_p->isChanFreqArrayExists() ) {
     754      vector<Frequency> chanFreqArr = specWinRow_p->getChanFreqArray() ;
    755755      if ( chanFreqArr[0].get() > chanFreqArr[1].get() )
    756756        incr *= -1.0 ;
    … …  
    759759      throw (casa::AipsError( "Either chanFreqArray or chanFreqStep must exist." )) ;
    760760    }         
    761     if ( spwrow->isChanFreqStartExists() ) {
    762       refval = spwrow->getChanFreqStart().get() + refpix * incr ;
    763     }
    764     else if ( spwrow->isChanFreqArrayExists() ) {
    765       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() ;
    766766    }
    767767    else {
    … …  
    774774    refpix = 0.5 * ( (double)nchan - 1.0 ) ;
    775775    int ic = nchan / 2 ;
    776     if ( spwrow->isChanWidthExists() ) {
    777       incr = spwrow->getChanWidth().get() ;
    778     }
    779     else if ( spwrow->isChanWidthArrayExists() ) {
    780       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() ;
    781781    }
    782782    else {
    783783      throw (casa::AipsError( "Either chanWidthArray or chanWidth must exist." )) ;
    784784    }
    785     if ( spwrow->isChanFreqStepExists() ) {
    786       if ( spwrow->getChanFreqStep().get() < 0.0 )
     785    if ( specWinRow_p->isChanFreqStepExists() ) {
     786      if ( specWinRow_p->getChanFreqStep().get() < 0.0 )
    787787        incr *= -1.0 ;
    788788    }
    789     else if ( spwrow->isChanFreqArrayExists() ) {
    790       vector<Frequency> chanFreqArr = spwrow->getChanFreqArray() ;
     789    else if ( specWinRow_p->isChanFreqArrayExists() ) {
     790      vector<Frequency> chanFreqArr = specWinRow_p->getChanFreqArray() ;
    791791      if ( chanFreqArr[0].get() > chanFreqArr[1].get() )
    792792        incr *= -1.0 ;
    … …  
    795795      throw (casa::AipsError( "Either chanFreqArray or chanFreqStep must exist." )) ;
    796796    }         
    797     if ( spwrow->isChanFreqStartExists() ) {
    798       refval = spwrow->getChanFreqStart().get() + refpix * incr ;
    799     }
    800     else if ( spwrow->isChanFreqArrayExists() ) {
    801       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() ;
    802802      refval = 0.5 * ( freqs[ic-1].get() + freqs[ic].get() ) ;     
    803803    }
    … …  
    808808}
    809809
    810 vector<double> OldASDMReader::getRestFrequency( unsigned int idx )
    811 {
    812   vector<double> rf( 0 ) ;
    813   unsigned int index = dataIdList_[idx] ;
    814   //ArrayTimeInterval tint( vmsData_->v_time[index]*s2d, vmsData_->v_interval[index]*s2d ) ;
    815   double startSec = vmsData_->v_time[index] - 0.5 * vmsData_->v_interval[index] ;
    816   ArrayTimeInterval tint( startSec*s2d, vmsData_->v_interval[index]*s2d ) ;
    817   Tag ddtag( vmsData_->v_dataDescId[index], TagType::DataDescription ) ;
    818   Tag spwtag = asdm_->getDataDescription().getRowByKey(ddtag)->getSpectralWindowId() ;
    819   Tag ftag( vmsData_->v_fieldId[index], TagType::Field ) ;
    820   FieldRow *frow = asdm_->getField().getRowByKey( ftag ) ;
    821   if ( frow->isSourceIdExists() ) {
    822     //logsink_->postLocally( LogMessage("sourceId exists",LogOrigin(className_,funcName,WHERE)) ) ;
    823     int sid = frow->getSourceId() ;
    824     SourceRow *srow = asdm_->getSource().getRowByKey( sid, tint, spwtag ) ;
     810double OldASDMReader::getTime( unsigned int idx )
     811{
     812  prepareData( idx ) ;
     813  return getTime() ;
     814}
     815
     816double OldASDMReader::getTime()
     817{
     818  double tsec = vmsData_->v_time[dataIndex_] ;
     819  return tsec * s2d ;
     820}
     821
     822double OldASDMReader::getInterval( unsigned int idx )
     823{
     824  prepareData( idx ) ;
     825  return getInterval() ;
     826}
     827
     828double OldASDMReader::getInterval()
     829{
     830  return vmsData_->v_interval[dataIndex_] ;
     831}
     832
     833void OldASDMReader::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 OldASDMReader::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
    825895    if ( srow->isRestFrequencyExists() ) {
    826896      //logsink_->postLocally( LogMessage("restFrequency exists",LogOrigin(className_,funcName,WHERE)) ) ;
    827       vector<Frequency> restfreq = srow->getRestFrequency() ;
    828       rf.resize( restfreq.size() ) ;
     897      vector<Frequency> rf = srow->getRestFrequency() ;
     898      restfreq.resize( rf.size() ) ;
    829899      for ( unsigned int i = 0 ; i < restfreq.size() ; i++ )
    830         rf[i] = restfreq[i].get() ;
    831     }
    832   }
    833   return rf ;
    834 }
    835 
    836 double OldASDMReader::getTime( unsigned int idx )
    837 {
    838   double tsec = vmsData_->v_time[dataIdList_[idx]] ;
    839   return tsec * s2d ;
    840 }
    841 
    842 double OldASDMReader::getInterval( unsigned int idx )
    843 {
    844   return vmsData_->v_interval[dataIdList_[idx]] ;
    845 }
    846 
    847 string OldASDMReader::getSourceName( unsigned int idx )
    848 {
    849   unsigned int index = dataIdList_[idx] ;
    850   //ArrayTimeInterval tint( vmsData_->v_time[index]*s2d, vmsData_->v_interval[index]*s2d ) ;
    851   double startSec = vmsData_->v_time[index] - 0.5 * vmsData_->v_interval[index] ;
    852   ArrayTimeInterval tint( startSec*s2d, vmsData_->v_interval[index]*s2d ) ;
    853   Tag ddtag( vmsData_->v_dataDescId[index], TagType::DataDescription ) ;
    854   Tag spwtag = asdm_->getDataDescription().getRowByKey(ddtag)->getSpectralWindowId() ;
    855   Tag ftag( vmsData_->v_fieldId[index], TagType::Field ) ;
    856   FieldRow *frow = asdm_->getField().getRowByKey( ftag ) ;
    857   string srcname ;
    858   if ( frow->isSourceIdExists() ) {
    859     //logsink_->postLocally( LogMessage("sourceId exists",LogOrigin(className_,funcName,WHERE)) ) ;
    860     int sid = frow->getSourceId() ;
    861     SourceRow *srow = asdm_->getSource().getRowByKey( sid, tint, spwtag ) ;
    862     srcname = srow->getSourceName() ;
     900        restfreq[i] = rf[i].get() ;
     901    }
     902    else {
     903      restfreq.resize( 0 ) ;
     904    }
    863905  }
    864906  else {
    865     srcname = frow->getFieldName() ;
    866   }
    867   return srcname ;
    868 }
    869 
    870 string OldASDMReader::getFieldName( unsigned int idx )
    871 {
    872   int fid = vmsData_->v_fieldId[dataIdList_[idx]] ;
    873   Tag ftag( fid, TagType::Field ) ;
    874   FieldRow *frow = asdm_->getField().getRowByKey( ftag ) ;
    875   ostringstream oss ;
    876   oss << frow->getFieldName() << "__" << fid ;
    877   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  }
    878915}
    879916
    … …  
    882919{
    883920  int srctype = SrcType::NOTYPE ;
    884   Tag ebtag = mainRow_[row_]->getExecBlockId() ;
    885   ScanRow *scanrow = asdm_->getScan().getRowByKey( ebtag, (int)scan ) ;
     921  ScanRow *scanrow = asdm_->getScan().getRowByKey( execBlockTag_, (int)scan ) ;
    886922  ScanIntent scanIntent = scanrow->getScanIntent()[0] ;
    887   SubscanRow *subrow = asdm_->getSubscan().getRowByKey( ebtag, (int)scan, (int)subscan ) ;
     923  SubscanRow *subrow = asdm_->getSubscan().getRowByKey( execBlockTag_, (int)scan, (int)subscan ) ;
    888924  SubscanIntent subIntent = subrow->getSubscanIntent() ;
    889925  SwitchingMode swmode = NO_SWITCHING ;
    … …  
    9931029unsigned int OldASDMReader::getSubscanNo( unsigned int idx )
    9941030{
     1031  prepareData( idx ) ;
     1032  return getSubscanNo() ;
     1033}
     1034
     1035unsigned int OldASDMReader::getSubscanNo()
     1036{
    9951037  //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)) ) ;
    996   return vmsData_->v_msState[dataIdList_[idx]].subscanNum ;
    997 }
    998 
    999 vector<double> OldASDMReader::getSourceDirection( unsigned int idx )
    1000 {
    1001   vector<double> dir( 2, 0.0 ) ;
    1002   unsigned int index = dataIdList_[idx] ;
    1003   //ArrayTimeInterval tint( vmsData_->v_time[index]*s2d, vmsData_->v_interval[index]*s2d ) ;
    1004   double startSec = vmsData_->v_time[index] - 0.5 * vmsData_->v_interval[index] ;
    1005   ArrayTimeInterval tint( startSec*s2d, vmsData_->v_interval[index]*s2d ) ;
    1006   Tag ddtag( vmsData_->v_dataDescId[index], TagType::DataDescription ) ;
    1007   Tag spwtag = asdm_->getDataDescription().getRowByKey(ddtag)->getSpectralWindowId() ;
    1008   Tag ftag( vmsData_->v_fieldId[index], TagType::Field ) ;
    1009   FieldRow *frow = asdm_->getField().getRowByKey( ftag ) ;
    1010   string srcname ;
    1011   if ( frow->isSourceIdExists() ) {
    1012     //logsink_->postLocally( LogMessage("sourceId exists",LogOrigin(className_,funcName,WHERE)) ) ;
    1013     int sid = frow->getSourceId() ;
    1014     SourceRow *srow = asdm_->getSource().getRowByKey( sid, tint, spwtag ) ;
    1015     vector<Angle> srcdir = srow->getDirection() ;
    1016     dir[0] = limitedAngle( srcdir[0].get() ) ;
    1017     dir[1] = limitedAngle( srcdir[1].get() ) ;
    1018     if ( srow->isDirectionCodeExists() ) {
    1019       DirectionReferenceCode dircode = srow->getDirectionCode() ;
    1020       //logsink_->postLocally( LogMessage("dircode="+CDirectionReferenceCode::toString(dircode),LogOrigin(className_,funcName,WHERE)) ) ;
    1021       if ( dircode != J2000 ) {
    1022         // if not J2000, need direction conversion
    1023         string ref = CDirectionReferenceCode::toString( dircode ) ;
    1024         double mjd = vmsData_->v_time[index] * s2d ;
    1025         Tag atag( antennaId_, TagType::Antenna ) ;
    1026         AntennaRow *arow = asdm_->getAntenna().getRowByKey( atag ) ;
    1027         StationRow *srow = arow->getStationUsingStationId() ;
    1028         vector<Length> antposL = srow->getPosition() ;
    1029         casa::Vector<casa::Double> antpos( 3 ) ;
    1030         for ( int i = 0 ; i < 3 ; i++ )
    1031           antpos[i] = antposL[i].get() ;
    1032         dir = toJ2000( dir, ref, mjd, antpos ) ;
    1033       }
    1034     }
    1035   }
    1036   return dir ;
    1037 }
    1038 
    1039 void OldASDMReader::getSourceDirection( unsigned int idx,
    1040                                      vector<double> &dir,
    1041                                      string &ref )
    1042 {
    1043   dir.resize( 2 ) ;
    1044   dir[0] = 0.0 ;
    1045   dir[1] = 0.0 ;
    1046   ref = "J2000" ;
    1047   unsigned int index = dataIdList_[idx] ;
    1048   //ArrayTimeInterval tint( vmsData_->v_time[index]*s2d, vmsData_->v_interval[index]*s2d ) ;
    1049   double startSec = vmsData_->v_time[index] - 0.5 * vmsData_->v_interval[index] ;
    1050   ArrayTimeInterval tint( startSec*s2d, vmsData_->v_interval[index]*s2d ) ;
    1051   Tag ddtag( vmsData_->v_dataDescId[index], TagType::DataDescription ) ;
    1052   Tag spwtag = asdm_->getDataDescription().getRowByKey(ddtag)->getSpectralWindowId() ;
    1053   Tag ftag( vmsData_->v_fieldId[index], TagType::Field ) ;
    1054   FieldRow *frow = asdm_->getField().getRowByKey( ftag ) ;
    1055   string srcname ;
    1056   if ( frow->isSourceIdExists() ) {
    1057     //logsink_->postLocally( LogMessage("sourceId exists",LogOrigin(className_,funcName,WHERE)) ) ;
    1058     int sid = frow->getSourceId() ;
    1059     SourceRow *srow = asdm_->getSource().getRowByKey( sid, tint, spwtag ) ;
    1060     vector<Angle> srcdir = srow->getDirection() ;
    1061     if ( srow->isDirectionCodeExists() ) {
    1062       ref = CDirectionReferenceCode::toString( srow->getDirectionCode() ) ;
    1063     }
    1064     dir[0] = limitedAngle( srcdir[0].get() ) ;
    1065     dir[1] = limitedAngle( srcdir[1].get() ) ;
    1066   }
     1038  return vmsData_->v_msState[dataIndex_].subscanNum ;
    10671039}
    10681040
    … …  
    10811053}
    10821054
    1083 vector<double> OldASDMReader::getSourceProperMotion( unsigned int idx )
    1084 {
    1085   vector<double> pm( 2, 0.0 ) ;
    1086   unsigned int index = dataIdList_[idx] ;
    1087   //ArrayTimeInterval tint( vmsData_->v_time[index]*s2d, vmsData_->v_interval[index]*s2d ) ;
    1088   double startSec = vmsData_->v_time[index] - 0.5 * vmsData_->v_interval[index] ;
    1089   ArrayTimeInterval tint( startSec*s2d, vmsData_->v_interval[index]*s2d ) ;
    1090   Tag ddtag( vmsData_->v_dataDescId[index], TagType::DataDescription ) ;
    1091   Tag spwtag = asdm_->getDataDescription().getRowByKey(ddtag)->getSpectralWindowId() ;
    1092   Tag ftag( vmsData_->v_fieldId[index], TagType::Field ) ;
    1093   FieldRow *frow = asdm_->getField().getRowByKey( ftag ) ;
    1094   string srcname ;
    1095   if ( frow->isSourceIdExists() ) {
    1096     //logsink_->postLocally( LogMessage("sourceId exists",LogOrigin(className_,funcName,WHERE)) ) ;
    1097     int sid = frow->getSourceId() ;
    1098     SourceRow *srow = asdm_->getSource().getRowByKey( sid, tint, spwtag ) ;
    1099     vector<AngularRate> srcpm = srow->getProperMotion() ;
    1100     pm[0] = srcpm[0].get() ;
    1101     pm[1] = srcpm[1].get() ;
    1102   }
    1103   return pm ;
    1104 }
    1105 
    1106 double OldASDMReader::getSysVel( unsigned int idx )
    1107 {
    1108   double sysvel = 0.0 ;
    1109   unsigned int index = dataIdList_[idx] ;
    1110   //ArrayTimeInterval tint( vmsData_->v_time[index]*s2d, vmsData_->v_interval[index]*s2d ) ;
    1111   double startSec = vmsData_->v_time[index] - 0.5 * vmsData_->v_interval[index] ;
    1112   ArrayTimeInterval tint( startSec*s2d, vmsData_->v_interval[index]*s2d ) ;
    1113   Tag ddtag( vmsData_->v_dataDescId[index], TagType::DataDescription ) ;
    1114   Tag spwtag = asdm_->getDataDescription().getRowByKey(ddtag)->getSpectralWindowId() ;
    1115   Tag ftag( vmsData_->v_fieldId[index], TagType::Field ) ;
    1116   FieldRow *frow = asdm_->getField().getRowByKey( ftag ) ;
    1117   string srcname ;
    1118   if ( frow->isSourceIdExists() ) {
    1119     //logsink_->postLocally( LogMessage("sourceId exists",LogOrigin(className_,funcName,WHERE)) ) ;
    1120     int sid = frow->getSourceId() ;
    1121     SourceRow *srow = asdm_->getSource().getRowByKey( sid, tint, spwtag ) ;
    1122     if ( srow->isSysVelExists() ) {
    1123       vector<Speed> sysvelV = srow->getSysVel() ;
    1124       if ( sysvelV.size() > 0 )
    1125         sysvel = sysvelV[0].get() ;
    1126     }
    1127   }
    1128   return sysvel ;
    1129 }
    1130 
    11311055unsigned int OldASDMReader::getFlagRow( unsigned int idx )
    11321056{
    1133   return vmsData_->v_flag[dataIdList_[idx]] ;
     1057  prepareData( idx ) ;
     1058  return getFlagRow() ;
     1059}
     1060
     1061unsigned int OldASDMReader::getFlagRow()
     1062{
     1063  return vmsData_->v_flag[dataIndex_] ;
    11341064}
    11351065
    11361066vector<unsigned int> OldASDMReader::getDataShape( unsigned int idx )
    11371067{
    1138   return vmsData_->vv_dataShape[dataIdList_[idx]] ;
     1068  prepareData( idx ) ;
     1069  return getDataShape() ;
     1070}
     1071
     1072vector<unsigned int> OldASDMReader::getDataShape()
     1073{
     1074  return vmsData_->vv_dataShape[dataIndex_] ;
    11391075}
    11401076
    11411077float * OldASDMReader::getSpectrum( unsigned int idx )
    11421078{
    1143   map<AtmPhaseCorrection, float*> data = vmsData_->v_m_data[dataIdList_[idx]] ;
     1079  prepareData( idx ) ;
     1080  return getSpectrum() ;
     1081}
     1082
     1083float * OldASDMReader::getSpectrum()
     1084{
     1085  map<AtmPhaseCorrection, float*> data = vmsData_->v_m_data[dataIndex_] ;
    11441086  //map<AtmPhaseCorrection, float*>::iterator iter = data.find(AP_UNCORRECTED) ;
    11451087  map<AtmPhaseCorrection, float*>::iterator iter = data.find(apc_) ;
    … …  
    11481090}
    11491091
    1150 // bool * OldASDMReader::getFlagChannel( unsigned int idx )
    1151 // {
    1152 //   return 0 ;
    1153 // }
    1154 
    11551092vector< vector<float> > OldASDMReader::getTsys( unsigned int idx )
    11561093{
     1094  prepareData( idx ) ;
     1095  return getTsys() ;
     1096}
     1097
     1098vector< vector<float> > OldASDMReader::getTsys()
     1099{
    11571100  vector< vector<float> > defaultTsys( 1, vector<float>( 1, 1.0 ) ) ;
    1158   SysCalRow *scrow = getSysCalRow( idx ) ;
     1101  SysCalRow *scrow = getSysCalRow() ;
    11591102  if ( scrow != 0 && scrow->isTsysSpectrumExists() ) {
    11601103    vector< vector<Temperature> > tsysSpec = scrow->getTsysSpectrum() ;
    … …  
    11841127vector< vector<float> > OldASDMReader::getTcal( unsigned int idx )
    11851128{
     1129  prepareData( idx ) ;
     1130  return getTcal() ;
     1131}
     1132
     1133vector< vector<float> > OldASDMReader::getTcal()
     1134{
    11861135  vector< vector<float> > defaultTcal( 1, vector<float>( 1, 1.0 ) ) ;
    1187   SysCalRow *scrow = getSysCalRow( idx ) ;
     1136  SysCalRow *scrow = getSysCalRow() ;
    11881137  if ( scrow != 0 && scrow->isTcalSpectrumExists() ) {
    11891138    vector< vector<Temperature> > tcalSpec = scrow->getTcalSpectrum() ;
    … …  
    12151164                                 vector< vector<float> > &tsys )
    12161165{
     1166  prepareData( idx ) ;
     1167  getTcalAndTsys( tcal, tsys ) ;
     1168}
     1169
     1170void OldASDMReader::getTcalAndTsys( vector< vector<float> > &tcal,
     1171                                 vector< vector<float> > &tsys )
     1172{
    12171173  String funcName = "getTcalAndTsys" ;
    12181174
    12191175  vector< vector<float> > defaultT( 1, vector<float>( 1, 1.0 ) ) ;
    1220   SysCalRow *scrow = getSysCalRow( idx ) ;
     1176  SysCalRow *scrow = getSysCalRow() ;
    12211177  if ( scrow == 0 ) {
    12221178    tcal = defaultT ;
    … …  
    12591215vector<float> OldASDMReader::getOpacity( unsigned int idx )
    12601216{
     1217  prepareData( idx ) ;
     1218  return getOpacity() ;
     1219}
     1220
     1221vector<float> OldASDMReader::getOpacity()
     1222{
    12611223  vector<float> tau(0) ;
    12621224  CalAtmosphereTable &atmtab = asdm_->getCalAtmosphere() ;
    12631225  unsigned int nrow = atmtab.size() ;
    12641226  if ( nrow > 0 ) {
    1265     unsigned int index = dataIdList_[idx] ;
    1266     //ArrayTimeInterval tint( vmsData_->v_time[index]*s2d, vmsData_->v_interval[index]*s2d ) ;
    1267     double startSec = vmsData_->v_time[index] - 0.5 * vmsData_->v_interval[index] ;
    1268     ArrayTimeInterval tint( startSec*s2d, vmsData_->v_interval[index]*s2d ) ;
    12691227    //int feedid = vmsData_->v_feedId1[index] ;
    1270     //Tag atag( antennaId_, TagType::Antenna ) ;
    1271     //Tag ddtag( vmsData_->v_dataDescId[index], TagType::DataDescription ) ;
    1272     //DataDescriptionRow *ddrow = asdm_->getDataDescription().getRowByKey(ddtag) ;
    1273     //Tag spwtag = ddrow->getSpectralWindowId() ;
    1274     //SpectralWindowRow *spwrow = ddrow->getSpectralWindowUsingSpectralWindowId() ;
    12751228    //BasebandName bbname = spwrow->getBasebandName() ;
    12761229    //FeedRow *frow = asdm_->getFeed().getRowByKey( atag, spwtag, tint, feedid ) ;
    … …  
    12801233    //ReceiverBand rb = rrows[0]->getFrequencyBand() ;
    12811234    int row0 = -1 ;
    1282     double eps = tint.getStart().getMJD() ;
     1235    double eps = DBL_MAX ;
    12831236    for ( unsigned int irow = 0 ; irow < nrow ; irow++ ) {
    12841237      CalAtmosphereRow *atmrow = atmrows[irow] ;
    … …  
    12891242        continue ;
    12901243      else {
    1291         double dt = tint.getStart().getMJD() - atmrow->getEndValidTime().getMJD() ;
     1244        double dt = timeInterval_.getStart().getMJD() - atmrow->getEndValidTime().getMJD() ;
    12921245        if ( dt >= 0 && dt < eps ) {
    12931246          eps = dt ;
    … …  
    13151268                                 float &windaz )
    13161269{
     1270  prepareData( idx ) ;
     1271  getWeatherInfo( temperature, pressure, humidity, windspeed, windaz ) ;
     1272}
     1273
     1274void OldASDMReader::getWeatherInfo( float &temperature,
     1275                                 float &pressure,
     1276                                 float &humidity,
     1277                                 float &windspeed,
     1278                                 float &windaz )
     1279{
    13171280  casa::String funcName = "getWeatherInfo" ;
    13181281
    … …  
    13291292    return ;
    13301293
    1331   unsigned int index = dataIdList_[idx] ;
    1332   //Tag anttag( antennaId_, TagType::Antenna ) ;
    1333   //Tag sttag = (asdm_->getAntenna().getRowByKey( anttag ))->getStationId() ;
    13341294  Tag sttag( (unsigned int)weatherStationId_, TagType::Station ) ;
    1335   //ArrayTimeInterval tint( vmsData_->v_time[index]*s2d, vmsData_->v_interval[index]*s2d ) ;
    1336   double startSec = vmsData_->v_time[index] - 0.5 * vmsData_->v_interval[index] ;
    1337   ArrayTimeInterval tint( startSec*s2d, vmsData_->v_interval[index]*s2d ) ;
    13381295  //WeatherRow *wrow = wtab.getRowByKey( sttag, tint ) ;
    13391296  vector<WeatherRow *> *wrows = wtab.getByContext( sttag ) ;
    … …  
    13411298  unsigned int nrow = wrows->size() ;
    13421299  //logsink_->postLocally( LogMessage("There are "+String::toString(nrow)+" rows for given context: stationId "+String::toString(weatherStationId_),LogOrigin(className_,funcName,WHERE)) ) ;
    1343   ArrayTime startTime = getMidTime( tint ) ;
     1300  ArrayTime startTime = getMidTime( timeInterval_ ) ;
    13441301  if ( startTime < (*wrows)[0]->getTimeInterval().getStart() ) {
    13451302    temperature = (*wrows)[0]->getTemperature().get() ;
    … …  
    14011358    return -1 ;
    14021359
    1403   Tag atag( antennaId_, TagType::Antenna ) ;
    1404   Tag stag = (asdm_->getAntenna().getRowByKey( atag ))->getStationId() ;
    14051360  vector<double> apos( 3 ) ;
    14061361  StationTable &stab = asdm_->getStation() ;
    1407   StationRow *srow = stab.getRowByKey( stag ) ;
    1408   vector<Length> pos = srow->getPosition() ;
    1409   apos[0] = pos[0].get() ;
    1410   apos[1] = pos[1].get() ;
    1411   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") ) ;
    14121365 
    1413   double eps = 1.0e20 ;
     1366  double eps = DBL_MAX ;
    14141367  int retval = -1 ;
    14151368  for ( unsigned int ir = 0 ; ir < weatherStation_.size() ; ir++ ) {
    1416     srow = stab.getRowByKey( weatherStation_[ir] ) ;
     1369    StationRow *srow = stab.getRowByKey( weatherStation_[ir] ) ;
    14171370    vector<Length> wpos = srow->getPosition() ;
    14181371    double dist = (apos[0]-wpos[0].get())*(apos[0]-wpos[0].get())
    … …  
    14331386                                  vector<double> &srate )
    14341387{
     1388  prepareData( idx ) ;
     1389  getPointingInfo( dir, az, el, srate ) ;
     1390}
     1391
     1392void OldASDMReader::getPointingInfo( vector<double> &dir,
     1393                                  double &az,
     1394                                  double &el,
     1395                                  vector<double> &srate )
     1396{
    14351397  String funcName = "getPointingInfo" ;
    14361398
    … …  
    14401402  srate.resize(0) ;
    14411403
    1442   Tag atag( antennaId_, TagType::Antenna ) ;
    1443   unsigned int index = dataIdList_[idx] ;
    1444   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_ ) ;
    14451408
    14461409  if ( prows == 0 )
    … …  
    14501413  PointingRow *qrow ;
    14511414  //ArrayTimeInterval tint( vmsData_->v_time[index]*s2d, vmsData_->v_interval[index]*s2d ) ;
    1452   double startSec = vmsData_->v_time[index] - 0.5 * vmsData_->v_interval[index] ;
    1453   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 ) ;
    14541417
    14551418  unsigned int nrow = prows->size() ;
    … …  
    14711434  el = 0.0 ;
    14721435  //double tcen = 0.0 ;
    1473   double tcen = getMidTime( tint ).getMJD() ;
     1436  //double tcen = getMidTime( tint ).getMJD() ;
     1437  double tcen = getMidTime( timeInterval_ ).getMJD() ;
    14741438
    14751439  //
    … …  
    14881452  ArrayTimeInterval pTime1 = (*prows)[nrow-1]->getTimeInterval() ;
    14891453  //if ( tint.getStartInMJD()+tint.getDurationInDays() < pTime0.getStartInMJD() ) {
    1490   if ( getEndTime( tint ) < getStartTime( pTime0 ) ) {
     1454  //if ( getEndTime( tint ) < getStartTime( pTime0 ) ) {
     1455  if ( getEndTime( timeInterval_ ) < getStartTime( pTime0 ) ) {
    14911456    logsink_->postLocally( LogMessage( "ArrayTimeInterval out of bounds: no data for given position (tint < ptime)", LogOrigin(className_,funcName,WHERE), LogMessage::WARN ) ) ;
    14921457    prow = (*prows)[0] ;
    … …  
    15001465  }
    15011466  //else if ( tint.getStartInMJD() > pTime1.getStartInMJD()+pTime1.getDurationInDays() ) {
    1502   else if ( getStartTime( tint ) > getEndTime( pTime1 ) ) {
     1467  //else if ( getStartTime( tint ) > getEndTime( pTime1 ) ) {
     1468  else if ( getStartTime( timeInterval_ ) > getEndTime( pTime1 ) ) {
    15031469    logsink_->postLocally( LogMessage( "ArrayTimeInterval out of bounds: no data for given position (tint > ptime)", LogOrigin(className_,funcName,WHERE), LogMessage::WARN ) ) ;
    15041470    prow = (*prows)[nrow-1] ;
    … …  
    15191485  }
    15201486  else {
    1521     ArrayTime startTime = tint.getStart() ;
    1522     ArrayTime endTime = getEndTime( tint ) ;
     1487    //ArrayTime startTime = tint.getStart() ;
     1488    //ArrayTime endTime = getEndTime( tint ) ;
     1489    ArrayTime startTime = timeInterval_.getStart() ;
     1490    ArrayTime endTime = getEndTime( timeInterval_ ) ;
    15231491    int row0 = -1 ;
    15241492    int row1 = -1 ;
    15251493    int row2 = -1 ;
    1526     double dt0 = getMidTime( tint ).getMJD() ;
     1494    //double dt0 = getMidTime( tint ).getMJD() ;
     1495    double dt0 = getMidTime( timeInterval_ ).getMJD() ;
    15271496    for ( unsigned int irow = 0 ; irow < nrow ; irow++ ) {
    15281497      prow = (*prows)[irow] ;
    1529       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() ;
    15301500      if ( dt > 0 && dt < dt0 ) {
    15311501        dt0 = dt ;
    … …  
    16321602            for ( int isam = 0 ; isam < numSample ; isam++ ) {
    16331603              //if ( tint.overlaps( stime[isam] ) ) {
    1634               if ( tint.contains( stime[isam] ) ) {
     1604              //if ( tint.contains( stime[isam] ) ) {
     1605              if ( timeInterval_.contains( stime[isam] ) ) {
    16351606                az += dirA[isam][0] ;
    16361607                el += dirA[isam][1] ;
    … …  
    16491620              ArrayTimeInterval stime( sampleStart+isam*sampleInterval, sampleInterval ) ;
    16501621              //if ( tint.overlaps( stime ) ) {
    1651               if ( tint.contains( stime ) ) {
     1622              //if ( tint.contains( stime ) ) {
     1623              if ( timeInterval_.contains( stime ) ) {
    16521624                az += dirA[isam][0] ;
    16531625                el += dirA[isam][1] ;
    … …  
    16691641    }
    16701642   
    1671     AntennaRow *arow = asdm_->getAntenna().getRowByKey( Tag( antennaId_, TagType::Antenna ) ) ;
    1672     StationRow *srow = arow->getStationUsingStationId() ;
    1673     vector<Length> antposL = srow->getPosition() ;
    1674     casa::Vector<casa::Double> antpos( 3 ) ;
    1675     for ( int i = 0 ; i < 3 ; i++ )
    1676       antpos[i] = antposL[i].get() ;
    1677     //logsink_->postLocally( LogMessage("tcen = "+String::toString(tcen),LogOrigin(className_,funcName,WHERE)) ) ;
    1678     //logsink_->postLocally( LogMessage("antpos = "+String::toString(antpos),LogOrigin(className_,funcName,WHERE)) ) ;
    1679     toJ2000( dir, az, el, tcen, antpos ) ;
    1680 
     1643    toJ2000( dir, az, el, tcen, antennaPosition_ ) ;
    16811644  }
    16821645
    … …  
    17001663
    17011664void OldASDMReader::toJ2000( vector<double> &dir,
    1702                           double az,
    1703                           double el,
    1704                           double mjd,
    1705                           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 )
    17061670{
    17071671  String funcName = "toJ2000" ;
    17081672
     1673  String ref = "AZELGEO" ;
    17091674  vector<double> azel( 2 ) ;
    17101675  azel[0] = az ;
    17111676  azel[1] = el ;
    1712   dir = toJ2000( azel, "AZELGEO", mjd, antpos ) ;
    1713 }
    1714 
    1715 vector<double> OldASDMReader::toJ2000( vector<double> dir,
    1716                                     casa::String dirref,
    1717                                     double mjd,
    1718                                     casa::Vector<casa::Double> antpos )
     1677  dir = toJ2000( azel, ref, mjd, antpos ) ;
     1678}
     1679
     1680vector<double> OldASDMReader::toJ2000( vector<double> &dir,
     1681                                    casa::String &dirref,
     1682                                    double &mjd,
     1683                                    casa::Vector<casa::Quantity> &antpos )
     1684//                                    casa::Vector<casa::Double> antpos )
    17191685{
    17201686  casa::String funcName = "toJ2000" ;
    … …  
    17231689  if ( dirref != "J2000" ) {
    17241690    casa::MEpoch me( casa::Quantity( (casa::Double)mjd, "d" ), casa::MEpoch::UTC ) ;
    1725     casa::Vector<casa::Quantity> qantpos( 3 ) ;
    1726     qantpos[0] = casa::Quantity( antpos[0], "m" ) ;
    1727     qantpos[1] = casa::Quantity( antpos[1], "m" ) ;
    1728     qantpos[2] = casa::Quantity( antpos[2], "m" ) ;
    1729     casa::MPosition mp( casa::MVPosition( qantpos ),
     1691    casa::MPosition mp( casa::MVPosition( antpos ),
    17301692                        casa::MPosition::ITRF ) ;
    17311693    //ostringstream oss ;
    … …  
    18231785SysCalRow *OldASDMReader::getSysCalRow( unsigned int idx )
    18241786{
     1787  prepareData( idx ) ;
     1788  return getSysCalRow() ;
     1789}
     1790
     1791SysCalRow *OldASDMReader::getSysCalRow()
     1792{
    18251793  String funcName = "getSysCalRow" ;
    18261794
    18271795  SysCalRow *row = 0 ;
    1828   unsigned int index = dataIdList_[idx] ;
    1829   Tag anttag( antennaId_, TagType::Antenna ) ;
    1830   int feedid = vmsData_->v_feedId1[index] ;
    1831   //ArrayTimeInterval tint( vmsData_->v_time[index]*s2d, vmsData_->v_interval[index]*s2d ) ;
    1832   double startSec = vmsData_->v_time[index] - 0.5 * vmsData_->v_interval[index] ;
    1833   ArrayTimeInterval tint( startSec*s2d, vmsData_->v_interval[index]*s2d ) ;
    1834   Tag ddtag( vmsData_->v_dataDescId[index], TagType::DataDescription ) ;
    1835   Tag spwtag = asdm_->getDataDescription().getRowByKey(ddtag)->getSpectralWindowId() ;
    1836   //int nchan = asdm_->getSpectralWindow().getRowByKey(spwtag)->getNumChan() ;
    1837   vector< vector<float> > defaultTsys( 1, vector<float>( 1, 1.0 ) ) ;
     1796  int feedid = vmsData_->v_feedId1[dataIndex_] ;
    18381797  SysCalTable &sctab = asdm_->getSysCal() ;
    1839   //vector<SysCalRow *> rows = sctab.get() ;
    1840   vector<SysCalRow *> *rows = sctab.getByContext( anttag, spwtag, feedid ) ;
     1798  vector<SysCalRow *> *rows = sctab.getByContext( antennaTag_, specWinTag_, feedid ) ;
    18411799  //if ( nrow == 0 ) {
    18421800  if ( rows == 0 ) {
    … …  
    18511809      scindex = 0 ;
    18521810    }
    1853     else if ( getEndTime( tint ) <= getStartTime( (*rows)[0]->getTimeInterval() ) )
     1811    else if ( getEndTime( timeInterval_ ) <= getStartTime( (*rows)[0]->getTimeInterval() ) )
    18541812      scindex = 0 ;
    18551813    else {
    18561814      for ( unsigned int irow = 0 ; irow < nrow-1 ; irow++ ) {
    1857         ArrayTime t = getMidTime( tint ) ;
     1815        ArrayTime t = getMidTime( timeInterval_ ) ;
    18581816        if ( t > getStartTime( (*rows)[irow]->getTimeInterval() )
    18591817             && t <= getStartTime( (*rows)[irow+1]->getTimeInterval() ) ) {
    … …  
    18821840vector< vector<double> > OldASDMReader::pointingDir( PointingRow *row )
    18831841{
     1842  //String funcName = "pointingDir" ;
    18841843  vector< vector<Angle> > aTar = row->getTarget() ;
    18851844  vector< vector<Angle> > aOff = row->getOffset() ;
    … …  
    19041863    dir[i][1] = aTar[i][1].get() + aOff[i][1].get()
    19051864               + aEnc[i][1].get() - aDir[i][1].get() ;
     1865    //logsink_->postLocally( LogMessage("tracking offset: ["+String::toString(aEnc[i][0].get()-aDir[i][0].get())+","+String::toString(aEnc[i][0]-aDir[i][0].get())+"]",LogOrigin(className_,funcName,WHERE)) ) ;
    19061866  }
    19071867  return dir ;
Note: See TracChangeset for help on using the changeset viewer.