Ignore:
Timestamp:
10/04/16 18:20:50 (8 years ago)
Author:
Takeshi Nakazato
Message:

New Development: No

JIRA Issue: No

Ready for Test: Yes/No?

Interface Changes: Yes/No?

What Interface Changed: Please list interface changes

Test Programs: List test programs

Put in Release Notes: Yes/No?

Module(s): Module Names change impacts.

Description: Describe your changes here...


Check-in asap modifications from Jim regarding casacore namespace conversion.

Location:
trunk/external-alma/asdm2ASAP
Files:
4 edited

Legend:

Unmodified
Added
Removed

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

    r2869 r3106  
    9090  //logsink_->postLocally( LogMessage("sFreqFrame = "+sFreqFrame,LogOrigin(className_,funcName,WHERE)) ) ;
    9191 
    92   Vector<casa::Double> antpos = table_->getHeader().antennaposition ;
     92  Vector<casacore::Double> antpos = table_->getHeader().antennaposition ;
    9393
    9494  // data selection
    … …  
    194194
    195195          // fill MOLECULE_ID and add MOLECULES row if necessary
    196           Vector<casa::Double> restFreqs( rf.size() ) ;
     196          Vector<casacore::Double> restFreqs( rf.size() ) ;
    197197          for ( uInt i = 0 ; i < rf.size() ; i++ )
    198             restFreqs[i] = (casa::Double)(rf[i]) ;
     198            restFreqs[i] = (casacore::Double)(rf[i]) ;
    199199          setMolecule( restFreqs ) ;
    200200         
    201201          // time and interval
    202           casa::Double mjd = (casa::Double)(reader_->getTime()) ;
    203           casa::Double interval = (casa::Double)(reader_->getInterval()) ;
     202          casacore::Double mjd = (casacore::Double)(reader_->getTime()) ;
     203          casacore::Double interval = (casacore::Double)(reader_->getInterval()) ;
    204204          //logsink_->postLocally( LogMessage("mjd = "+String::toString(mjd),LogOrigin(className_,funcName,WHERE)) ) ;
    205205
    … …  
    208208         
    209209          // fill SRCNAME, SRCTYPE, FIELDNAME, SRCDIRECTION, SRCPROPERMOTION, and SRCVELOCITY
    210           Vector<casa::Double> srcDir( 2 ) ;
    211           srcDir[0] = (casa::Double)(srcDirection[0]) ;
    212           srcDir[1] = (casa::Double)(srcDirection[1]) ;
    213           Vector<casa::Double> srcPM( 2 ) ;
    214           srcPM[0] = (casa::Double)(srcProperMotion[0]) ;
    215           srcPM[1] = (casa::Double)(srcProperMotion[1]) ;
    216           setSource( srcname, srctype, fieldname, srcDir, srcPM, (casa::Double)sysVel ) ;
     210          Vector<casacore::Double> srcDir( 2 ) ;
     211          srcDir[0] = (casacore::Double)(srcDirection[0]) ;
     212          srcDir[1] = (casacore::Double)(srcDirection[1]) ;
     213          Vector<casacore::Double> srcPM( 2 ) ;
     214          srcPM[0] = (casacore::Double)(srcProperMotion[0]) ;
     215          srcPM[1] = (casacore::Double)(srcProperMotion[1]) ;
     216          setSource( srcname, srctype, fieldname, srcDir, srcPM, (casacore::Double)sysVel ) ;
    217217
    218218          // fill FLAGROW
    … …  
    231231                                   windspeed,
    232232                                   windaz ) ;
    233           setWeather2( (casa::Float)temperature,
    234                        (casa::Float)pressure,
    235                        (casa::Float)humidity,
    236                        (casa::Float)windspeed,
    237                        (casa::Float)windaz ) ;
     233          setWeather2( (casacore::Float)temperature,
     234                       (casacore::Float)pressure,
     235                       (casacore::Float)humidity,
     236                       (casacore::Float)windspeed,
     237                       (casacore::Float)windaz ) ;
    238238          //logsink_->postLocally( LogMessage("temperature = "+String::toString(temperature),LogOrigin(className_,funcName,WHERE)) ) ;
    239239          // fill AZIMUTH, ELEVATION, DIRECTION and SCANRATE
    … …  
    246246                                    el,
    247247                                    srate ) ;
    248           Vector<casa::Double> scanRate( 2, 0.0 ) ;
    249           Vector<casa::Double> direction( 2, 0.0 ) ;
     248          Vector<casacore::Double> scanRate( 2, 0.0 ) ;
     249          Vector<casacore::Double> direction( 2, 0.0 ) ;
    250250          if ( srate.size() > 0 ) {
    251             scanRate[0] = (casa::Double)(srate[0]) ;
    252             scanRate[1] = (casa::Double)(srate[1]) ;
     251            scanRate[0] = (casacore::Double)(srate[0]) ;
     252            scanRate[1] = (casacore::Double)(srate[1]) ;
    253253          }
    254254          setScanRate( scanRate ) ;
    255255          if ( dir.size() > 0 ) {
    256             direction[0] = (casa::Double)(dir[0]) ;
    257             direction[1] = (casa::Double)(dir[1]) ;
     256            direction[0] = (casacore::Double)(dir[0]) ;
     257            direction[1] = (casacore::Double)(dir[1]) ;
    258258          }
    259259          else {
    … …  
    261261          }
    262262          //logsink_->postLocally( LogMessage("direction = "+String::toString(direction),LogOrigin(className_,funcName,WHERE)) ) ;
    263           setDirection( direction, (casa::Float)az, (casa::Float)el ) ;
     263          setDirection( direction, (casacore::Float)az, (casacore::Float)el ) ;
    264264
    265265           // REFPIX, REFVAL, INCREMENT
    … …  
    270270          else {
    271271            reader_->getFrequency( refpix, refval, incr, freqref ) ;
    272             refval = (double)toLSRK( casa::Double(refval),
     272            refval = (double)toLSRK( casacore::Double(refval),
    273273                                     String(freqref),
    274274                                     hdr.utc,
    … …  
    281281
    282282          // fill FREQ_ID and add FREQUENCIES row if necessary
    283           setFrequency( (casa::Double)refpix, (casa::Double)refval, (casa::Double)incr ) ;
     283          setFrequency( (casacore::Double)refpix, (casacore::Double)refval, (casacore::Double)incr ) ;
    284284
    285285          // loop on polarization
    … …  
    303303          // OPACITY
    304304          vector<float> tau = reader_->getOpacity() ;
    305           Vector<casa::Float> opacity = toVector( tau, numPol ) ;
     305          Vector<casacore::Float> opacity = toVector( tau, numPol ) ;
    306306
    307307          // SPECTRA, FLAGTRA, TSYS, TCAL
    … …  
    311311          vector< vector<float> > tc ;
    312312          reader_->getTcalAndTsys( tc, ts ) ;
    313           Matrix<casa::Float> spectra = toMatrix( sp, numPol, numChan ) ;
     313          Matrix<casacore::Float> spectra = toMatrix( sp, numPol, numChan ) ;
    314314          //logsink_->postLocally( LogMessage("spectra(0,0) = "+String::toString(spectra(0,0)),LogOrigin(className_,funcName,WHERE)) ) ;
    315315          Vector<uChar> flagtra( numChan, 0 ) ;
    316           Matrix<casa::Float> tsys = toMatrix( ts, numPol, numChan ) ;
    317           Matrix<casa::Float> tcal = toMatrix( tc, numPol, numChan ) ;
     316          Matrix<casacore::Float> tsys = toMatrix( ts, numPol, numChan ) ;
     317          Matrix<casacore::Float> tcal = toMatrix( tc, numPol, numChan ) ;
    318318          //logsink_->postLocally( LogMessage("tsys(0,0) = "+String::toString(tsys(0,0)),LogOrigin(className_,funcName,WHERE)) ) ;
    319319//           String caltime = "" ;
    320 //           if ( anyNE( tcal, (casa::Float)1.0 ) )
     320//           if ( anyNE( tcal, (casacore::Float)1.0 ) )
    321321//             caltime = toTcalTime( mjd ) ;
    322322          String caltime = toTcalTime( mjd ) ;
    … …  
    401401    string ref ;
    402402    reader_->getSourceDirection( sdir, ref ) ;
    403     Vector<casa::Double> sourceDir( sdir ) ;
     403    Vector<casacore::Double> sourceDir( sdir ) ;
    404404    hdr.reffreq = toLSRK( hdr.reffreq, hdr.freqref, hdr.utc, hdr.antennaposition, sdir, String(ref) ) ;
    405405    hdr.freqref = "LSRK" ;
    … …  
    437437}
    438438
    439 Matrix<casa::Float> ASDMFiller::toMatrix( float *sp,
     439Matrix<casacore::Float> ASDMFiller::toMatrix( float *sp,
    440440                                         unsigned int npol,
    441441                                         unsigned int nchan )
    442442{
    443   Matrix<casa::Float> mSp( npol, nchan ) ;
     443  Matrix<casacore::Float> mSp( npol, nchan ) ;
    444444  if ( npol <= 2 ) {
    445445    // 1 or 2 polarization case
    446446    for ( unsigned int ich = 0 ; ich < nchan ; ich++ ) {
    447447      for ( unsigned int ipol = 0 ; ipol < npol ; ipol++ ) {
    448         mSp(ipol,ich) = (casa::Float)(sp[npol*ich+ipol]) ;
     448        mSp(ipol,ich) = (casacore::Float)(sp[npol*ich+ipol]) ;
    449449      }
    450450    }
    … …  
    453453    // 4 polarization case
    454454    for ( unsigned int ich = 0 ; ich < nchan ; ich++ ) {
    455       mSp(0,ich) = (casa::Float)(sp[4*ich]) ;   // Re(XX)
    456       mSp(1,ich) = (casa::Float)(sp[4*ich+4]) ; // Re(YY)
    457       mSp(2,ich) = (casa::Float)(sp[4*ich+2]) ; // Re(XY)
    458       mSp(3,ich) = (casa::Float)(sp[4*ich+3]) ; // Im(XY)
     455      mSp(0,ich) = (casacore::Float)(sp[4*ich]) ;   // Re(XX)
     456      mSp(1,ich) = (casacore::Float)(sp[4*ich+4]) ; // Re(YY)
     457      mSp(2,ich) = (casacore::Float)(sp[4*ich+2]) ; // Re(XY)
     458      mSp(3,ich) = (casacore::Float)(sp[4*ich+3]) ; // Im(XY)
    459459    }
    460460  }
    … …  
    462462}
    463463
    464 Matrix<casa::Float> ASDMFiller::toMatrix( vector< vector<float> > &tsys,
     464Matrix<casacore::Float> ASDMFiller::toMatrix( vector< vector<float> > &tsys,
    465465                                               unsigned int npol,
    466466                                               unsigned int nchan )
    … …  
    468468  unsigned int numRec = tsys.size() ;
    469469  unsigned int numChan = tsys[0].size() ;
    470   Matrix<casa::Float> ret ;
     470  Matrix<casacore::Float> ret ;
    471471  if ( npol == numRec && nchan == numChan ) {
    472472    ret.resize( npol, nchan ) ;
    473473    for ( unsigned int ip = 0 ; ip < npol ; ip++ )
    474474      for ( unsigned int ic = 0 ; ic < nchan ; ic++ )
    475         ret( ip, ic ) = (casa::Float)(tsys[ip][ic]) ;
     475        ret( ip, ic ) = (casacore::Float)(tsys[ip][ic]) ;
    476476  }
    477477  else if ( npol == numRec && numChan == 1 ) {
    478478    ret.resize( npol, 1 ) ;
    479479    for ( unsigned int ip = 0 ; ip < npol ; ip++ )
    480       ret( ip, 0 ) = (casa::Float)(tsys[0][0]) ;
     480      ret( ip, 0 ) = (casacore::Float)(tsys[0][0]) ;
    481481  }
    482482  else if ( numRec == 1 && nchan == numChan ) {
    … …  
    484484    for ( unsigned int ip = 0 ; ip < npol ; ip++ )
    485485      for ( unsigned int ic = 0 ; ic < nchan ; ic++ )
    486         ret( ip, ic ) = (casa::Float)(tsys[0][ic]) ;
     486        ret( ip, ic ) = (casacore::Float)(tsys[0][ic]) ;
    487487  }
    488488  else if ( numRec == 1 && numChan == 1 ) {
    489489    ret.resize( npol, 1 ) ;
    490490    for ( unsigned int ip = 0 ; ip < npol ; ip++ )
    491       ret( ip, 0 ) = (casa::Float)(tsys[0][0]) ;
     491      ret( ip, 0 ) = (casacore::Float)(tsys[0][0]) ;
    492492  }
    493493  else if ( numRec == 2 && npol == 4 && numChan == nchan ) {
    … …  
    496496    ret.resize( npol, nchan ) ;
    497497    for ( unsigned int ic = 0 ; ic < nchan ; ic++ ) {
    498       casa::Float tsysxy = (casa::Float)(0.5*(tsys[0][ic]+tsys[1][ic])) ;
    499       ret( 0, ic ) = (casa::Float)(tsys[0][ic]) ;
    500       ret( 1, ic ) = (casa::Float)(tsys[1][ic]) ;
     498      casacore::Float tsysxy = (casacore::Float)(0.5*(tsys[0][ic]+tsys[1][ic])) ;
     499      ret( 0, ic ) = (casacore::Float)(tsys[0][ic]) ;
     500      ret( 1, ic ) = (casacore::Float)(tsys[1][ic]) ;
    501501      ret( 2, ic ) = tsysxy ;
    502502      ret( 3, ic ) = tsysxy ;
    … …  
    507507    //       at the moment Tsys[XY] = 0.5*(Tsys[X]+Tsys[Y])
    508508    ret.resize( npol, 1 ) ;
    509     casa::Float tsysxy = (casa::Float)(0.5*(tsys[0][0]+tsys[1][0])) ;
    510     ret( 0, 0 ) = (casa::Float)(tsys[0][0]) ;
    511     ret( 1, 0 ) = (casa::Float)(tsys[1][0]) ;
     509    casacore::Float tsysxy = (casacore::Float)(0.5*(tsys[0][0]+tsys[1][0])) ;
     510    ret( 0, 0 ) = (casacore::Float)(tsys[0][0]) ;
     511    ret( 1, 0 ) = (casacore::Float)(tsys[1][0]) ;
    512512    ret( 2, 0 ) = tsysxy ;
    513513    ret( 3, 0 ) = tsysxy ;
    … …  
    517517    for ( unsigned int ip = 0 ; ip < npol ; ip++ )
    518518      for ( unsigned int ic = 0 ; ic < nchan ; ic++ )
    519         ret( ip, ic ) = (casa::Float)(tsys[0][ic]) ;   
     519        ret( ip, ic ) = (casacore::Float)(tsys[0][ic]) ;   
    520520  }
    521521  return ret ;
    522522}
    523523
    524 Vector<casa::Float> ASDMFiller::toVector( vector<float> &tau,
     524Vector<casacore::Float> ASDMFiller::toVector( vector<float> &tau,
    525525                                               unsigned int npol )
    526526{
    527527  String funcName = "toVector" ;
    528528
    529   Vector<casa::Float> ret( npol ) ;
     529  Vector<casacore::Float> ret( npol ) ;
    530530  //logsink_->postLocally( LogMessage("tau0="+String::toString(tau[0]),LogOrigin(className_,funcName,WHERE)) ) ;
    531531  if ( npol == 4 ) {
    532     ret[0] = (casa::Float)tau[0] ;
    533     ret[1] = (casa::Float)tau[1] ;
     532    ret[0] = (casacore::Float)tau[0] ;
     533    ret[1] = (casacore::Float)tau[1] ;
    534534    ret[2] = 0.5 * ( ret[0] + ret[1] ) ;
    535535    ret[3] = ret[2] ;
    … …  
    537537  else if ( npol == tau.size() ) {
    538538    for ( unsigned int ipol = 0 ; ipol < npol ; ipol++ )
    539       ret[ipol] = (casa::Float)tau[ipol] ;
     539      ret[ipol] = (casacore::Float)tau[ipol] ;
    540540  }
    541541  else {
    542542    // I don't know how to handle...
    543543    for ( unsigned int ipol = 0 ; ipol < npol ; ipol++ )
    544       ret[ipol] = (casa::Float)tau[0] ;
     544      ret[ipol] = (casacore::Float)tau[0] ;
    545545  }
    546546  //logsink_->postLocally( LogMessage("tau="+String::toString(ret),LogOrigin(className_,funcName,WHERE)) ) ;
    … …  
    548548}
    549549
    550 String ASDMFiller::toTcalTime( casa::Double mjd )
     550String ASDMFiller::toTcalTime( casacore::Double mjd )
    551551{
    552552  return MVTime( mjd ).string( MVTime::YMD ) ;
    553553}
    554554
    555 void ASDMFiller::toJ2000( Vector<casa::Double> &dir,
     555void ASDMFiller::toJ2000( Vector<casacore::Double> &dir,
    556556                               double az,
    557557                               double el,
    558                                casa::Double mjd,
    559                                Vector<casa::Double> antpos )
     558                               casacore::Double mjd,
     559                               Vector<casacore::Double> antpos )
    560560{
    561561  String funcName = "toJ2000" ;
    562562
    563   Vector<casa::Double> azel( 2 ) ;
     563  Vector<casacore::Double> azel( 2 ) ;
    564564  azel[0] = az ;
    565565  azel[1] = el ;
    … …  
    580580}
    581581
    582 Vector<casa::Double> ASDMFiller::toJ2000( Vector<casa::Double> dir,
     582Vector<casacore::Double> ASDMFiller::toJ2000( Vector<casacore::Double> dir,
    583583                                          String dirref,
    584                                           casa::Double mjd,
    585                                           Vector<casa::Double> antpos )
    586 {
    587   Vector<casa::Double> newd( dir ) ;
     584                                          casacore::Double mjd,
     585                                          Vector<casacore::Double> antpos )
     586{
     587  Vector<casacore::Double> newd( dir ) ;
    588588  if ( dirref != "J2000" ) {
    589589    MEpoch me( Quantity( mjd, "d" ), MEpoch::UTC ) ;
    … …  
    620620}
    621621
    622 casa::Double ASDMFiller::toLSRK( casa::Double freq,
     622casacore::Double ASDMFiller::toLSRK( casacore::Double freq,
    623623                                 String freqref,
    624                                  casa::Double utc,
    625                                  Vector<casa::Double> antpos,
    626                                  Vector<casa::Double> dir,
     624                                 casacore::Double utc,
     625                                 Vector<casacore::Double> antpos,
     626                                 Vector<casacore::Double> dir,
    627627                                 String dirref )
    628628{
    … …  
    630630
    631631  //logsink_->postLocally( LogMessage("freqref = "+freqref,LogOrigin(className_,funcName,WHERE)) ) ;
    632   casa::Double newf = freq ;
     632  casacore::Double newf = freq ;
    633633  if ( freqToLsr_ && freqref != "LSRK" ) {
    634     MEpoch me( Quantum<casa::Double>( utc, Unit("d") ), MEpoch::UTC ) ;
    635     Vector< Quantum<casa::Double> > antposQ( 3 ) ;
     634    MEpoch me( Quantum<casacore::Double>( utc, Unit("d") ), MEpoch::UTC ) ;
     635    Vector< Quantum<casacore::Double> > antposQ( 3 ) ;
    636636    for ( int i = 0 ; i < 3 ; i++ )
    637       antposQ[i] = Quantum<casa::Double>( antpos[i], Unit("m") ) ;
     637      antposQ[i] = Quantum<casacore::Double>( antpos[i], Unit("m") ) ;
    638638    MPosition mp( antposQ, MPosition::ITRF ) ;
    639639    MDirection::Types dirtype ;
    … …  
    641641    if ( !b )
    642642      dirtype = MDirection::J2000 ;
    643     MDirection md( Quantum<casa::Double>( dir[0], Unit("rad") ),
    644                    Quantum<casa::Double>( dir[1], Unit("rad") ),
     643    MDirection md( Quantum<casacore::Double>( dir[0], Unit("rad") ),
     644                   Quantum<casacore::Double>( dir[1], Unit("rad") ),
    645645                   dirtype ) ;
    646646    MeasFrame mf( me, mp, md ) ;
    … …  
    651651    MFrequency::Convert tolsr( freqtype,
    652652                               MFrequency::Ref( MFrequency::LSRK, mf ) ) ;
    653     newf = tolsr( Quantum<casa::Double>( freq, Unit("Hz") ) ).get( "Hz" ).getValue() ;
     653    newf = tolsr( Quantum<casacore::Double>( freq, Unit("Hz") ) ).get( "Hz" ).getValue() ;
    654654    //logsink_->postLocally( LogMessage("freq = "+String::toString(freq)+", newf = "+String::toString(newf),LogOrigin(className_,funcName,WHERE)) ) ;
    655655  }

  • trunk/external-alma/asdm2ASAP/ASDMFiller.h

    r2754 r3106  
    1313public:
    1414  // constructor and destructor
    15   ASDMFiller( casa::CountedPtr<asap::Scantable> stable ) ;
     15  ASDMFiller( casacore::CountedPtr<asap::Scantable> stable ) ;
    1616  ~ASDMFiller() ;
    1717
    1818  // open data
    19   bool open( const std::string &filename, const casa::Record &rec ) ;
     19  bool open( const std::string &filename, const casacore::Record &rec ) ;
    2020
    2121  // fill data
    … …  
    2626 
    2727  // get reader object
    28   casa::CountedPtr<ASDMReader> getReader() { return reader_ ; } ;
     28  casacore::CountedPtr<ASDMReader> getReader() { return reader_ ; } ;
    2929
    3030  // set logger
    31   void setLogger( casa::CountedPtr<casa::LogSinkInterface> &logsink ) ;
     31  void setLogger( casacore::CountedPtr<casacore::LogSinkInterface> &logsink ) ;
    3232
    3333private:
    … …  
    3636
    3737  // get IF key
    38   casa::String getIFKey( casa::uInt ifno ) ;
     38  casacore::String getIFKey( casacore::uInt ifno ) ;
    3939
    4040  // get FREQUENCIES attributes from ifrec_
    41   void getFrequencyRec( casa::String key,
     41  void getFrequencyRec( casacore::String key,
    4242                        double &refpix,
    4343                        double &refval,
    … …  
    4545
    4646  // set FREQUENCIES attributes to ifrec_
    47   void setFrequencyRec( casa::String key,
     47  void setFrequencyRec( casacore::String key,
    4848                        double refpix,
    4949                        double refval,
    … …  
    5151                     
    5252  // reshape float array spectra to Matrix<Float>
    53   casa::Matrix<casa::Float> toMatrix( float *sp,
     53  casacore::Matrix<casacore::Float> toMatrix( float *sp,
    5454                                      unsigned int npol,
    5555                                      unsigned int nchan ) ;
    5656
    5757  // reshape 2d vector Tsys to Matrix<Float>
    58   casa::Matrix<casa::Float> toMatrix( std::vector< std::vector<float> > &tsys,
     58  casacore::Matrix<casacore::Float> toMatrix( std::vector< std::vector<float> > &tsys,
    5959                                      unsigned int npol,
    6060                                      unsigned int nchan ) ;
    6161
    6262  // reshape vector<float> to Vector<Float> with appropriate length
    63   casa::Vector<casa::Float> toVector( std::vector<float> &tau,
     63  casacore::Vector<casacore::Float> toVector( std::vector<float> &tau,
    6464                                      unsigned int npol ) ;
    6565
    6666  // create TCAL time string from MJD
    67   casa::String toTcalTime( casa::Double mjd ) ;
     67  casacore::String toTcalTime( casacore::Double mjd ) ;
    6868
    6969  // AZEL to J2000
    70   void toJ2000( casa::Vector<casa::Double> &dir,
     70  void toJ2000( casacore::Vector<casacore::Double> &dir,
    7171                double az,
    7272                double el,
    73                 casa::Double mjd,
    74                 casa::Vector<casa::Double> antpos ) ;
     73                casacore::Double mjd,
     74                casacore::Vector<casacore::Double> antpos ) ;
    7575
    7676  // to J2000
    77   casa::Vector<casa::Double> toJ2000( casa::Vector<casa::Double> dir,
    78                                       casa::String dirref,
    79                                       casa::Double mjd,
    80                                       casa::Vector<casa::Double> antpos ) ;
     77  casacore::Vector<casacore::Double> toJ2000( casacore::Vector<casacore::Double> dir,
     78                                      casacore::String dirref,
     79                                      casacore::Double mjd,
     80                                      casacore::Vector<casacore::Double> antpos ) ;
    8181
    8282  // get frequency frame enum value from string
    83   casa::MFrequency::Types toFrameType( std::string &s ) ;
     83  casacore::MFrequency::Types toFrameType( std::string &s ) ;
    8484
    8585  // to LSRK
    8686  // utc must be UTC time in "d" (day)
    8787  // antpos must be ITRF value in "m"
    88   casa::Double toLSRK( casa::Double freq,
    89                        casa::String freqref,
    90                        casa::Double utc,
    91                        casa::Vector<casa::Double> antpos,
    92                        casa::Vector<casa::Double> dir,
    93                        casa::String dirref ) ;
     88  casacore::Double toLSRK( casacore::Double freq,
     89                       casacore::String freqref,
     90                       casacore::Double utc,
     91                       casacore::Vector<casacore::Double> antpos,
     92                       casacore::Vector<casacore::Double> dir,
     93                       casacore::String dirref ) ;
    9494
    95   casa::CountedPtr<ASDMReader> reader_ ;
    96   casa::Int antennaId_ ;
    97   casa::String antennaName_ ;
     95  casacore::CountedPtr<ASDMReader> reader_ ;
     96  casacore::Int antennaId_ ;
     97  casacore::String antennaName_ ;
    9898
    99   casa::Record ifrec_ ;
     99  casacore::Record ifrec_ ;
    100100
    101   casa::CountedPtr<casa::LogSinkInterface> logsink_ ;
     101  casacore::CountedPtr<casacore::LogSinkInterface> logsink_ ;
    102102
    103   casa::String className_ ;
    104   casa::Bool freqToLsr_ ;
     103  casacore::String className_ ;
     104  casacore::Bool freqToLsr_ ;
    105105
    106106} ;

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

    r2755 r3106  
    5757}
    5858
    59 bool ASDMReader::open( const string &filename, const casa::Record &rec )
    60 {
    61   casa::String funcName = "open" ;
     59bool ASDMReader::open( const string &filename, const casacore::Record &rec )
     60{
     61  casacore::String funcName = "open" ;
    6262
    6363  // return value
    … …  
    7272  // parsing ASDM options
    7373  if ( rec.isDefined( "asdm" ) ) {
    74     casa::Record asdmrec = rec.asRecord( "asdm" ) ;
     74    casacore::Record asdmrec = rec.asRecord( "asdm" ) ;
    7575
    7676    // antenna
    7777    if ( asdmrec.isDefined( "antenna" ) ) {
    78       if ( asdmrec.type( asdmrec.fieldNumber( "antenna" ) ) == casa::TpInt ) {
     78      if ( asdmrec.type( asdmrec.fieldNumber( "antenna" ) ) == casacore::TpInt ) {
    7979        antennaId_ = asdmrec.asInt( "antenna" ) ;
    8080      }
    … …  
    183183    vector<AntennaRow *> rows = atab.get() ;
    184184    int idx = -1 ;
    185     for ( casa::uInt irow = 0 ; irow < rows.size() ; irow++ ) {
    186       if ( casa::String(rows[irow]->getName()) == antennaName_ ) {
     185    for ( casacore::uInt irow = 0 ; irow < rows.size() ; irow++ ) {
     186      if ( casacore::String(rows[irow]->getName()) == antennaName_ ) {
    187187        idx = rows[irow]->getAntennaId().getTagValue() ;
    188188        break ;
    … …  
    191191    if ( idx == -1 ) {
    192192      close() ;
    193       throw (casa::AipsError( antennaName_ + " not found." )) ;
     193      throw (casacore::AipsError( antennaName_ + " not found." )) ;
    194194    }
    195195    else {
    … …  
    204204    if ( antennaRow == 0 ) {
    205205      close() ;
    206       throw (casa::AipsError( "AntennaId " + casa::String::toString(antennaId_) + " is invalid." ) ) ;
     206      throw (casacore::AipsError( "AntennaId " + casacore::String::toString(antennaId_) + " is invalid." ) ) ;
    207207    }
    208208  }
    … …  
    211211  // set antenna name
    212212  if ( antennaName_.size() == 0 ) {
    213     antennaName_ = casa::String( antennaRow->getName() ) ;
     213    antennaName_ = casacore::String( antennaRow->getName() ) ;
    214214  }
    215215
    … …  
    218218
    219219  // station name
    220   stationName_ = casa::String( stationRow->getName() ) ;
     220  stationName_ = casacore::String( stationRow->getName() ) ;
    221221
    222222  // antenna position
    223223  antennaPosition_.resize( 3 ) ;
    224224  vector<Length> antpos = stationRow->getPosition() ;
    225   for ( casa::uInt i = 0 ; i < 3 ; i++ )
    226     antennaPosition_[i] = Quantity( casa::Double( antpos[i].get() ), Unit( "m" ) ) ;
    227   mp_ = casa::MPosition( casa::MVPosition( antennaPosition_ ),
    228                          casa::MPosition::ITRF ) ;
     225  for ( casacore::uInt i = 0 ; i < 3 ; i++ )
     226    antennaPosition_[i] = Quantity( casacore::Double( antpos[i].get() ), Unit( "m" ) ) ;
     227  mp_ = casacore::MPosition( casacore::MVPosition( antennaPosition_ ),
     228                         casacore::MPosition::ITRF ) ;
    229229  mf_.set( mp_ ) ;
    230230
    … …  
    233233
    234234  // get Main rows
    235   //mainRow_ = casa::Vector<MainRow *>(asdm_->getMain().get()) ;
     235  //mainRow_ = casacore::Vector<MainRow *>(asdm_->getMain().get()) ;
    236236
    237237  // set up IFNO
    … …  
    266266}
    267267
    268 void ASDMReader::fillHeader( casa::Int &nchan,
    269                              casa::Int &npol,
    270                              casa::Int &nif,
    271                              casa::Int &nbeam,
    272                              casa::String &observer,
    273                              casa::String &project,
    274                              casa::String &obstype,
    275                              casa::String &antennaname,
    276                              casa::Vector<casa::Double> &antennaposition,
    277                              casa::Float &equinox,
    278                              casa::String &freqref,
    279                              casa::Double &reffreq,
    280                              casa::Double &bandwidth,
    281                              casa::Double &utc,
    282                              casa::String &fluxunit,
    283                              casa::String &epoch,
    284                              casa::String &poltype )
    285 {
    286   casa::String funcName = "fillHeader" ;
     268void ASDMReader::fillHeader( casacore::Int &nchan,
     269                             casacore::Int &npol,
     270                             casacore::Int &nif,
     271                             casacore::Int &nbeam,
     272                             casacore::String &observer,
     273                             casacore::String &project,
     274                             casacore::String &obstype,
     275                             casacore::String &antennaname,
     276                             casacore::Vector<casacore::Double> &antennaposition,
     277                             casacore::Float &equinox,
     278                             casacore::String &freqref,
     279                             casacore::Double &reffreq,
     280                             casacore::Double &bandwidth,
     281                             casacore::Double &utc,
     282                             casacore::String &fluxunit,
     283                             casacore::String &epoch,
     284                             casacore::String &poltype )
     285{
     286  casacore::String funcName = "fillHeader" ;
    287287
    288288  ExecBlockTable &ebtab = asdm_->getExecBlock() ;
    289289  // at the moment take first row of ExecBlock table
    290290  ExecBlockRow *ebrow = ebtab.get()[0] ;
    291   casa::String telescopeName( ebrow->getTelescopeName() ) ;
    292   //casa::String stationName( stationRow_p->getName() ) ;
     291  casacore::String telescopeName( ebrow->getTelescopeName() ) ;
     292  //casacore::String stationName( stationRow_p->getName() ) ;
    293293
    294294  // antennaname
    … …  
    299299  // antennaposition
    300300  antennaposition.resize( 3 ) ;
    301   for ( casa::uInt i = 0 ; i < 3 ; i++ )
     301  for ( casacore::uInt i = 0 ; i < 3 ; i++ )
    302302    antennaposition[i] = antennaPosition_[i].getValue( Unit("m") ) ;
    303303
    … …  
    311311  // utc
    312312  // start time of the project
    313   utc = casa::Double( ebrow->getStartTime().getMJD() ) ;
     313  utc = casacore::Double( ebrow->getStartTime().getMJD() ) ;
    314314 
    315315
    … …  
    330330      refidx = irow ;
    331331  }
    332   nchan = casa::Int( *max_element( nchans.begin(), nchans.end() ) ) ;
     332  nchan = casacore::Int( *max_element( nchans.begin(), nchans.end() ) ) ;
    333333
    334334  //logsink_->postLocally( LogMessage("refidx = "+String::toString(refidx),LogOrigin(className_,funcName,WHERE)) ) ;
    … …  
    341341    }
    342342  }
    343   bandwidth = casa::Double( *max_element( bws.begin(), bws.end() ) ) ;
     343  bandwidth = casacore::Double( *max_element( bws.begin(), bws.end() ) ) ;
    344344
    345345  // reffreq
    346   reffreq = casa::Double( spwrows[refidx]->getRefFreq().get() ) ;
     346  reffreq = casacore::Double( spwrows[refidx]->getRefFreq().get() ) ;
    347347
    348348  // freqref
    … …  
    386386
    387387  // npol
    388   npol = casa::Int( *max_element( npols.begin(), npols.end() ) ) ;
     388  npol = casacore::Int( *max_element( npols.begin(), npols.end() ) ) ;
    389389
    390390  // poltype
    … …  
    425425
    426426  // nbeam
    427   nbeam = casa::Int( *max_element( nbeams.begin(), nbeams.end() ) ) ;
     427  nbeam = casacore::Int( *max_element( nbeams.begin(), nbeams.end() ) ) ;
    428428
    429429  // fluxunit
    … …  
    445445  obstype = "" ;
    446446  for ( unsigned int imode = 0 ; imode < obsmode.size() ; imode++ ) {
    447     obstype += casa::String(obsmode[imode]) ;
     447    obstype += casacore::String(obsmode[imode]) ;
    448448    if ( imode != obsmode.size()-1 )
    449449      obstype += "#" ;
    … …  
    453453void ASDMReader::selectConfigDescription()
    454454{
    455   casa::String funcName = "selectConfigDescription" ;
     455  casacore::String funcName = "selectConfigDescription" ;
    456456
    457457  vector<ConfigDescriptionRow *> cdrows = asdm_->getConfigDescription().get() ;
    … …  
    466466  configDescIdList_.resize( cdidTags.size() ) ;
    467467  for ( unsigned int i = 0 ; i < cdidTags.size() ; i++ ) {
    468     configDescIdList_[i] = casa::uInt( cdidTags[i].getTagValue() ) ;
     468    configDescIdList_[i] = casacore::uInt( cdidTags[i].getTagValue() ) ;
    469469  }
    470470}
    … …  
    476476  Tag atag( antennaId_, TagType::Antenna ) ;
    477477  for ( unsigned int irow = 0 ; irow < frows.size() ; irow++ ) {
    478     casa::uInt feedId = (casa::uInt)(frows[irow]->getFeedId() ) ;
    479     if ( casa::anyEQ( feedIdList_, feedId ) )
     478    casacore::uInt feedId = (casacore::uInt)(frows[irow]->getFeedId() ) ;
     479    if ( casacore::anyEQ( feedIdList_, feedId ) )
    480480      continue ;
    481481    if ( frows[irow]->getAntennaId() == atag ) {
    … …  
    487487}
    488488
    489 casa::Vector<casa::uInt> ASDMReader::getFieldIdList()
    490 {
    491   casa::String funcName = "getFieldIdList" ;
     489casacore::Vector<casacore::uInt> ASDMReader::getFieldIdList()
     490{
     491  casacore::String funcName = "getFieldIdList" ;
    492492
    493493  vector<FieldRow *> frows = asdm_->getField().get() ;
    … …  
    501501}
    502502
    503 casa::uInt ASDMReader::getNumMainRow()
    504 {
    505   casa::uInt nrow = casa::uInt( mainRow_.size() ) ;
     503casacore::uInt ASDMReader::getNumMainRow()
     504{
     505  casacore::uInt nrow = casacore::uInt( mainRow_.size() ) ;
    506506
    507507  return nrow ;
    … …  
    534534}
    535535
    536 casa::Bool ASDMReader::setMainRow( casa::uInt irow )
    537 {
    538   casa::Bool status = true ;
     536casacore::Bool ASDMReader::setMainRow( casacore::uInt irow )
     537{
     538  casacore::Bool status = true ;
    539539  row_ = irow ;
    540540  execBlockTag_ = mainRow_[row_]->getExecBlockId() ;
    … …  
    544544    status = false ;
    545545  else {
    546     status = (casa::Bool)(sdmBin_->acceptMainRow( mainRow_[row_] )) ;
     546    status = (casacore::Bool)(sdmBin_->acceptMainRow( mainRow_[row_] )) ;
    547547  }
    548548  return status ;
    549549}
    550550
    551 casa::Bool ASDMReader::setMainRow( casa::uInt configDescId, casa::uInt fieldId )
     551casacore::Bool ASDMReader::setMainRow( casacore::uInt configDescId, casacore::uInt fieldId )
    552552{
    553553  clearMainRow() ;
    … …  
    558558  if (rows == 0)
    559559    return false;
    560   mainRow_ = casa::Vector<MainRow *>( *rows ) ;
     560  mainRow_ = casacore::Vector<MainRow *>( *rows ) ;
    561561 
    562562  return true ;
    … …  
    570570void ASDMReader::setupIFNO()
    571571{
    572   casa::String funcName = "setupIFNO" ;
     572  casacore::String funcName = "setupIFNO" ;
    573573
    574574  vector<SpectralWindowRow *> spwrows = asdm_->getSpectralWindow().get() ;
    575575  unsigned int nrow = spwrows.size() ;
    576576  ifno_.clear() ;
    577   casa::uInt idx = 0 ;
    578   casa::uInt wvridx = 0 ;
     577  casacore::uInt idx = 0 ;
     578  casacore::uInt wvridx = 0 ;
    579579  for ( unsigned int irow = 0 ; irow < nrow ; irow++ ) {
    580     casa::uInt index ;
     580    casacore::uInt index ;
    581581    if ( isWVR( spwrows[irow] ) ) {
    582582      //logsink_->postLocally( LogMessage(spwrows[irow]->getSpectralWindowId().toString()+" is WVR",LogOrigin(className_,funcName,WHERE)) ) ;
    … …  
    586586      index = ++idx ;
    587587    }
    588     ifno_.insert( pair<Tag,casa::uInt>(spwrows[irow]->getSpectralWindowId(),index) ) ;
     588    ifno_.insert( pair<Tag,casacore::uInt>(spwrows[irow]->getSpectralWindowId(),index) ) ;
    589589    //logsink_->postLocally( LogMessage(spwrows[irow]->getSpectralWindowId().toString()+": IFNO="+String::toString(index),LogOrigin(className_,funcName,WHERE)) ) ;
    590590  }
    … …  
    601601}
    602602
    603 casa::Bool ASDMReader::setData()
    604 {
    605   casa::String funcName = "setData" ;
     603casacore::Bool ASDMReader::setData()
     604{
     605  casacore::String funcName = "setData" ;
    606606
    607607  //logsink_->postLocally( LogMessage("try to retrieve binary data",LogOrigin(className_,funcName,WHERE)) ) ;
    … …  
    678678}
    679679
    680 casa::uInt ASDMReader::getIFNo( unsigned int idx )
     680casacore::uInt ASDMReader::getIFNo( unsigned int idx )
    681681{
    682682  prepareData( idx ) ;
    … …  
    684684}
    685685
    686 casa::uInt ASDMReader::getIFNo()
    687 {
    688   map<Tag,casa::uInt>::iterator iter = ifno_.find( specWinTag_ ) ;
     686casacore::uInt ASDMReader::getIFNo()
     687{
     688  map<Tag,casacore::uInt>::iterator iter = ifno_.find( specWinTag_ ) ;
    689689  if ( iter != ifno_.end() )
    690690    return iter->second ;
    … …  
    720720                               string &freqref )
    721721{
    722   casa::String funcName = "getFrequency" ;
     722  casacore::String funcName = "getFrequency" ;
    723723
    724724  int nchan = specWinRow_p->getNumChan() ;
    … …  
    737737    }
    738738    else {
    739       throw (casa::AipsError( "Either chanFreqArray or chanFreqStart must exist." )) ;
     739      throw (casacore::AipsError( "Either chanFreqArray or chanFreqStart must exist." )) ;
    740740    }     
    741741  }
    … …  
    752752    }
    753753    else {
    754       throw (casa::AipsError( "Either chanWidthArray or chanWidth must exist." )) ;
     754      throw (casacore::AipsError( "Either chanWidthArray or chanWidth must exist." )) ;
    755755    }     
    756756    if ( specWinRow_p->isChanFreqStepExists() ) {
    … …  
    764764    }
    765765    else {
    766       throw (casa::AipsError( "Either chanFreqArray or chanFreqStep must exist." )) ;
     766      throw (casacore::AipsError( "Either chanFreqArray or chanFreqStep must exist." )) ;
    767767    }         
    768768    if ( specWinRow_p->isChanFreqStartExists() ) {
    … …  
    773773    }
    774774    else {
    775       throw (casa::AipsError( "Either chanFreqArray or chanFreqStart must exist." )) ;
     775      throw (casacore::AipsError( "Either chanFreqArray or chanFreqStart must exist." )) ;
    776776    }     
    777777  }
    … …  
    788788    }
    789789    else {
    790       throw (casa::AipsError( "Either chanWidthArray or chanWidth must exist." )) ;
     790      throw (casacore::AipsError( "Either chanWidthArray or chanWidth must exist." )) ;
    791791    }
    792792    if ( specWinRow_p->isChanFreqStepExists() ) {
    … …  
    800800    }
    801801    else {
    802       throw (casa::AipsError( "Either chanFreqArray or chanFreqStep must exist." )) ;
     802      throw (casacore::AipsError( "Either chanFreqArray or chanFreqStep must exist." )) ;
    803803    }         
    804804    if ( specWinRow_p->isChanFreqStartExists() ) {
    … …  
    810810    }
    811811    else {
    812       throw (casa::AipsError( "Either chanFreqArray or chanFreqStart must exist." )) ;
     812      throw (casacore::AipsError( "Either chanFreqArray or chanFreqStart must exist." )) ;
    813813    }     
    814814  }
    … …  
    12641264    for ( unsigned int irow = 0 ; irow < nrow ; irow++ ) {
    12651265      CalAtmosphereRow *atmrow = atmrows[irow] ;
    1266       if ( casa::String(atmrow->getAntennaName()) != antennaName_
     1266      if ( casacore::String(atmrow->getAntennaName()) != antennaName_
    12671267           //|| atmrow->getReceiverBand() != rb
    12681268           //|| atmrow->getBasebandName() != bbname
    … …  
    13101310                                 float &windaz )
    13111311{
    1312   casa::String funcName = "getWeatherInfo" ;
     1312  casacore::String funcName = "getWeatherInfo" ;
    13131313
    13141314  temperature = 0.0 ;
    … …  
    17101710
    17111711vector<double> ASDMReader::toJ2000( vector<double> &dir,
    1712                                     casa::String &dirref,
     1712                                    casacore::String &dirref,
    17131713                                    double &mjd )
    17141714{
    1715   casa::String funcName = "toJ2000" ;
     1715  casacore::String funcName = "toJ2000" ;
    17161716
    17171717  vector<double> newd( dir ) ;
    17181718  if ( dirref != "J2000" ) {
    1719     me_ = casa::MEpoch( casa::Quantity( (casa::Double)mjd, "d" ), casa::MEpoch::UTC ) ;
     1719    me_ = casacore::MEpoch( casacore::Quantity( (casacore::Double)mjd, "d" ), casacore::MEpoch::UTC ) ;
    17201720    mf_.set( me_ ) ;
    1721     casa::MDirection::Types dirtype ;
    1722     casa::Bool b = casa::MDirection::getType( dirtype, dirref ) ;
     1721    casacore::MDirection::Types dirtype ;
     1722    casacore::Bool b = casacore::MDirection::getType( dirtype, dirref ) ;
    17231723    if ( b ) {
    1724       casa::Vector<casa::Double> cdir = toj2000_( dir ).getAngle( "rad" ).getValue() ;
     1724      casacore::Vector<casacore::Double> cdir = toj2000_( dir ).getAngle( "rad" ).getValue() ;
    17251725      //logsink_->postLocally( LogMessage("cdir = "+String::toString(cdir),LogOrigin(className_,funcName,WHERE)) ) ;
    17261726      newd[0] = (double)(cdir[0]) ;
    … …  
    17381738string ASDMReader::getFrame()
    17391739{
    1740   casa::String funcName = "getFrame" ;
     1740  casacore::String funcName = "getFrame" ;
    17411741 
    17421742  // default is TOPO
    … …  
    17671767int ASDMReader::getNumIFs()
    17681768{
    1769   casa::String funcName = "getNumIFs" ;
     1769  casacore::String funcName = "getNumIFs" ;
    17701770
    17711771  int nif = 0 ;

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

    r2979 r3106  
    3838   * @return boolean status (true or false)
    3939   **/
    40   bool open( const std::string &filename, const casa::Record &rec ) ;
     40  bool open( const std::string &filename, const casacore::Record &rec ) ;
    4141
    4242  /**
    … …  
    5353   * get antenna id
    5454   **/
    55   casa::Int getAntennaId() { return antennaId_ ; } ;
     55  casacore::Int getAntennaId() { return antennaId_ ; } ;
    5656
    5757  /**
    5858   * get antenna name
    5959   **/
    60   casa::String getAntennaName() { return antennaName_ ; } ;
     60  casacore::String getAntennaName() { return antennaName_ ; } ;
    6161
    6262  /**
    … …  
    8181   * @param poltype polarization type
    8282   **/
    83   void fillHeader( casa::Int &nchan,
    84                    casa::Int &npol,
    85                    casa::Int &nif,
    86                    casa::Int &nbeam,
    87                    casa::String &observer,
    88                    casa::String &project,
    89                    casa::String &obstype,
    90                    casa::String &antennaname,
    91                    casa::Vector<casa::Double> &antennaposition,
    92                    casa::Float &equinox,
    93                    casa::String &freqref,
    94                    casa::Double &reffreq,
    95                    casa::Double &bandwidth,
    96                    casa::Double &utc,
    97                    casa::String &fluxunit,
    98                    casa::String &epoch,
    99                    casa::String &poltype ) ; 
     83  void fillHeader( casacore::Int &nchan,
     84                   casacore::Int &npol,
     85                   casacore::Int &nif,
     86                   casacore::Int &nbeam,
     87                   casacore::String &observer,
     88                   casacore::String &project,
     89                   casacore::String &obstype,
     90                   casacore::String &antennaname,
     91                   casacore::Vector<casacore::Double> &antennaposition,
     92                   casacore::Float &equinox,
     93                   casacore::String &freqref,
     94                   casacore::Double &reffreq,
     95                   casacore::Double &bandwidth,
     96                   casacore::Double &utc,
     97                   casacore::String &fluxunit,
     98                   casacore::String &epoch,
     99                   casacore::String &poltype ) ; 
    100100
    101101  /**
    … …  
    107107   * @return list of valid configDescriptionId
    108108   **/
    109   casa::Vector<casa::uInt> getConfigDescriptionIdList() { return configDescIdList_ ; } ;
     109  casacore::Vector<casacore::uInt> getConfigDescriptionIdList() { return configDescIdList_ ; } ;
    110110
    111111  /**
    112112   * get list of fieldId
    113113   *
    114    * @return list of fieldId as casa::uInt
    115    **/
    116   casa::Vector<casa::uInt> getFieldIdList() ;
     114   * @return list of fieldId as casacore::uInt
     115   **/
     116  casacore::Vector<casacore::uInt> getFieldIdList() ;
    117117
    118118  /**
    … …  
    121121   * @return number of rows in Main table
    122122   **/
    123   casa::uInt getNumMainRow() ;
     123  casacore::uInt getNumMainRow() ;
    124124
    125125  /**
    … …  
    135135   * @param fieldId
    136136   **/
    137   casa::Bool setMainRow( casa::uInt configDescId, casa::uInt fieldId ) ;
     137  casacore::Bool setMainRow( casacore::uInt configDescId, casacore::uInt fieldId ) ;
    138138
    139139  /**
    … …  
    143143   * @return boolean indicating the row is valid or not
    144144   **/
    145   casa::Bool setMainRow( casa::uInt irow ) ;
     145  casacore::Bool setMainRow( casacore::uInt irow ) ;
    146146
    147147  /**
    … …  
    181181   * @return IF number
    182182   **/
    183   casa::uInt getIFNo( unsigned int idx ) ;
    184   casa::uInt getIFNo() ;
     183  casacore::uInt getIFNo( unsigned int idx ) ;
     184  casacore::uInt getIFNo() ;
    185185
    186186  /**
    … …  
    387387   * @return boolean status
    388388   **/
    389   casa::Bool setData() ;
     389  casacore::Bool setData() ;
    390390
    391391  /**
    … …  
    408408   * @param logger (LogSinkInterface)
    409409   **/
    410   void setLogger( casa::CountedPtr<casa::LogSinkInterface> &logsink ) ;
     410  void setLogger( casacore::CountedPtr<casacore::LogSinkInterface> &logsink ) ;
    411411
    412412
    … …  
    507507  **/
    508508  std::vector<double> toJ2000( std::vector<double> &dir,
    509                                casa::String &dirref,
     509                               casacore::String &dirref,
    510510                               double &mjd ) ;
    511511
    … …  
    579579  const sdmbin::VMSData *vmsData_ ;
    580580 
    581   casa::Int antennaId_ ; // antenna id
    582   casa::String antennaName_ ; // antenna name
    583   casa::String stationName_ ; // station name
    584   casa::Vector<casa::Quantity> antennaPosition_ ; // antenna position
    585   casa::Vector<casa::uInt> configDescIdList_ ; // list of valid configDescriptionId
    586   casa::Vector<casa::uInt> feedIdList_ ; // list of valid feedId
    587   casa::Vector<casa::uInt> fieldIdList_ ; // list of fieldId
    588   casa::Int row_ ; // current row index
    589   map<asdm::Tag,casa::uInt> ifno_ ; // list of IFNO for each SpectralWindow rows
     581  casacore::Int antennaId_ ; // antenna id
     582  casacore::String antennaName_ ; // antenna name
     583  casacore::String stationName_ ; // station name
     584  casacore::Vector<casacore::Quantity> antennaPosition_ ; // antenna position
     585  casacore::Vector<casacore::uInt> configDescIdList_ ; // list of valid configDescriptionId
     586  casacore::Vector<casacore::uInt> feedIdList_ ; // list of valid feedId
     587  casacore::Vector<casacore::uInt> fieldIdList_ ; // list of fieldId
     588  casacore::Int row_ ; // current row index
     589  map<asdm::Tag,casacore::uInt> ifno_ ; // list of IFNO for each SpectralWindow rows
    590590  unsigned int numData_ ; // number of valid data in vmsData_ where v_antennaId equals antennaId_
    591591  vector<unsigned int> dataIdList_ ; // list of valid data indexes in vmsData_ 
    … …  
    597597  EnumSet<TimeSamplingMod::TimeSampling> timeSampling_ ; // time sampling
    598598  EnumSet<SpectralResolutionTypeMod::SpectralResolutionType> resolutionType_ ; // spectral resolution type
    599   casa::CountedPtr<casa::LogSinkInterface> logsink_ ; // Logger
    600   casa::String className_ ;
     599  casacore::CountedPtr<casacore::LogSinkInterface> logsink_ ; // Logger
     600  casacore::String className_ ;
    601601  unsigned int dataIndex_ ;
    602602
    603603  // Tables/Rows for ASDM
    604   casa::Vector<asdm::MainRow *> mainRow_ ; // list of pointers to all Main rows
     604  casacore::Vector<asdm::MainRow *> mainRow_ ; // list of pointers to all Main rows
    605605  //asdm::AntennaRow *antennaRow_p ; // pointer to target Antenna row
    606606  //asdm::StationRow *stationRow_p ; // pointer to target Station row that target antenna is located
    … …  
    617617  asdm::ArrayTimeInterval timeInterval_ ;
    618618
    619   casa::MDirection::Convert toj2000_ ;
    620   casa::MeasFrame mf_ ;
    621   casa::MPosition mp_ ;
    622   casa::MEpoch me_ ;
     619  casacore::MDirection::Convert toj2000_ ;
     620  casacore::MeasFrame mf_ ;
     621  casacore::MPosition mp_ ;
     622  casacore::MEpoch me_ ;
    623623} ;
    624624#endif // ASAP_ASDM_READER_H
Note: See TracChangeset for help on using the changeset viewer.