Changeset 3106 for trunk/external-alma/oldasdm2ASAP

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/oldasdm2ASAP

Files:

• OldASDMFiller.cc (modified) (26 diffs)
• OldASDMFiller.h (modified) (5 diffs)
• OldASDMReader.cc (modified) (43 diffs)
• OldASDMReader.h (modified) (14 diffs)

trunk/external-alma/oldasdm2ASAP/OldASDMFiller.cc

@@ -74 +74 @@
   //logsink_->postLocally( LogMessage("sFreqFrame = "+sFreqFrame,LogOrigin(className_,funcName,WHERE)) ) ;
   
-  Vector<casa::Double> antpos = table_->getHeader().antennaposition ;
+  Vector<casacore::Double> antpos = table_->getHeader().antennaposition ;
 
   // data selection
@@ -172 +172 @@
           
           // fill MOLECULE_ID and add MOLECULES row if necessary
-          Vector<casa::Double> restFreqs( rf.size() ) ;
+          Vector<casacore::Double> restFreqs( rf.size() ) ;
           for ( uInt i = 0 ; i < rf.size() ; i++ )
-            restFreqs[i] = (casa::Double)(rf[i]) ;
+            restFreqs[i] = (casacore::Double)(rf[i]) ;
           setMolecule( restFreqs ) ;
           
           // time and interval
-          casa::Double mjd = (casa::Double)(reader_->getTime()) ;
-          casa::Double interval = (casa::Double)(reader_->getInterval()) ;
+          casacore::Double mjd = (casacore::Double)(reader_->getTime()) ;
+          casacore::Double interval = (casacore::Double)(reader_->getInterval()) ;
 
           // fill TIME and INTERVAL
@@ -185 +185 @@
           
           // fill SRCNAME, SRCTYPE, FIELDNAME, SRCDIRECTION, SRCPROPERMOTION, and SRCVELOCITY
-          Vector<casa::Double> srcDir( 2 ) ;
-          srcDir[0] = (casa::Double)(srcDirection[0]) ;
-          srcDir[1] = (casa::Double)(srcDirection[1]) ;
-          Vector<casa::Double> srcPM( 2 ) ;
-          srcPM[0] = (casa::Double)(srcProperMotion[0]) ;
-          srcPM[1] = (casa::Double)(srcProperMotion[1]) ;
-          setSource( srcname, srctype, fieldname, srcDir, srcPM, (casa::Double)sysVel ) ;
+          Vector<casacore::Double> srcDir( 2 ) ;
+          srcDir[0] = (casacore::Double)(srcDirection[0]) ;
+          srcDir[1] = (casacore::Double)(srcDirection[1]) ;
+          Vector<casacore::Double> srcPM( 2 ) ;
+          srcPM[0] = (casacore::Double)(srcProperMotion[0]) ;
+          srcPM[1] = (casacore::Double)(srcProperMotion[1]) ;
+          setSource( srcname, srctype, fieldname, srcDir, srcPM, (casacore::Double)sysVel ) ;
 
           // fill FLAGROW
@@ -208 +208 @@
                                    windspeed,
                                    windaz ) ;
-          setWeather2( (casa::Float)temperature,
-                       (casa::Float)pressure,
-                       (casa::Float)humidity,
-                       (casa::Float)windspeed,
-                       (casa::Float)windaz ) ;
+          setWeather2( (casacore::Float)temperature,
+                       (casacore::Float)pressure,
+                       (casacore::Float)humidity,
+                       (casacore::Float)windspeed,
+                       (casacore::Float)windaz ) ;
 
           // fill AZIMUTH, ELEVATION, DIRECTION and SCANRATE
@@ -223 +223 @@
                                     el,
                                     srate ) ;
-          Vector<casa::Double> scanRate( 2, 0.0 ) ;
-          Vector<casa::Double> direction( 2, 0.0 ) ;
+          Vector<casacore::Double> scanRate( 2, 0.0 ) ;
+          Vector<casacore::Double> direction( 2, 0.0 ) ;
           if ( srate.size() > 0 ) {
-            scanRate[0] = (casa::Double)(srate[0]) ;
-            scanRate[1] = (casa::Double)(srate[1]) ;
+            scanRate[0] = (casacore::Double)(srate[0]) ;
+            scanRate[1] = (casacore::Double)(srate[1]) ;
           }
           setScanRate( scanRate ) ;
           if ( dir.size() > 0 ) {
-            direction[0] = (casa::Double)(dir[0]) ;
-            direction[1] = (casa::Double)(dir[1]) ;
+            direction[0] = (casacore::Double)(dir[0]) ;
+            direction[1] = (casacore::Double)(dir[1]) ;
           }
           else {
@@ -238 +238 @@
           }
           //logsink_->postLocally( LogMessage("direction = "+String::toString(direction),LogOrigin(className_,funcName,WHERE)) ) ;
-          setDirection( direction, (casa::Float)az, (casa::Float)el ) ;
+          setDirection( direction, (casacore::Float)az, (casacore::Float)el ) ;
 
            // REFPIX, REFVAL, INCREMENT
@@ -247 +247 @@
           else {
             reader_->getFrequency( refpix, refval, incr, freqref ) ;
-            refval = (double)toLSRK( casa::Double(refval), 
+            refval = (double)toLSRK( casacore::Double(refval), 
                                      String(freqref),
                                      mjd,
@@ -258 +258 @@
 
           // fill FREQ_ID and add FREQUENCIES row if necessary
-          setFrequency( (casa::Double)refpix, (casa::Double)refval, (casa::Double)incr ) ;
+          setFrequency( (casacore::Double)refpix, (casacore::Double)refval, (casacore::Double)incr ) ;
 
           // loop on polarization
@@ -280 +280 @@
           // OPACITY
           vector<float> tau = reader_->getOpacity() ;
-          Vector<casa::Float> opacity = toVector( tau, numPol ) ;
+          Vector<casacore::Float> opacity = toVector( tau, numPol ) ;
 
           // SPECTRA, FLAGTRA, TSYS, TCAL
@@ -287 +287 @@
           vector< vector<float> > tc ;
           reader_->getTcalAndTsys( tc, ts ) ;
-          Matrix<casa::Float> spectra = toMatrix( sp, numPol, numChan ) ;
+          Matrix<casacore::Float> spectra = toMatrix( sp, numPol, numChan ) ;
           Vector<uChar> flagtra( numChan, 0 ) ;
-          Matrix<casa::Float> tsys = toMatrix( ts, numPol, numChan ) ;
-          Matrix<casa::Float> tcal = toMatrix( tc, numPol, numChan ) ;
+          Matrix<casacore::Float> tsys = toMatrix( ts, numPol, numChan ) ;
+          Matrix<casacore::Float> tcal = toMatrix( tc, numPol, numChan ) ;
 //           String caltime = "" ;
-//           if ( anyNE( tcal, (casa::Float)1.0 ) ) 
+//           if ( anyNE( tcal, (casacore::Float)1.0 ) ) 
 //             caltime = toTcalTime( mjd ) ;
           String caltime = toTcalTime( mjd ) ;
@@ -374 +374 @@
     string ref ;
     reader_->getSourceDirection( sdir, ref ) ;
-    Vector<casa::Double> sourceDir( sdir ) ; 
+    Vector<casacore::Double> sourceDir( sdir ) ; 
     hdr.reffreq = toLSRK( hdr.reffreq, hdr.freqref, hdr.utc, hdr.antennaposition, sdir, String(ref) ) ;
     hdr.freqref = "LSRK" ;
@@ -410 +410 @@
 }
 
-Matrix<casa::Float> OldASDMFiller::toMatrix( float *sp,
+Matrix<casacore::Float> OldASDMFiller::toMatrix( float *sp,
                                          unsigned int npol,
                                          unsigned int nchan )
 {
-  Matrix<casa::Float> mSp( npol, nchan ) ;
+  Matrix<casacore::Float> mSp( npol, nchan ) ;
   if ( npol <= 2 ) {
     // 1 or 2 polarization case
     for ( unsigned int ich = 0 ; ich < nchan ; ich++ ) {
       for ( unsigned int ipol = 0 ; ipol < npol ; ipol++ ) {
-        mSp(ipol,ich) = (casa::Float)(sp[npol*ich+ipol]) ;
+        mSp(ipol,ich) = (casacore::Float)(sp[npol*ich+ipol]) ;
       }
     }
@@ -426 +426 @@
     // 4 polarization case
     for ( unsigned int ich = 0 ; ich < nchan ; ich++ ) {
-      mSp(0,ich) = (casa::Float)(sp[4*ich]) ;   // Re(XX)
-      mSp(1,ich) = (casa::Float)(sp[4*ich+4]) ; // Re(YY)
-      mSp(2,ich) = (casa::Float)(sp[4*ich+2]) ; // Re(XY)
-      mSp(3,ich) = (casa::Float)(sp[4*ich+3]) ; // Im(XY)
+      mSp(0,ich) = (casacore::Float)(sp[4*ich]) ;   // Re(XX)
+      mSp(1,ich) = (casacore::Float)(sp[4*ich+4]) ; // Re(YY)
+      mSp(2,ich) = (casacore::Float)(sp[4*ich+2]) ; // Re(XY)
+      mSp(3,ich) = (casacore::Float)(sp[4*ich+3]) ; // Im(XY)
     }
   }
@@ -435 +435 @@
 }
 
-Matrix<casa::Float> OldASDMFiller::toMatrix( vector< vector<float> > &tsys,
+Matrix<casacore::Float> OldASDMFiller::toMatrix( vector< vector<float> > &tsys,
                                                unsigned int npol,
                                                unsigned int nchan ) 
@@ -441 +441 @@
   unsigned int numRec = tsys.size() ;
   unsigned int numChan = tsys[0].size() ;
-  Matrix<casa::Float> ret ;
+  Matrix<casacore::Float> ret ;
   if ( npol == numRec && nchan == numChan ) {
     ret.resize( npol, nchan ) ; 
     for ( unsigned int ip = 0 ; ip < npol ; ip++ ) 
       for ( unsigned int ic = 0 ; ic < nchan ; ic++ ) 
-        ret( ip, ic ) = (casa::Float)(tsys[ip][ic]) ;
+        ret( ip, ic ) = (casacore::Float)(tsys[ip][ic]) ;
   }
   else if ( npol == numRec && numChan == 1 ) {
     ret.resize( npol, 1 ) ;
     for ( unsigned int ip = 0 ; ip < npol ; ip++ )
-      ret( ip, 0 ) = (casa::Float)(tsys[0][0]) ;
+      ret( ip, 0 ) = (casacore::Float)(tsys[0][0]) ;
   }
   else if ( numRec == 1 && nchan == numChan ) {
@@ -457 +457 @@
     for ( unsigned int ip = 0 ; ip < npol ; ip++ ) 
       for ( unsigned int ic = 0 ; ic < nchan ; ic++ ) 
-        ret( ip, ic ) = (casa::Float)(tsys[0][ic]) ;
+        ret( ip, ic ) = (casacore::Float)(tsys[0][ic]) ;
   }
   else if ( numRec == 1 && numChan == 1 ) {
     ret.resize( npol, 1 ) ;
     for ( unsigned int ip = 0 ; ip < npol ; ip++ )
-      ret( ip, 0 ) = (casa::Float)(tsys[0][0]) ;
+      ret( ip, 0 ) = (casacore::Float)(tsys[0][0]) ;
   }
   else if ( numRec == 2 && npol == 4 && numChan == nchan ) {
@@ -469 +469 @@
     ret.resize( npol, nchan ) ; 
     for ( unsigned int ic = 0 ; ic < nchan ; ic++ ) {
-      casa::Float tsysxy = (casa::Float)(0.5*(tsys[0][ic]+tsys[1][ic])) ;
-      ret( 0, ic ) = (casa::Float)(tsys[0][ic]) ;
-      ret( 1, ic ) = (casa::Float)(tsys[1][ic]) ;
+      casacore::Float tsysxy = (casacore::Float)(0.5*(tsys[0][ic]+tsys[1][ic])) ;
+      ret( 0, ic ) = (casacore::Float)(tsys[0][ic]) ;
+      ret( 1, ic ) = (casacore::Float)(tsys[1][ic]) ;
       ret( 2, ic ) = tsysxy ;
       ret( 3, ic ) = tsysxy ;
@@ -480 +480 @@
     //       at the moment Tsys[XY] = 0.5*(Tsys[X]+Tsys[Y])
     ret.resize( npol, 1 ) ;
-    casa::Float tsysxy = (casa::Float)(0.5*(tsys[0][0]+tsys[1][0])) ;
-    ret( 0, 0 ) = (casa::Float)(tsys[0][0]) ;
-    ret( 1, 0 ) = (casa::Float)(tsys[1][0]) ;
+    casacore::Float tsysxy = (casacore::Float)(0.5*(tsys[0][0]+tsys[1][0])) ;
+    ret( 0, 0 ) = (casacore::Float)(tsys[0][0]) ;
+    ret( 1, 0 ) = (casacore::Float)(tsys[1][0]) ;
     ret( 2, 0 ) = tsysxy ;
     ret( 3, 0 ) = tsysxy ;
@@ -490 +490 @@
     for ( unsigned int ip = 0 ; ip < npol ; ip++ ) 
       for ( unsigned int ic = 0 ; ic < nchan ; ic++ ) 
-        ret( ip, ic ) = (casa::Float)(tsys[0][ic]) ;    
+        ret( ip, ic ) = (casacore::Float)(tsys[0][ic]) ;    
   }
   return ret ;
 }
 
-Vector<casa::Float> OldASDMFiller::toVector( vector<float> &tau,
+Vector<casacore::Float> OldASDMFiller::toVector( vector<float> &tau,
                                                unsigned int npol ) 
 {
   String funcName = "toVector" ;
 
-  Vector<casa::Float> ret( npol ) ;
+  Vector<casacore::Float> ret( npol ) ;
   //logsink_->postLocally( LogMessage("tau0="+String::toString(tau[0]),LogOrigin(className_,funcName,WHERE)) ) ;
   if ( npol == 4 ) {
-    ret[0] = (casa::Float)tau[0] ;
-    ret[1] = (casa::Float)tau[1] ;
+    ret[0] = (casacore::Float)tau[0] ;
+    ret[1] = (casacore::Float)tau[1] ;
     ret[2] = 0.5 * ( ret[0] + ret[1] ) ;
     ret[3] = ret[2] ;
@@ -510 +510 @@
   else if ( npol == tau.size() ) {
     for ( unsigned int ipol = 0 ; ipol < npol ; ipol++ ) 
-      ret[ipol] = (casa::Float)tau[ipol] ;
+      ret[ipol] = (casacore::Float)tau[ipol] ;
   }
   else {
     // I don't know how to handle...
     for ( unsigned int ipol = 0 ; ipol < npol ; ipol++ )
-      ret[ipol] = (casa::Float)tau[0] ;
+      ret[ipol] = (casacore::Float)tau[0] ;
   }
   //logsink_->postLocally( LogMessage("tau="+String::toString(ret),LogOrigin(className_,funcName,WHERE)) ) ;
@@ -521 +521 @@
 }
 
-String OldASDMFiller::toTcalTime( casa::Double mjd ) 
+String OldASDMFiller::toTcalTime( casacore::Double mjd ) 
 {
   return MVTime( mjd ).string( MVTime::YMD ) ;
 }
 
-void OldASDMFiller::toJ2000( Vector<casa::Double> &dir,
+void OldASDMFiller::toJ2000( Vector<casacore::Double> &dir,
                                double az, 
                                double el,
-                               casa::Double mjd,
-                               Vector<casa::Double> antpos ) 
+                               casacore::Double mjd,
+                               Vector<casacore::Double> antpos ) 
 {
   String funcName = "toJ2000" ;
 
-  Vector<casa::Double> azel( 2 ) ;
+  Vector<casacore::Double> azel( 2 ) ;
   azel[0] = az ;
   azel[1] = el ;
@@ -553 +553 @@
 }
 
-Vector<casa::Double> OldASDMFiller::toJ2000( Vector<casa::Double> dir,
+Vector<casacore::Double> OldASDMFiller::toJ2000( Vector<casacore::Double> dir,
                                           String dirref,
-                                          casa::Double mjd,
-                                          Vector<casa::Double> antpos ) 
-{
-  Vector<casa::Double> newd( dir ) ;
+                                          casacore::Double mjd,
+                                          Vector<casacore::Double> antpos ) 
+{
+  Vector<casacore::Double> newd( dir ) ;
   if ( dirref != "J2000" ) {
     MEpoch me( Quantity( mjd, "d" ), MEpoch::UTC ) ;
@@ -593 +593 @@
 }
 
-casa::Double OldASDMFiller::toLSRK( casa::Double freq,
+casacore::Double OldASDMFiller::toLSRK( casacore::Double freq,
                                  String freqref,
-                                 casa::Double utc,
-                                 Vector<casa::Double> antpos,
-                                 Vector<casa::Double> dir,
+                                 casacore::Double utc,
+                                 Vector<casacore::Double> antpos,
+                                 Vector<casacore::Double> dir,
                                  String dirref ) 
 {
@@ -603 +603 @@
 
   //logsink_->postLocally( LogMessage("freqref = "+freqref,LogOrigin(className_,funcName,WHERE)) ) ;
-  casa::Double newf = freq ;
+  casacore::Double newf = freq ;
   if ( freqref != "LSRK" ) {
-    MEpoch me( Quantum<casa::Double>( utc, Unit("d") ), MEpoch::UTC ) ;
-    Vector< Quantum<casa::Double> > antposQ( 3 ) ;
+    MEpoch me( Quantum<casacore::Double>( utc, Unit("d") ), MEpoch::UTC ) ;
+    Vector< Quantum<casacore::Double> > antposQ( 3 ) ;
     for ( int i = 0 ; i < 3 ; i++ ) 
-      antposQ[i] = Quantum<casa::Double>( antpos[i], Unit("m") ) ;
+      antposQ[i] = Quantum<casacore::Double>( antpos[i], Unit("m") ) ;
     MPosition mp( antposQ, MPosition::ITRF ) ;
     MDirection::Types dirtype ;
@@ -614 +614 @@
     if ( !b )
       dirtype = MDirection::J2000 ;
-    MDirection md( Quantum<casa::Double>( dir[0], Unit("rad") ), 
-                   Quantum<casa::Double>( dir[1], Unit("rad") ),
+    MDirection md( Quantum<casacore::Double>( dir[0], Unit("rad") ), 
+                   Quantum<casacore::Double>( dir[1], Unit("rad") ),
                    dirtype ) ;
     MeasFrame mf( me, mp, md ) ;
@@ -624 +624 @@
     MFrequency::Convert tolsr( freqtype, 
                                MFrequency::Ref( MFrequency::LSRK, mf ) ) ;
-    newf = tolsr( Quantum<casa::Double>( freq, Unit("Hz") ) ).get( "Hz" ).getValue() ;
+    newf = tolsr( Quantum<casacore::Double>( freq, Unit("Hz") ) ).get( "Hz" ).getValue() ;
     //logsink_->postLocally( LogMessage("freq = "+String::toString(freq)+", newf = "+String::toString(newf),LogOrigin(className_,funcName,WHERE)) ) ;
   }

trunk/external-alma/oldasdm2ASAP/OldASDMFiller.h

@@ -13 +13 @@
 public:
   // constructor and destructor
-  OldASDMFiller( casa::CountedPtr<asap::Scantable> stable ) ;
+  OldASDMFiller( casacore::CountedPtr<asap::Scantable> stable ) ;
   ~OldASDMFiller() ;
 
   // open data
-  bool open( const std::string &filename, const casa::Record &rec ) ;
+  bool open( const std::string &filename, const casacore::Record &rec ) ;
 
   // fill data
@@ -26 +26 @@
   
   // get reader object
-  casa::CountedPtr<OldASDMReader> getReader() { return reader_ ; } ;
+  casacore::CountedPtr<OldASDMReader> getReader() { return reader_ ; } ;
 
   // set logger
-  void setLogger( casa::CountedPtr<casa::LogSinkInterface> &logsink ) ;
+  void setLogger( casacore::CountedPtr<casacore::LogSinkInterface> &logsink ) ;
 
 private:
@@ -36 +36 @@
 
   // get IF key
-  casa::String getIFKey( casa::uInt ifno ) ;
+  casacore::String getIFKey( casacore::uInt ifno ) ;
 
   // get FREQUENCIES attributes from ifrec_
-  void getFrequencyRec( casa::String key,
+  void getFrequencyRec( casacore::String key,
                         double &refpix, 
                         double &refval, 
@@ -45 +45 @@
 
   // set FREQUENCIES attributes to ifrec_
-  void setFrequencyRec( casa::String key,
+  void setFrequencyRec( casacore::String key,
                         double refpix, 
                         double refval, 
@@ -51 +51 @@
                      
   // reshape float array spectra to Matrix<Float>
-  casa::Matrix<casa::Float> toMatrix( float *sp, 
+  casacore::Matrix<casacore::Float> toMatrix( float *sp, 
                                       unsigned int npol,
                                       unsigned int nchan ) ;
 
   // reshape 2d vector Tsys to Matrix<Float>
-  casa::Matrix<casa::Float> toMatrix( std::vector< std::vector<float> > &tsys,
+  casacore::Matrix<casacore::Float> toMatrix( std::vector< std::vector<float> > &tsys,
                                       unsigned int npol,
                                       unsigned int nchan ) ;
 
   // reshape vector<float> to Vector<Float> with appropriate length
-  casa::Vector<casa::Float> toVector( std::vector<float> &tau,
+  casacore::Vector<casacore::Float> toVector( std::vector<float> &tau,
                                       unsigned int npol ) ;
 
   // create TCAL time string from MJD
-  casa::String toTcalTime( casa::Double mjd ) ;
+  casacore::String toTcalTime( casacore::Double mjd ) ;
 
   // AZEL to J2000
-  void toJ2000( casa::Vector<casa::Double> &dir,
+  void toJ2000( casacore::Vector<casacore::Double> &dir,
                 double az, 
                 double el,
-                casa::Double mjd,
-                casa::Vector<casa::Double> antpos ) ;
+                casacore::Double mjd,
+                casacore::Vector<casacore::Double> antpos ) ;
 
   // to J2000
-  casa::Vector<casa::Double> toJ2000( casa::Vector<casa::Double> dir,
-                                      casa::String dirref,
-                                      casa::Double mjd,
-                                      casa::Vector<casa::Double> antpos ) ;
+  casacore::Vector<casacore::Double> toJ2000( casacore::Vector<casacore::Double> dir,
+                                      casacore::String dirref,
+                                      casacore::Double mjd,
+                                      casacore::Vector<casacore::Double> antpos ) ;
 
   // get frequency frame enum value from string
-  casa::MFrequency::Types toFrameType( std::string &s ) ;
+  casacore::MFrequency::Types toFrameType( std::string &s ) ;
 
   // to LSRK 
   // utc must be UTC time in "d" (day)
   // antpos must be ITRF value in "m"
-  casa::Double toLSRK( casa::Double freq,
-                       casa::String freqref,
-                       casa::Double utc,
-                       casa::Vector<casa::Double> antpos,
-                       casa::Vector<casa::Double> dir,
-                       casa::String dirref ) ;
+  casacore::Double toLSRK( casacore::Double freq,
+                       casacore::String freqref,
+                       casacore::Double utc,
+                       casacore::Vector<casacore::Double> antpos,
+                       casacore::Vector<casacore::Double> dir,
+                       casacore::String dirref ) ;
 
-  casa::CountedPtr<OldASDMReader> reader_ ;
-  casa::Int antennaId_ ;
-  casa::String antennaName_ ;
+  casacore::CountedPtr<OldASDMReader> reader_ ;
+  casacore::Int antennaId_ ;
+  casacore::String antennaName_ ;
 
-  casa::Record ifrec_ ;
+  casacore::Record ifrec_ ;
 
-  casa::CountedPtr<casa::LogSinkInterface> logsink_ ;
+  casacore::CountedPtr<casacore::LogSinkInterface> logsink_ ;
 
-  casa::String className_ ;
+  casacore::String className_ ;
 
 } ;

trunk/external-alma/oldasdm2ASAP/OldASDMReader.cc

@@ -56 +56 @@
 }
 
-bool OldASDMReader::open( const string &filename, const casa::Record &rec )
-{
-  casa::String funcName = "open" ;
+bool OldASDMReader::open( const string &filename, const casacore::Record &rec )
+{
+  casacore::String funcName = "open" ;
 
   // return value
@@ -71 +71 @@
   // parsing ASDM options
   if ( rec.isDefined( "asdm" ) ) {
-    casa::Record asdmrec = rec.asRecord( "asdm" ) ;
+    casacore::Record asdmrec = rec.asRecord( "asdm" ) ;
 
     // antenna
     if ( asdmrec.isDefined( "antenna" ) ) {
-      if ( asdmrec.type( asdmrec.fieldNumber( "antenna" ) ) == casa::TpInt ) {
+      if ( asdmrec.type( asdmrec.fieldNumber( "antenna" ) ) == casacore::TpInt ) {
         antennaId_ = asdmrec.asInt( "antenna" ) ;
       }
@@ -182 +182 @@
     vector<AntennaRow *> rows = atab.get() ;
     int idx = -1 ;
-    for ( casa::uInt irow = 0 ; irow < rows.size() ; irow++ ) {
-      if ( casa::String(rows[irow]->getName()) == antennaName_ ) {
+    for ( casacore::uInt irow = 0 ; irow < rows.size() ; irow++ ) {
+      if ( casacore::String(rows[irow]->getName()) == antennaName_ ) {
         idx = rows[irow]->getAntennaId().getTagValue() ;
         break ;
@@ -190 +190 @@
     if ( idx == -1 ) {
       close() ;
-      throw (casa::AipsError( antennaName_ + " not found." )) ;
+      throw (casacore::AipsError( antennaName_ + " not found." )) ;
     }
     else {
@@ -203 +203 @@
     if ( antennaRow == 0 ) {
       close() ;
-      throw (casa::AipsError( "AntennaId " + casa::String::toString(antennaId_) + " is invalid." ) ) ;
+      throw (casacore::AipsError( "AntennaId " + casacore::String::toString(antennaId_) + " is invalid." ) ) ;
     }
   }
@@ -210 +210 @@
   // set antenna name
   if ( antennaName_.size() == 0 ) {
-    antennaName_ = casa::String( antennaRow->getName() ) ;
+    antennaName_ = casacore::String( antennaRow->getName() ) ;
   }
 
@@ -217 +217 @@
 
   // station name
-  stationName_ = casa::String( stationRow->getName() ) ;
+  stationName_ = casacore::String( stationRow->getName() ) ;
 
   // antenna position
   antennaPosition_.resize( 3 ) ;
   vector<Length> antpos = stationRow->getPosition() ;
-  for ( casa::uInt i = 0 ; i < 3 ; i++ ) 
-    antennaPosition_[i] = Quantity( casa::Double( antpos[i].get() ), Unit( "m" ) ) ;
+  for ( casacore::uInt i = 0 ; i < 3 ; i++ ) 
+    antennaPosition_[i] = Quantity( casacore::Double( antpos[i].get() ), Unit( "m" ) ) ;
 
   // create SDMBinData object
@@ -229 +229 @@
 
   // get Main rows
-  //mainRow_ = casa::Vector<MainRow *>(asdm_->getMain().get()) ;
+  //mainRow_ = casacore::Vector<MainRow *>(asdm_->getMain().get()) ;
 
   // set up IFNO
@@ -262 +262 @@
 }
 
-void OldASDMReader::fillHeader( casa::Int &nchan, 
-                             casa::Int &npol, 
-                             casa::Int &nif, 
-                             casa::Int &nbeam, 
-                             casa::String &observer, 
-                             casa::String &project, 
-                             casa::String &obstype, 
-                             casa::String &antennaname, 
-                             casa::Vector<casa::Double> &antennaposition, 
-                             casa::Float &equinox, 
-                             casa::String &freqref, 
-                             casa::Double &reffreq, 
-                             casa::Double &bandwidth,
-                             casa::Double &utc, 
-                             casa::String &fluxunit, 
-                             casa::String &epoch, 
-                             casa::String &poltype ) 
-{
-  casa::String funcName = "fillHeader" ;
+void OldASDMReader::fillHeader( casacore::Int &nchan, 
+                             casacore::Int &npol, 
+                             casacore::Int &nif, 
+                             casacore::Int &nbeam, 
+                             casacore::String &observer, 
+                             casacore::String &project, 
+                             casacore::String &obstype, 
+                             casacore::String &antennaname, 
+                             casacore::Vector<casacore::Double> &antennaposition, 
+                             casacore::Float &equinox, 
+                             casacore::String &freqref, 
+                             casacore::Double &reffreq, 
+                             casacore::Double &bandwidth,
+                             casacore::Double &utc, 
+                             casacore::String &fluxunit, 
+                             casacore::String &epoch, 
+                             casacore::String &poltype ) 
+{
+  casacore::String funcName = "fillHeader" ;
 
   ExecBlockTable &ebtab = asdm_->getExecBlock() ;
   // at the moment take first row of ExecBlock table
   ExecBlockRow *ebrow = ebtab.get()[0] ;
-  casa::String telescopeName( ebrow->getTelescopeName() ) ;
-  //casa::String stationName( stationRow_p->getName() ) ;
+  casacore::String telescopeName( ebrow->getTelescopeName() ) ;
+  //casacore::String stationName( stationRow_p->getName() ) ;
 
   // antennaname
@@ -295 +295 @@
   // antennaposition
   antennaposition.resize( 3 ) ;
-  for ( casa::uInt i = 0 ; i < 3 ; i++ ) 
+  for ( casacore::uInt i = 0 ; i < 3 ; i++ ) 
     antennaposition[i] = antennaPosition_[i].getValue( Unit("m") ) ;
 
@@ -307 +307 @@
   // utc
   // start time of the project
-  utc = casa::Double( ebrow->getStartTime().getMJD() ) ;
+  utc = casacore::Double( ebrow->getStartTime().getMJD() ) ;
   
 
@@ -326 +326 @@
       refidx = irow ;
   }
-  nchan = casa::Int( *max_element( nchans.begin(), nchans.end() ) ) ;
+  nchan = casacore::Int( *max_element( nchans.begin(), nchans.end() ) ) ;
 
   //logsink_->postLocally( LogMessage("refidx = "+String::toString(refidx),LogOrigin(className_,funcName,WHERE)) ) ;
@@ -337 +337 @@
     }
   }
-  bandwidth = casa::Double( *max_element( bws.begin(), bws.end() ) ) ;
+  bandwidth = casacore::Double( *max_element( bws.begin(), bws.end() ) ) ;
 
   // reffreq
-  reffreq = casa::Double( spwrows[refidx]->getRefFreq().get() ) ;
+  reffreq = casacore::Double( spwrows[refidx]->getRefFreq().get() ) ;
 
   // freqref
@@ -382 +382 @@
 
   // npol
-  npol = casa::Int( *max_element( npols.begin(), npols.end() ) ) ;
+  npol = casacore::Int( *max_element( npols.begin(), npols.end() ) ) ;
 
   // poltype
@@ -421 +421 @@
 
   // nbeam
-  nbeam = casa::Int( *max_element( nbeams.begin(), nbeams.end() ) ) ;
+  nbeam = casacore::Int( *max_element( nbeams.begin(), nbeams.end() ) ) ;
 
   // fluxunit
@@ -441 +441 @@
   obstype = "" ;
   for ( unsigned int imode = 0 ; imode < obsmode.size() ; imode++ ) {
-    obstype += casa::String(obsmode[imode]) ;
+    obstype += casacore::String(obsmode[imode]) ;
     if ( imode != obsmode.size()-1 )
       obstype += "#" ;
@@ -449 +449 @@
 void OldASDMReader::selectConfigDescription() 
 {
-  casa::String funcName = "selectConfigDescription" ;
+  casacore::String funcName = "selectConfigDescription" ;
 
   vector<ConfigDescriptionRow *> cdrows = asdm_->getConfigDescription().get() ;
@@ -462 +462 @@
   configDescIdList_.resize( cdidTags.size() ) ;
   for ( unsigned int i = 0 ; i < cdidTags.size() ; i++ ) {
-    configDescIdList_[i] = casa::uInt( cdidTags[i].getTagValue() ) ;
+    configDescIdList_[i] = casacore::uInt( cdidTags[i].getTagValue() ) ;
   }
 }
@@ -472 +472 @@
   Tag atag( antennaId_, TagType::Antenna ) ;
   for ( unsigned int irow = 0 ; irow < frows.size() ; irow++ ) {
-    casa::uInt feedId = (casa::uInt)(frows[irow]->getFeedId() ) ;
-    if ( casa::anyEQ( feedIdList_, feedId ) ) 
+    casacore::uInt feedId = (casacore::uInt)(frows[irow]->getFeedId() ) ;
+    if ( casacore::anyEQ( feedIdList_, feedId ) ) 
       continue ;
     if ( frows[irow]->getAntennaId() == atag ) {
@@ -483 +483 @@
 }
 
-casa::Vector<casa::uInt> OldASDMReader::getFieldIdList() 
-{
-  casa::String funcName = "getFieldIdList" ;
+casacore::Vector<casacore::uInt> OldASDMReader::getFieldIdList() 
+{
+  casacore::String funcName = "getFieldIdList" ;
 
   vector<FieldRow *> frows = asdm_->getField().get() ;
@@ -497 +497 @@
 }
 
-casa::uInt OldASDMReader::getNumMainRow() 
-{
-  casa::uInt nrow = casa::uInt( mainRow_.size() ) ;
+casacore::uInt OldASDMReader::getNumMainRow() 
+{
+  casacore::uInt nrow = casacore::uInt( mainRow_.size() ) ;
 
   return nrow ;
@@ -530 +530 @@
 }
 
-casa::Bool OldASDMReader::setMainRow( casa::uInt irow ) 
-{
-  casa::Bool status = true ;
+casacore::Bool OldASDMReader::setMainRow( casacore::uInt irow ) 
+{
+  casacore::Bool status = true ;
   row_ = irow ;
   execBlockTag_ = mainRow_[row_]->getExecBlockId() ;
@@ -540 +540 @@
     status = false ;
   else {
-    status = (casa::Bool)(sdmBin_->acceptMainRow( mainRow_[row_] )) ;
+    status = (casacore::Bool)(sdmBin_->acceptMainRow( mainRow_[row_] )) ;
   }
   return status ;
 }
 
-casa::Bool OldASDMReader::setMainRow( casa::uInt configDescId, casa::uInt fieldId ) 
+casacore::Bool OldASDMReader::setMainRow( casacore::uInt configDescId, casacore::uInt fieldId ) 
 {
   clearMainRow() ;
@@ -551 +551 @@
   Tag configDescTag( (unsigned int)configDescId, TagType::ConfigDescription ) ;
   Tag fieldTag( (unsigned int)fieldId, TagType::Field ) ;
-  mainRow_ = casa::Vector<MainRow *>( *(asdm_->getMain().getByContext( configDescTag, fieldTag ) ) ) ;
+  mainRow_ = casacore::Vector<MainRow *>( *(asdm_->getMain().getByContext( configDescTag, fieldTag ) ) ) ;
   
   return true ;
@@ -563 +563 @@
 void OldASDMReader::setupIFNO() 
 {
-  casa::String funcName = "setupIFNO" ;
+  casacore::String funcName = "setupIFNO" ;
 
   vector<SpectralWindowRow *> spwrows = asdm_->getSpectralWindow().get() ;
   unsigned int nrow = spwrows.size() ;
   ifno_.clear() ;
-  casa::uInt idx = 0 ;
-  casa::uInt wvridx = 0 ;
+  casacore::uInt idx = 0 ;
+  casacore::uInt wvridx = 0 ;
   for ( unsigned int irow = 0 ; irow < nrow ; irow++ ) {
-    casa::uInt index ;
+    casacore::uInt index ;
     if ( isWVR( spwrows[irow] ) ) {
       //logsink_->postLocally( LogMessage(spwrows[irow]->getSpectralWindowId().toString()+" is WVR",LogOrigin(className_,funcName,WHERE)) ) ;
@@ -579 +579 @@
       index = ++idx ;
     }
-    ifno_.insert( pair<Tag,casa::uInt>(spwrows[irow]->getSpectralWindowId(),index) ) ;
+    ifno_.insert( pair<Tag,casacore::uInt>(spwrows[irow]->getSpectralWindowId(),index) ) ;
     //logsink_->postLocally( LogMessage(spwrows[irow]->getSpectralWindowId().toString()+": IFNO="+String::toString(index),LogOrigin(className_,funcName,WHERE)) ) ;
   }
@@ -594 +594 @@
 } 
 
-casa::Bool OldASDMReader::setData()
-{
-  casa::String funcName = "setData" ;
+casacore::Bool OldASDMReader::setData()
+{
+  casacore::String funcName = "setData" ;
 
   //logsink_->postLocally( LogMessage("try to retrieve binary data",LogOrigin(className_,funcName,WHERE)) ) ;
@@ -671 +671 @@
 }
 
-casa::uInt OldASDMReader::getIFNo( unsigned int idx )
+casacore::uInt OldASDMReader::getIFNo( unsigned int idx )
 {
   prepareData( idx ) ;
@@ -677 +677 @@
 }
 
-casa::uInt OldASDMReader::getIFNo()
-{
-  map<Tag,casa::uInt>::iterator iter = ifno_.find( specWinTag_ ) ;
+casacore::uInt OldASDMReader::getIFNo()
+{
+  map<Tag,casacore::uInt>::iterator iter = ifno_.find( specWinTag_ ) ;
   if ( iter != ifno_.end() )
     return iter->second ;
@@ -713 +713 @@
                                string &freqref ) 
 {
-  casa::String funcName = "getFrequency" ;
+  casacore::String funcName = "getFrequency" ;
 
   int nchan = specWinRow_p->getNumChan() ;
@@ -730 +730 @@
     }
     else {
-      throw (casa::AipsError( "Either chanFreqArray or chanFreqStart must exist." )) ;
+      throw (casacore::AipsError( "Either chanFreqArray or chanFreqStart must exist." )) ;
     }      
   }
@@ -745 +745 @@
     }
     else {
-      throw (casa::AipsError( "Either chanWidthArray or chanWidth must exist." )) ;
+      throw (casacore::AipsError( "Either chanWidthArray or chanWidth must exist." )) ;
     }      
     if ( specWinRow_p->isChanFreqStepExists() ) {
@@ -757 +757 @@
     }
     else {
-      throw (casa::AipsError( "Either chanFreqArray or chanFreqStep must exist." )) ;
+      throw (casacore::AipsError( "Either chanFreqArray or chanFreqStep must exist." )) ;
     }          
     if ( specWinRow_p->isChanFreqStartExists() ) {
@@ -766 +766 @@
     }
     else {
-      throw (casa::AipsError( "Either chanFreqArray or chanFreqStart must exist." )) ;
+      throw (casacore::AipsError( "Either chanFreqArray or chanFreqStart must exist." )) ;
     }      
   }
@@ -781 +781 @@
     }
     else {
-      throw (casa::AipsError( "Either chanWidthArray or chanWidth must exist." )) ;
+      throw (casacore::AipsError( "Either chanWidthArray or chanWidth must exist." )) ;
     }
     if ( specWinRow_p->isChanFreqStepExists() ) {
@@ -793 +793 @@
     }
     else {
-      throw (casa::AipsError( "Either chanFreqArray or chanFreqStep must exist." )) ;
+      throw (casacore::AipsError( "Either chanFreqArray or chanFreqStep must exist." )) ;
     }          
     if ( specWinRow_p->isChanFreqStartExists() ) {
@@ -803 +803 @@
     }
     else {
-      throw (casa::AipsError( "Either chanFreqArray or chanFreqStart must exist." )) ;
+      throw (casacore::AipsError( "Either chanFreqArray or chanFreqStart must exist." )) ;
     }      
   }
@@ -1237 +1237 @@
     for ( unsigned int irow = 0 ; irow < nrow ; irow++ ) {
       CalAtmosphereRow *atmrow = atmrows[irow] ;
-      if ( casa::String(atmrow->getAntennaName()) != antennaName_ 
+      if ( casacore::String(atmrow->getAntennaName()) != antennaName_ 
            //|| atmrow->getReceiverBand() != rb 
            //|| atmrow->getBasebandName() != bbname 
@@ -1279 +1279 @@
                                  float &windaz ) 
 {
-  casa::String funcName = "getWeatherInfo" ;
+  casacore::String funcName = "getWeatherInfo" ;
 
   temperature = 0.0 ;
@@ -1668 +1668 @@
                           double &el,
                           double &mjd,
-                          casa::Vector<casa::Quantity> &antpos ) 
-//                          casa::Vector<casa::Double> antpos ) 
+                          casacore::Vector<casacore::Quantity> &antpos ) 
+//                          casacore::Vector<casacore::Double> antpos ) 
 {
   String funcName = "toJ2000" ;
@@ -1681 +1681 @@
 
 vector<double> OldASDMReader::toJ2000( vector<double> &dir,
-                                    casa::String &dirref,
+                                    casacore::String &dirref,
                                     double &mjd,
-                                    casa::Vector<casa::Quantity> &antpos ) 
-//                                    casa::Vector<casa::Double> antpos ) 
-{
-  casa::String funcName = "toJ2000" ;
+                                    casacore::Vector<casacore::Quantity> &antpos ) 
+//                                    casacore::Vector<casacore::Double> antpos ) 
+{
+  casacore::String funcName = "toJ2000" ;
 
   vector<double> newd( dir ) ;
   if ( dirref != "J2000" ) {
-    casa::MEpoch me( casa::Quantity( (casa::Double)mjd, "d" ), casa::MEpoch::UTC ) ;
-    casa::MPosition mp( casa::MVPosition( antpos ),
-                        casa::MPosition::ITRF ) ;
+    casacore::MEpoch me( casacore::Quantity( (casacore::Double)mjd, "d" ), casacore::MEpoch::UTC ) ;
+    casacore::MPosition mp( casacore::MVPosition( antpos ),
+                        casacore::MPosition::ITRF ) ;
     //ostringstream oss ;
     //mp.print( oss ) ;
     //logsink_->postLocally( LogMessage(oss.str(),LogOrigin(className_,funcName,WHERE)) ) ;
     
-    casa::MeasFrame mf( me, mp ) ;
-    casa::MDirection::Types dirtype ;
-    casa::Bool b = casa::MDirection::getType( dirtype, dirref ) ;
+    casacore::MeasFrame mf( me, mp ) ;
+    casacore::MDirection::Types dirtype ;
+    casacore::Bool b = casacore::MDirection::getType( dirtype, dirref ) ;
     if ( b ) {
-      casa::MDirection::Convert toj2000( dirtype,
-                                         casa::MDirection::Ref( casa::MDirection::J2000, mf ) ) ;
-      casa::Vector<casa::Double> cdir = toj2000( dir ).getAngle( "rad" ).getValue() ; 
+      casacore::MDirection::Convert toj2000( dirtype,
+                                         casacore::MDirection::Ref( casacore::MDirection::J2000, mf ) ) ;
+      casacore::Vector<casacore::Double> cdir = toj2000( dir ).getAngle( "rad" ).getValue() ; 
       //logsink_->postLocally( LogMessage("cdir = "+String::toString(cdir),LogOrigin(className_,funcName,WHERE)) ) ;
       newd[0] = (double)(cdir[0]) ;
@@ -1719 +1719 @@
 string OldASDMReader::getFrame()
 {
-  casa::String funcName = "getFrame" ;
+  casacore::String funcName = "getFrame" ;
  
   // default is TOPO
@@ -1748 +1748 @@
 int OldASDMReader::getNumIFs()
 {
-  casa::String funcName = "getNumIFs" ;
+  casacore::String funcName = "getNumIFs" ;
 
   int nif = 0 ;

trunk/external-alma/oldasdm2ASAP/OldASDMReader.h

@@ -31 +31 @@
    * @return boolean status (true or false) 
    **/
-  bool open( const std::string &filename, const casa::Record &rec ) ;
+  bool open( const std::string &filename, const casacore::Record &rec ) ;
 
   /**
@@ -46 +46 @@
    * get antenna id
    **/
-  casa::Int getAntennaId() { return antennaId_ ; } ;
+  casacore::Int getAntennaId() { return antennaId_ ; } ;
 
   /**
    * get antenna name
    **/
-  casa::String getAntennaName() { return antennaName_ ; } ;
+  casacore::String getAntennaName() { return antennaName_ ; } ;
 
   /**
@@ -74 +74 @@
    * @param poltype polarization type
    **/
-  void fillHeader( casa::Int &nchan, 
-                   casa::Int &npol, 
-                   casa::Int &nif, 
-                   casa::Int &nbeam, 
-                   casa::String &observer, 
-                   casa::String &project, 
-                   casa::String &obstype, 
-                   casa::String &antennaname, 
-                   casa::Vector<casa::Double> &antennaposition, 
-                   casa::Float &equinox, 
-                   casa::String &freqref, 
-                   casa::Double &reffreq, 
-                   casa::Double &bandwidth,
-                   casa::Double &utc, 
-                   casa::String &fluxunit, 
-                   casa::String &epoch, 
-                   casa::String &poltype ) ;  
+  void fillHeader( casacore::Int &nchan, 
+                   casacore::Int &npol, 
+                   casacore::Int &nif, 
+                   casacore::Int &nbeam, 
+                   casacore::String &observer, 
+                   casacore::String &project, 
+                   casacore::String &obstype, 
+                   casacore::String &antennaname, 
+                   casacore::Vector<casacore::Double> &antennaposition, 
+                   casacore::Float &equinox, 
+                   casacore::String &freqref, 
+                   casacore::Double &reffreq, 
+                   casacore::Double &bandwidth,
+                   casacore::Double &utc, 
+                   casacore::String &fluxunit, 
+                   casacore::String &epoch, 
+                   casacore::String &poltype ) ;  
 
   /**
@@ -100 +100 @@
    * @return list of valid configDescriptionId 
    **/
-  casa::Vector<casa::uInt> getConfigDescriptionIdList() { return configDescIdList_ ; } ;
+  casacore::Vector<casacore::uInt> getConfigDescriptionIdList() { return configDescIdList_ ; } ;
 
   /**
    * get list of fieldId
    *
-   * @return list of fieldId as casa::uInt
-   **/
-  casa::Vector<casa::uInt> getFieldIdList() ;
+   * @return list of fieldId as casacore::uInt
+   **/
+  casacore::Vector<casacore::uInt> getFieldIdList() ;
 
   /**
@@ -114 +114 @@
    * @return number of rows in Main table
    **/
-  casa::uInt getNumMainRow() ;
+  casacore::uInt getNumMainRow() ;
 
   /**
@@ -128 +128 @@
    * @param fieldId
    **/
-  casa::Bool setMainRow( casa::uInt configDescId, casa::uInt fieldId ) ;
+  casacore::Bool setMainRow( casacore::uInt configDescId, casacore::uInt fieldId ) ;
 
   /**
@@ -136 +136 @@
    * @return boolean indicating the row is valid or not
    **/
-  casa::Bool setMainRow( casa::uInt irow ) ;
+  casacore::Bool setMainRow( casacore::uInt irow ) ;
 
   /**
@@ -174 +174 @@
    * @return IF number
    **/
-  casa::uInt getIFNo( unsigned int idx ) ;
-  casa::uInt getIFNo() ;
+  casacore::uInt getIFNo( unsigned int idx ) ;
+  casacore::uInt getIFNo() ;
 
   /**
@@ -380 +380 @@
    * @return boolean status
    **/
-  casa::Bool setData() ;
+  casacore::Bool setData() ;
 
   /**
@@ -401 +401 @@
    * @param logger (LogSinkInterface)
    **/
-  void setLogger( casa::CountedPtr<casa::LogSinkInterface> &logsink ) ;
+  void setLogger( casacore::CountedPtr<casacore::LogSinkInterface> &logsink ) ;
 
 
@@ -490 +490 @@
                 double &el,
                 double &mjd,
-                casa::Vector<casa::Quantity> &antpos ) ;
+                casacore::Vector<casacore::Quantity> &antpos ) ;
 
   /**
@@ -502 +502 @@
   **/
   std::vector<double> toJ2000( std::vector<double> &dir,
-                               casa::String &dirref,
+                               casacore::String &dirref,
                                double &mjd,
-                               casa::Vector<casa::Quantity> &antpos ) ;
+                               casacore::Vector<casacore::Quantity> &antpos ) ;
   /**
    * get nIF
@@ -569 +569 @@
   const sdmbin::VMSData *vmsData_ ;
  
-  casa::Int antennaId_ ; // antenna id
-  casa::String antennaName_ ; // antenna name
-  casa::String stationName_ ; // station name
-  casa::Vector<casa::Quantity> antennaPosition_ ; // antenna position
-  casa::Vector<casa::uInt> configDescIdList_ ; // list of valid configDescriptionId 
-  casa::Vector<casa::uInt> feedIdList_ ; // list of valid feedId 
-  casa::Vector<casa::uInt> fieldIdList_ ; // list of fieldId
-  casa::Int row_ ; // current row index
-  map<asdm::Tag,casa::uInt> ifno_ ; // list of IFNO for each SpectralWindow rows
+  casacore::Int antennaId_ ; // antenna id
+  casacore::String antennaName_ ; // antenna name
+  casacore::String stationName_ ; // station name
+  casacore::Vector<casacore::Quantity> antennaPosition_ ; // antenna position
+  casacore::Vector<casacore::uInt> configDescIdList_ ; // list of valid configDescriptionId 
+  casacore::Vector<casacore::uInt> feedIdList_ ; // list of valid feedId 
+  casacore::Vector<casacore::uInt> fieldIdList_ ; // list of fieldId
+  casacore::Int row_ ; // current row index
+  map<asdm::Tag,casacore::uInt> ifno_ ; // list of IFNO for each SpectralWindow rows
   unsigned int numData_ ; // number of valid data in vmsData_ where v_antennaId equals antennaId_
   vector<unsigned int> dataIdList_ ; // list of valid data indexes in vmsData_  
@@ -587 +587 @@
   EnumSet<TimeSamplingMod::TimeSampling> timeSampling_ ; // time sampling
   EnumSet<SpectralResolutionTypeMod::SpectralResolutionType> resolutionType_ ; // spectral resolution type
-  casa::CountedPtr<casa::LogSinkInterface> logsink_ ; // Logger
-  casa::String className_ ;
+  casacore::CountedPtr<casacore::LogSinkInterface> logsink_ ; // Logger
+  casacore::String className_ ;
   unsigned int dataIndex_ ;
 
   // Tables/Rows for ASDM
-  casa::Vector<asdm::MainRow *> mainRow_ ; // list of pointers to all Main rows
+  casacore::Vector<asdm::MainRow *> mainRow_ ; // list of pointers to all Main rows
   //asdm::AntennaRow *antennaRow_p ; // pointer to target Antenna row
   //asdm::StationRow *stationRow_p ; // pointer to target Station row that target antenna is located