Changeset 1987 for trunk/src

Timestamp:

02/02/11 13:15:19 (14 years ago)

Author:

Takeshi Nakazato

Message:

New Development: No

JIRA Issue: Yes CAS-2718

Ready for Test: Yes

Interface Changes: 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...

Improved MSFiller/MSWriter.
Changed Scantable::get_antennaName() to fit with MSFiller/MSWriter.

Location:

trunk/src

Files:

• MSFiller.cpp (modified) (67 diffs)
• MSFiller.h (modified) (5 diffs)
• MSWriter.cpp (modified) (1 diff)
• Scantable.cpp (modified) (1 diff)

trunk/src/MSFiller.cpp

@@ -17 +17 @@
 #include <tables/Tables/ExprNode.h>
 #include <tables/Tables/TableIter.h>
+#include <tables/Tables/TableColumn.h>
 #include <tables/Tables/ScalarColumn.h>
 #include <tables/Tables/ArrayColumn.h>
+#include <tables/Tables/RefRows.h>
+#include <tables/Tables/TableParse.h>
 #include <tables/Tables/RefRows.h>
 
@@ -25 +28 @@
 #include <casa/Arrays/Slicer.h>
 #include <casa/Quanta/MVTime.h>
+#include <casa/OS/Path.h>
 
 #include <measures/Measures/Stokes.h>
 #include <measures/Measures/MEpoch.h>
+#include <measures/Measures/MCEpoch.h>
+#include <measures/Measures/MFrequency.h>
+#include <measures/Measures/MCFrequency.h>
+#include <measures/Measures/MPosition.h>
+#include <measures/Measures/MCPosition.h>
+#include <measures/Measures/MDirection.h>
+#include <measures/Measures/MCDirection.h>
+#include <measures/Measures/MeasConvert.h>
 #include <measures/TableMeasures/ScalarMeasColumn.h>
+#include <measures/TableMeasures/ArrayMeasColumn.h>
+#include <measures/TableMeasures/ScalarQuantColumn.h>
+#include <measures/TableMeasures/ArrayQuantColumn.h>
 
 #include <atnf/PKSIO/SrcType.h>
@@ -41 +56 @@
 MSFiller::MSFiller( casa::CountedPtr<Scantable> stable )
   : table_( stable ),
+    tablename_( "" ),
     antenna_( -1 ),
     getPt_( False ),
@@ -65 +81 @@
 {
   os_.origin( LogOrigin( "MSFiller", "open()", WHERE ) ) ;
+  //os_ << "start MSFiller::open()" << LogIO::POST ;
   //os_ << "   filename = " << filename << endl ;
-  //rec.print( os_.output(), 25, "      " ) ;
-  //os_ << LogIO::POST ;
 
   // parsing MS options
-  //Int antenna = 0 ;
-  //Bool getPt = False;
-
   if ( rec.isDefined( "ms" ) ) {
     Record msrec = rec.asRecord( "ms" ) ;
@@ -95 +107 @@
   os_ << "   antenna = " << antenna_ << LogIO::POST ;
 
-  mstable_ = MeasurementSet( filename, Table::Old ) ;
+  MeasurementSet *tmpMS = new MeasurementSet( filename, Table::Old ) ;
+  //mstable_ = (*tmpMS)( tmpMS->col("ANTENNA1") == antenna_ 
+  //                     && tmpMS->col("ANTENNA1") == tmpMS->col("ANTENNA2") ) ;
+  tablename_ = tmpMS->tableName() ;
+  mstable_ = MeasurementSet( (*tmpMS)( tmpMS->col("ANTENNA1") == antenna_ 
+                                       && tmpMS->col("ANTENNA1") == tmpMS->col("ANTENNA2") ) ) ;
+//   stringstream ss ;
+//   ss << "SELECT FROM $1 WHERE ANTENNA1 == ANTENNA2 && ANTENNA1 == " << antenna_ ;
+//   String taql( ss.str() ) ;
+//   mstable_ = MeasurementSet( tableCommand( taql, *tmpMS ) ) ;
+  delete tmpMS ;
 
   // check which data column exists
-  isFloatData_ = mstable_.isColumn( MSMainEnums::FLOAT_DATA ) ;
-  isData_ = mstable_.isColumn( MSMainEnums::DATA ) ;
-
+  isFloatData_ = mstable_.tableDesc().isColumn( "FLOAT_DATA" ) ;
+  isData_ = mstable_.tableDesc().isColumn( "DATA" ) ;
+
+  //os_ << "end MSFiller::open()" << LogIO::POST ;
   return true ;
 }
@@ -107 +130 @@
 {
   os_.origin( LogOrigin( "MSFiller", "fill()", WHERE ) ) ;
-
-  tablesel_ = mstable_( mstable_.col("ANTENNA1") == mstable_.col("ANTENNA2")  
-                        && mstable_.col("ANTENNA1") == antenna_ ) ;
+  //os_ << "start MSFiller::fill()" << LogIO::POST ;
 
   // Initialize header
@@ -132 +153 @@
  
   // check if optional table exists
-  const TableRecord msrec = tablesel_.keywordSet() ;
+  //const TableRecord msrec = tablesel_.keywordSet() ;
+  const TableRecord msrec = mstable_.keywordSet() ;
   isDoppler_ = msrec.isDefined( "DOPPLER" ) ;
   isFlagCmd_ = msrec.isDefined( "FLAG_CMD" ) ;
@@ -142 +164 @@
   
   // Access to MS subtables
-  MSField fieldtab = tablesel_.field() ;
-  MSPolarization poltab = tablesel_.polarization() ;
-  MSDataDescription ddtab = tablesel_.dataDescription() ;
-  MSObservation obstab = tablesel_.observation() ;
-  MSSource srctab = tablesel_.source() ;
-  MSSpectralWindow spwtab = tablesel_.spectralWindow() ;
-  MSSysCal caltab = tablesel_.sysCal() ; 
+  MSField fieldtab = mstable_.field() ;
+  MSPolarization poltab = mstable_.polarization() ;
+  MSDataDescription ddtab = mstable_.dataDescription() ;
+  MSObservation obstab = mstable_.observation() ;
+  MSSource srctab = mstable_.source() ;
+  MSSpectralWindow spwtab = mstable_.spectralWindow() ;
+  MSSysCal caltab = mstable_.sysCal() ; 
   if ( caltab.nrow() == 0 ) 
     isSysCal_ = False ;
-  MSPointing pointtab = tablesel_.pointing() ;
-  MSWeather weathertab = tablesel_.weather() ;
-  if ( weathertab.nrow() == 0 ) 
+  MSPointing pointtab = mstable_.pointing() ;
+  if ( mstable_.weather().nrow() == 0 ) 
     isWeather_ = False ;
-
-//   os_ << "isDoppler_ = " << isDoppler_ << endl 
-//       << "isFlagCmd_ = " << isFlagCmd_ << endl
-//       << "isFreqOffset_ = " << isFreqOffset_ << endl 
-//       << "isHistory_ = " << isHistory_ << endl
-//       << "isProcessor_ = " << isProcessor_ << endl
-//       << "isSysCal_ = " << isSysCal_ << endl
-//       << "isWeather_ = " << isWeather_ << LogIO::POST ;
-
- // SUBTABLES: FREQUENCIES
-  //fillFrequencies() ;
+  MSState stattab = mstable_.state() ;
+  MSAntenna anttab = mstable_.antenna() ;
+
+  // TEST
+  // memory allocation by boost::object_pool
+  boost::object_pool<ROTableColumn> *tpoolr = new boost::object_pool<ROTableColumn> ;
+  boost::object_pool<TableColumn> *tpoolw = new boost::object_pool<TableColumn> ;
+  //
+
+  // SUBTABLES: FREQUENCIES
   table_->frequencies().setFrame( "LSRK" ) ;
   table_->frequencies().setFrame( "LSRK", True ) ;
@@ -178 +198 @@
   // SUBTABLES: TCAL
   if ( isSysCal_ )
-    fillTcal() ;
-
-  // SUBTABLES: MOLECULES
-  //fillMolecules() ;
+    fillTcal( tpoolr ) ;
 
   // SUBTABLES: FIT
@@ -189 +206 @@
   //fillHistory() ;
 
+  // shared pointers
+  ROTableColumn *tcolr ;
+  TableColumn *tcolw ;
+
+  // Scantable columns
+  Table stab = table_->table() ;
+  TableColumn *scannoCol = tpoolw->construct( stab, "SCANNO" ) ;
+  TableColumn *cyclenoCol = tpoolw->construct( stab, "CYCLENO" ) ;
+  TableColumn *beamnoCol = tpoolw->construct( stab, "BEAMNO" ) ;
+  TableColumn *ifnoCol = tpoolw->construct( stab, "IFNO" ) ;
+  TableColumn *polnoCol = tpoolw->construct( stab, "POLNO" ) ;
+  TableColumn *freqidCol = tpoolw->construct( stab, "FREQ_ID" ) ;
+  TableColumn *molidCol = tpoolw->construct( stab, "MOLECULE_ID" ) ;
+  TableColumn *flagrowCol = tpoolw->construct( stab, "FLAGROW" ) ;
+  ScalarMeasColumn<MEpoch> *timeCol = new ScalarMeasColumn<MEpoch>( stab, "TIME" ) ;
+  TableColumn *intervalCol = tpoolw->construct( stab, "INTERVAL" ) ;
+  TableColumn *srcnameCol = tpoolw->construct( stab, "SRCNAME" ) ;
+  TableColumn *srctypeCol = tpoolw->construct( stab, "SRCTYPE" ) ;
+  TableColumn *fieldnameCol = tpoolw->construct( stab, "SRCNAME" ) ;
+  ArrayColumn<Float> *spCol = new ArrayColumn<Float>( stab, "SPECTRA" ) ;
+  ArrayColumn<uChar> *flCol = new ArrayColumn<uChar>( stab, "FLAGTRA" ) ;
+  ArrayColumn<Float> *tsysCol = new ArrayColumn<Float>( stab, "TSYS" ) ;
+  ArrayColumn<Double> *dirCol = new ArrayColumn<Double>( stab, "DIRECTION" ) ;
+  TableColumn *azCol = tpoolw->construct( stab, "AZIMUTH" ) ;
+  TableColumn *elCol = tpoolw->construct( stab, "ELEVATION" ) ;
+  TableColumn *tcalidCol = tpoolw->construct( stab, "TCAL_ID" ) ;
+  TableColumn *focusidCol = tpoolw->construct( stab, "FOCUS_ID" ) ;
+  TableColumn *weatheridCol = tpoolw->construct( stab, "WEATHER_ID" ) ;
+  ArrayColumn<Double> *srcpmCol = new ArrayColumn<Double>( stab, "SRCPROPERMOTION" ) ;
+  ArrayColumn<Double> *srcdirCol = new ArrayColumn<Double>( stab, "SRCDIRECTION" ) ;
+  TableColumn *srcvelCol = tpoolw->construct( stab, "SRCVELOCITY" ) ;
+  ArrayColumn<Double> *scanrateCol = new ArrayColumn<Double>( stab, "SCANRATE" ) ;
+ 
   // MAIN 
   // Iterate over several ids
   Int oldnr = table_->nrow() ;
   map<Int, uInt> ifmap ; // (IFNO, FREQ_ID) pair
-  ROMSAntennaColumns antCols( mstable_.antenna() ) ;
-  Vector< Quantum<Double> > antpos = antCols.positionQuant()(antenna_) ;
+  ROArrayQuantColumn<Double> *sharedQDArrCol = new ROArrayQuantColumn<Double>( anttab, "POSITION" ) ;
+  Vector< Quantum<Double> > antpos = (*sharedQDArrCol)( antenna_ ) ;
+  delete sharedQDArrCol ;
   MPosition mp( MVPosition( antpos ), MPosition::ITRF ) ;
-  MSPointing potabsel = pointtab( pointtab.col("ANTENNA_ID")==antenna_ ).sort("TIME") ;
-  String stationName = antCols.station()(antenna_) ;
-  ROMSPointingColumns pointCols( potabsel ) ;
-  String telescopeName ;
+  //pointtab = pointtab( pointtab.col("ANTENNA_ID")==antenna_ ).sort("TIME") ;
+  pointtab = MSPointing( pointtab( pointtab.col("ANTENNA_ID")==antenna_ ).sort("TIME") ) ;
+  tcolr = tpoolr->construct( anttab, "STATION" ) ;
+  String stationName = tcolr->asString( antenna_ ) ;
+  tpoolr->destroy( tcolr ) ;
+  tcolr = tpoolr->construct( anttab, "NAME" ) ;
+  String antennaName = tcolr->asString( antenna_ ) ;
+  tpoolr->destroy( tcolr ) ;
+  sdh.antennaposition.resize( 3 ) ;
+  for ( int i = 0 ; i < 3 ; i++ )
+    sdh.antennaposition[i] = antpos[i].getValue( "m" ) ;
+  String telescopeName = "" ;
+
   //
   // ITERATION: OBSERVATION_ID
@@ -205 +265 @@
   Int added0 = 0 ;
   Int current0 = table_->nrow() ;
-  TableIterator iter0( tablesel_, "OBSERVATION_ID" ) ;
+  TableIterator iter0( mstable_, "OBSERVATION_ID" ) ;
   while( !iter0.pastEnd() ) {
-    MeasurementSet t0( iter0.table() ) ;
-    ROScalarColumn<Int> mObsIdCol( t0, "OBSERVATION_ID" ) ;
-    Int obsId = mObsIdCol( 0 ) ;
-    ROMSObservationColumns obsCols( obstab ) ;
-    if ( sdh.observer == "" ) sdh.observer = obsCols.observer()(obsId) ;
-    if ( sdh.project == "" ) sdh.project = obsCols.project()(obsId) ;
-    MEpoch me = obsCols.timeRangeMeas()(obsId)(IPosition(1,0)) ;
+    Table t0 = iter0.table() ;
+    tcolr = tpoolr->construct( t0, "OBSERVATION_ID" ) ;
+    Int obsId = tcolr->asInt( 0 ) ;
+    tpoolr->destroy( tcolr ) ;
+    if ( sdh.observer == "" ) {
+      tcolr = tpoolr->construct( obstab, "OBSERVER" ) ;
+      sdh.observer = tcolr->asString( obsId ) ;
+      tpoolr->destroy( tcolr ) ;
+    }
+    if ( sdh.project == "" ) {
+      tcolr = tpoolr->construct( obstab, "PROJECT" ) ;
+      sdh.observer = tcolr->asString( obsId ) ;
+      tpoolr->destroy( tcolr ) ;
+    }
+    ROArrayMeasColumn<MEpoch> *tmpMeasCol = new ROArrayMeasColumn<MEpoch>( obstab, "TIME_RANGE" ) ;
+    MEpoch me = (*tmpMeasCol)( obsId )( IPosition(1,0) ) ;
+    delete tmpMeasCol ;
     if ( sdh.utc == 0.0 ) {
-      Quantum<Double> startTime = obsCols.timeRangeQuant()(obsId)(IPosition(1,0)) ;
-      sdh.utc = startTime.getValue( "s" ) ;
-    }
-    telescopeName = obsCols.telescopeName()(obsId) ;
+      sdh.utc = me.get( "s" ).getValue() ;
+    }
+    if ( telescopeName == "" ) {
+      tcolr = tpoolr->construct( obstab, "TELESCOPE_NAME" ) ;
+      sdh.observer = tcolr->asString( obsId ) ;
+      tpoolr->destroy( tcolr ) ;
+    }
     Int nbeam = 0 ;
     //
@@ -227 +300 @@
     TableIterator iter1( t0, "FEED1" ) ;
     while( !iter1.pastEnd() ) {
-      MeasurementSet t1( iter1.table() ) ;
-      ROScalarColumn<Int> mFeedCol( t1, "FEED1" ) ;
-      Int feedId = mFeedCol( 0 ) ; // assume FEED1 == FEED2
+      Table t1 = iter1.table() ;
+      // assume FEED1 == FEED2
+      tcolr = tpoolr->construct( t1, "FEED1" ) ;
+      Int feedId = tcolr->asInt( 0 ) ;
+      tpoolr->destroy( tcolr ) ;
       nbeam++ ;
       // 
@@ -238 +313 @@
       TableIterator iter2( t1, "FIELD_ID" ) ;
       while( !iter2.pastEnd() ) {
-        MeasurementSet t2( iter2.table() ) ;
-        ROScalarColumn<Int> mFieldIdCol( t2, "FIELD_ID" ) ;
-        Int fieldId = mFieldIdCol( 0 ) ;
-        ROScalarColumn<String> mFieldNameCol( fieldtab, "NAME" ) ;
-        ROScalarColumn<Int> mSrcIdCol( fieldtab, "SOURCE_ID" ) ;
-        String fieldName = mFieldNameCol( fieldId ) + "__" + String::toString(fieldId) ;
-        Int srcId = mSrcIdCol( fieldId ) ;
+        Table t2 = iter2.table() ;
+        tcolr = tpoolr->construct( t2, "FIELD_ID" ) ;
+        Int fieldId = tcolr->asInt( 0 ) ;
+        tpoolr->destroy( tcolr ) ;
+        tcolr = tpoolr->construct( fieldtab, "SOURCE_ID" ) ;
+        Int srcId = tcolr->asInt( fieldId ) ;
+        tpoolr->destroy( tcolr ) ;
+        tcolr = tpoolr->construct( fieldtab, "NAME" ) ;
+        String fieldName = tcolr->asString( fieldId ) + "__" + String::toString(fieldId) ;
+        tpoolr->destroy( tcolr ) ;
         // 
         // ITERATION: DATA_DESC_ID
@@ -252 +330 @@
         TableIterator iter3( t2, "DATA_DESC_ID" ) ;
         while( !iter3.pastEnd() ) {
-          MeasurementSet t3( iter3.table() ) ;
-          ROScalarColumn<Int> mDDIdCol( t3, "DATA_DESC_ID" ) ;
-          Int ddId = mDDIdCol( 0 ) ;
-          ROMSDataDescColumns ddCols( ddtab ) ;
-          Int polId = ddCols.polarizationId()(ddId) ;
-          Int spwId = ddCols.spectralWindowId()(ddId) ;
+          Table t3 = iter3.table() ;
+          tcolr = tpoolr->construct( t3, "DATA_DESC_ID" ) ;
+          Int ddId = tcolr->asInt( 0 ) ;
+          tpoolr->destroy( tcolr ) ;
+          tcolr = tpoolr->construct( ddtab, "POLARIZATION_ID" ) ;
+          Int polId = tcolr->asInt( ddId ) ;
+          tpoolr->destroy( tcolr ) ;
+          tcolr = tpoolr->construct( ddtab, "SPECTRAL_WINDOW_ID" ) ;
+          Int spwId = tcolr->asInt( ddId ) ;
+          tpoolr->destroy( tcolr ) ;
           // polarization information
-          ROMSPolarizationColumns polCols( poltab ) ;
-          Int npol = polCols.numCorr()(polId) ;
-          Vector<Int> corrtype = polCols.corrType()(polId) ;
+          tcolr = tpoolr->construct( poltab, "NUM_CORR" ) ;
+          Int npol = tcolr->asInt( polId ) ;
+          tpoolr->destroy( tcolr ) ;
+          ROArrayColumn<Int> *roArrICol = new ROArrayColumn<Int>( poltab, "CORR_TYPE" ) ;
+          Vector<Int> corrtype = (*roArrICol)( polId ) ;
+          delete roArrICol ;
           //os_ << "npol = " << npol << LogIO::POST ;
           //os_ << "corrtype = " << corrtype << LogIO::POST ;
@@ -269 +354 @@
           MSSource srctabSel( srctab( srctab.col("SOURCE_ID") == srcId && srctab.col("SPECTRAL_WINDOW_ID") == spwId ) ) ;
           //os_ << "srcId = " << srcId << " spwId = " << spwId << " nrow = " << srctabSel.nrow() << LogIO::POST ; 
-          ROMSSourceColumns srcCols( srctabSel ) ;
-          String srcName = srcCols.name()(0) ;
+          tcolr = tpoolr->construct( srctabSel, "NAME" ) ;
+          String srcName = tcolr->asString( 0 ) ;
+          tpoolr->destroy( tcolr ) ;
           //os_ << "srcName = " << srcName << LogIO::POST ;
-          Array<Double> srcPM = srcCols.properMotion()(0) ;
+          ROArrayColumn<Double> *roArrDCol = new ROArrayColumn<Double>( srctabSel, "PROPER_MOTION" ) ;
+          Array<Double> srcPM = (*roArrDCol)( 0 ) ;
+          delete roArrDCol ;
           //os_ << "srcPM = " << srcPM << LogIO::POST ;
-          Array<Double> srcDir = srcCols.direction()(0) ;
+          roArrDCol = new ROArrayColumn<Double>( srctabSel, "DIRECTION" ) ;
+          Array<Double> srcDir = (*roArrDCol)( 0 ) ;
+          delete roArrDCol ;
           //os_ << "srcDir = " << srcDir << LogIO::POST ;
-          Array<Double> sysVels = srcCols.sysvel()(0) ;
+          Array<Double> sysVels ;
           Double sysVel = 0.0 ;
+          if ( srctabSel.tableDesc().isColumn( "SYSVEL" ) ) {
+            roArrDCol = new ROArrayColumn<Double>( srctabSel, "SYSVEL" ) ;
+            sysVels = (*roArrDCol)( 0 ) ;
+            delete roArrDCol ;
+          }
           if ( !sysVels.empty() ) {
             //os_ << "sysVels.shape() = " << sysVels.shape() << LogIO::POST ;
             // NB: assume all SYSVEL values are the same
-            Double sysVel = sysVels( IPosition(1,0) ) ;
+            sysVel = sysVels( IPosition(1,0) ) ;
           }
+          //delete tmpArrCol ;
           //os_ << "sysVel = " << sysVel << LogIO::POST ;
-          MDirection md = srcCols.directionMeas()(0) ;
+          ROScalarMeasColumn<MDirection> *tmpMeasCol = new ROScalarMeasColumn<MDirection>( srctabSel, "DIRECTION" ) ;
+          MDirection md = (*tmpMeasCol)( 0 ) ;
+          delete tmpMeasCol ;
           // for MOLECULES subtable
-          Int numLines = srcCols.numLines()(0) ;
+          tcolr = tpoolr->construct( srctabSel, "NUM_LINES" ) ;
+          Int numLines = tcolr->asInt( 0 ) ;
+          tpoolr->destroy( tcolr ) ;
           //os_ << "numLines = " << numLines << LogIO::POST ;
           Vector<Double> restFreqs( numLines, 0.0 ) ;
           Vector<String> transitionName( numLines, "" ) ;
           if ( numLines != 0 ) {
-            Array< Quantum<Double> > qRestFreqs = srcCols.restFrequencyQuant()(0) ;
-            for ( int i = 0 ; i < numLines ; i++ ) {
-              restFreqs[i] = qRestFreqs( IPosition( 1, i ) ).getValue( "Hz" ) ;
+            if ( srctabSel.tableDesc().isColumn( "REST_FREQUENCY" ) ) {
+              sharedQDArrCol = new ROArrayQuantColumn<Double>( srctabSel, "REST_FREQUENCY" ) ;
+              Array< Quantum<Double> > qRestFreqs = (*sharedQDArrCol)( 0 ) ;
+              delete sharedQDArrCol ;
+              for ( int i = 0 ; i < numLines ; i++ ) {
+                restFreqs[i] = qRestFreqs( IPosition( 1, i ) ).getValue( "Hz" ) ;
+              }
             }
             //os_ << "restFreqs = " << restFreqs << LogIO::POST ;
             if ( srctabSel.tableDesc().isColumn( "TRANSITION" ) ) {
-              ROScalarColumn<String> transitionNameCol = srcCols.transition() ;
+              tcolr = tpoolr->construct( srctabSel, "TRANSITION" ) ;
+              transitionName = tcolr->asString( 0 ) ;
+              tpoolr->destroy( tcolr ) ;
               //os_ << "transitionNameCol.nrow() = " << transitionNameCol.nrow() << LogIO::POST ;
-              transitionName = transitionNameCol(0) ;
             }
           }
@@ -305 +410 @@
           // spectral setup
           MeasFrame mf( me, mp, md ) ;
-          ROMSSpWindowColumns spwCols( spwtab ) ;
-          MFrequency::Types freqRef = MFrequency::castType((uInt)(spwCols.measFreqRef()(spwId))) ;
-          Int nchan = spwCols.numChan()(spwId) ;
+          tcolr = tpoolr->construct( spwtab, "MEAS_FREQ_REF" ) ;
+          MFrequency::Types freqRef = MFrequency::castType((uInt)(tcolr->asInt(spwId))) ;
+          tpoolr->destroy( tcolr ) ;
+          tcolr = tpoolr->construct( spwtab, "NUM_CHAN" ) ;
+          Int nchan = tcolr->asInt( spwId ) ;
+          tpoolr->destroy( tcolr ) ;
           Bool even = False ;
           if ( (nchan/2)*2 == nchan ) even = True ;
           if ( sdh.nchan < nchan ) sdh.nchan = nchan ;
-          Quantum<Double> qtotbw = spwCols.totalBandwidthQuant()(spwId) ;
-          Double totbw = qtotbw.getValue( "Hz" ) ; 
+          ROScalarQuantColumn<Double> *tmpQuantCol = new ROScalarQuantColumn<Double>( spwtab, "TOTAL_BANDWIDTH" ) ;
+          Double totbw = (*tmpQuantCol)( spwId ).getValue( "Hz" ) ;
+          delete tmpQuantCol ;
           if ( sdh.bandwidth < totbw ) sdh.bandwidth = totbw ;
           if ( sdh.freqref == "" ) 
@@ -318 +427 @@
             sdh.freqref = "LSRK" ;
           if ( sdh.reffreq == -1.0 ) {
-            Quantum<Double> qreffreq = spwCols.refFrequencyQuant()(spwId) ;
+            tmpQuantCol = new ROScalarQuantColumn<Double>( spwtab, "REF_FREQUENCY" ) ;
+            Quantum<Double> qreffreq = (*tmpQuantCol)( spwId ) ;
+            delete tmpQuantCol ;
             if ( freqRef == MFrequency::LSRK ) {
               sdh.reffreq = qreffreq.getValue("Hz") ;
@@ -331 +442 @@
           Double refpix = 0.5*(nchan-1) ;
           Double refval = 0.0 ;
-          Double increment = spwCols.chanWidthQuant()(spwId)(refip).getValue("Hz") ;
+          sharedQDArrCol = new ROArrayQuantColumn<Double>( spwtab, "CHAN_WIDTH" ) ;
+          Double increment = (*sharedQDArrCol)( spwId )( refip ).getValue( "Hz" ) ;
+          delete sharedQDArrCol ;
           //os_ << "nchan = " << nchan << " refchan = " << refchan << "(even=" << even << ") refpix = " << refpix << LogIO::POST ;
-          Vector< Quantum<Double> > chanFreqs = spwCols.chanFreqQuant()(spwId) ;
+          sharedQDArrCol = new ROArrayQuantColumn<Double>( spwtab, "CHAN_FREQ" ) ;
+          Vector< Quantum<Double> > chanFreqs = (*sharedQDArrCol)( spwId ) ;
+          delete sharedQDArrCol ;
           if ( freqRef == MFrequency::LSRK ) {
             if ( even ) {
@@ -365 +480 @@
           // for TSYS and TCAL
           MSSysCal caltabsel( caltab( caltab.col("ANTENNA_ID") == antenna_ && caltab.col("FEED_ID") == feedId && caltab.col("SPECTRAL_WINDOW_ID") == spwId ).sort("TIME") ) ;
-          //Vector<uInt> tcalidrange = addTcal( caltabsel ) ;
           //
           // ITERATION: SCAN_NUMBER
@@ -373 +487 @@
           TableIterator iter4( t3, "SCAN_NUMBER" ) ;
           while( !iter4.pastEnd() ) {
-            MeasurementSet t4( iter4.table() ) ;
-            ROScalarColumn<Int> mScanNumCol( t4, "SCAN_NUMBER" ) ;
-            Int scanNum = mScanNumCol( 0 ) ;
+            Table t4 = iter4.table() ;
+            tcolr = tpoolr->construct( t4, "SCAN_NUMBER" ) ;
+            Int scanNum = tcolr->asInt( 0 ) ;
+            tpoolr->destroy( tcolr ) ;
             uInt cycle = 0 ;
             // 
@@ -384 +499 @@
             TableIterator iter5( t4, "STATE_ID" ) ; 
             while( !iter5.pastEnd() ) {
-              MeasurementSet t5( iter5.table().sort( "TIME" ) ) ;
-              ROScalarColumn<Int> mStateIdCol( t5, "STATE_ID" ) ;
-              Int stateId = mStateIdCol( 0 ) ;
-              ROMSStateColumns stateCols( t5.state() ) ;
-              String obstype = stateCols.obsMode()(stateId) ;
+              Table t5 = iter5.table() ;
+              tcolr = tpoolr->construct( t5, "STATE_ID" ) ;
+              Int stateId = tcolr->asInt( 0 ) ;
+              tpoolr->destroy( tcolr ) ;
+              tcolr = tpoolr->construct( stattab, "OBS_MODE" ) ;
+              String obstype = tcolr->asString( stateId ) ;
+              tpoolr->destroy( tcolr ) ;
               if ( sdh.obstype == "" ) sdh.obstype = obstype ;
 
@@ -394 +511 @@
               Int prevnr = oldnr ;
               Int addednr = 0 ;
+              Int nloop = 0 ;
             
               // SPECTRA, FLAG
-              ArrayColumn<Float> spCol( table_->table(), "SPECTRA" ) ;
-              ArrayColumn<uChar> flagCol( table_->table(), "FLAGTRA" ) ;
               ROArrayColumn<Bool> mFlagCol( t5, "FLAG" ) ;
               if ( isFloatData_ ) {
                 //os_ << "FLOAT_DATA exists" << LogIO::POST ;
                 ROArrayColumn<Float> mFloatDataCol( t5, "FLOAT_DATA" ) ;
-                IPosition cShape = mFloatDataCol.shape( 0 ) ;
-                IPosition newShape( 2, cShape[1], nrow ) ;
-                for ( int ipol = 0 ; ipol < npol ; ipol++ ) {
-                  table_->table().addRow( nrow ) ;
-                  addednr += nrow ;
-                  Int newnr = oldnr + nrow ;
-                  RefRows rows( oldnr, newnr-1 ) ;
-                  Slice paxis( ipol, 1, 1 ) ;
-                  Slice caxis( 0, cShape[1], 1 ) ;
-                  Slicer slicer( paxis, caxis ) ;
-                  spCol.putColumnCells( rows, mFloatDataCol.getColumn(slicer).reform(newShape) ) ;
-                  Array<Bool> flags = mFlagCol.getColumn(slicer).reform(newShape) ;
-                  Array<uChar> flagtra( flags.shape() ) ;
-                  convertArray( flagtra, flags ) ;
-                  flagCol.putColumnCells( rows, flagtra ) ;
-                  oldnr = newnr ;
+                addednr = nrow*npol ;
+                oldnr += addednr ;
+                table_->table().addRow( addednr ) ;
+                nloop = npol ;
+                for ( Int irow = 0 ; irow < nrow ; irow++ ) {
+                  Matrix<Float> sp = mFloatDataCol( irow ) ;
+                  for ( Int ipol = 0 ; ipol < npol ; ipol++ ) {
+                    spCol->put( prevnr+ipol*nrow+irow, sp.row(ipol) ) ;
+                  }
+                }
+                for ( Int irow = 0 ; irow < nrow ; irow++ ) {
+                  Matrix<Bool> flb = mFlagCol( irow ) ;
+                  Matrix<uChar> fl( flb.shape() ) ;
+                  convertArray( fl, flb ) ;
+                  for ( Int ipol = 0 ; ipol < npol ; ipol++ ) {
+                    flCol->put( prevnr+ipol*nrow+irow, fl.row(ipol) ) ;
+                  }
                 }
                 if ( sdh.fluxunit == "" ) {
@@ -428 +545 @@
                 //os_ << "DATA exists" << LogIO::POST ;
                 ROArrayColumn<Complex> mDataCol( t5, "DATA" ) ;
-                IPosition cShape = mDataCol.shape( 0 ) ;
-                IPosition newShape( 2, cShape[1], nrow ) ;
-                Bool crossOK = False ;
-                for ( int ipol = 0 ; ipol < npol ; ipol++ ) {
-                  //os_ << "corrtype[" << ipol << "] = " << corrtype[ipol] << LogIO::POST ;
-                  if ( corrtype[ipol] == Stokes::XY || corrtype[ipol] == Stokes::YX 
-                       || corrtype[ipol] == Stokes::RL || corrtype[ipol] == Stokes::LR ) {
-                    if ( !crossOK ) {
-                      //os_ << "cross polarization data" << LogIO::POST ;
-                      table_->table().addRow( nrow, True ) ;
-                      addednr += nrow ;
-                      //os_ << "table_->nrow() = " << table_->nrow() << LogIO::POST ;
-                      Int newnr = oldnr + nrow ;
-                      RefRows rows( oldnr, newnr-1 ) ;
-                      Slice paxis( ipol, 1, 1 ) ;
-                      Slice caxis( 0, cShape[1], 1 ) ;
-                      Slicer slicer( paxis, caxis ) ;
-                      Array<Complex> data = mDataCol.getColumn(slicer).reform(newShape) ;
-                      spCol.putColumnCells( rows, real( data ) ) ;
-                      Array<Bool> flags = mFlagCol.getColumn(slicer).reform(newShape) ;
-                      Array<uChar> flagtra( flags.shape() ) ;
-                      convertArray( flagtra, flags ) ;
-                      flagCol.putColumnCells( rows, flagtra ) ;
-                      oldnr = newnr ;
-                      table_->table().addRow( nrow, True ) ;
-                      addednr += nrow ;
-                      newnr = oldnr + nrow ;
-                      rows = RefRows( oldnr, newnr-1 ) ;
-                      if ( corrtype[ipol] == Stokes::YX || corrtype[ipol] == Stokes::LR ) {
-                        data = conj( data ) ;
+                addednr = nrow*npol ;
+                oldnr += addednr ;
+                table_->table().addRow( addednr ) ;
+                nloop = npol ;
+                for ( Int irow = 0 ; irow < nrow ; irow++ ) {
+                  Bool crossOK = False ;
+                  Matrix<Complex> sp = mDataCol( irow ) ;
+                  for ( Int ipol = 0 ; ipol < npol ; ipol++ ) {
+                    if ( corrtype[ipol] == Stokes::XY || corrtype[ipol] == Stokes::YX 
+                         || corrtype[ipol] == Stokes::RL || corrtype[ipol] == Stokes::LR ) {
+                      if ( !crossOK ) {
+                        crossOK = True ;
+                        Int pidx = prevnr + ipol * nrow + irow ;
+                        spCol->put( pidx, real( sp.row(ipol) ) ) ;
+                        if ( corrtype[ipol] == Stokes::XY || corrtype[ipol] == Stokes::RL )
+                          spCol->put( pidx+nrow, imag( sp.row(ipol) ) ) ;
+                        else
+                          spCol->put( pidx+nrow, imag( conj(sp.row(ipol)) ) ) ;
                       }
-                      spCol.putColumnCells( rows, imag( data ) ) ;
-                      flagCol.putColumnCells( rows, flagtra ) ;
-                      crossOK = True ;
-                      oldnr = newnr ;
+                    }
+                    else {
+                      spCol->put( prevnr+ipol*nrow+irow, real( sp.row(ipol) ) ) ;
                     }
                   }
-                  else {
-                    table_->table().addRow( nrow, True ) ;
-                    addednr += nrow ;
-                    //os_ << "table_->nrow() = " << table_->nrow() << LogIO::POST ;
-                    Int newnr = oldnr + nrow ;
-                    RefRows rows( oldnr, newnr-1 ) ;
-                    Slice paxis( ipol, 1, 1 ) ;
-                    Slice caxis( 0, cShape[1], 1 ) ;
-                    Slicer slicer( paxis, caxis ) ;
-                    Array<Complex> data = mDataCol.getColumn(slicer).reform(newShape) ;
-                    spCol.putColumnCells( rows, real( data ) ) ;
-                    Array<Bool> flags = mFlagCol.getColumn(slicer).reform(newShape) ;
-                    Array<uChar> flagtra( flags.shape() ) ;
-                    convertArray( flagtra, flags ) ;
-                    flagCol.putColumnCells( rows, flagtra ) ;
-                    oldnr = newnr ;
+                }
+                for ( Int irow = 0 ; irow < nrow ; irow++ ) {
+                  Bool crossOK = False ;
+                  Matrix<Bool> flb = mFlagCol( irow ) ;
+                  Matrix<uChar> fl( flb.shape() ) ;
+                  convertArray( fl, flb ) ;
+                  for ( Int ipol = 0 ; ipol < npol ; ipol++ ) {
+                    if ( corrtype[ipol] == Stokes::XY || corrtype[ipol] == Stokes::YX 
+                         || corrtype[ipol] == Stokes::RL || corrtype[ipol] == Stokes::LR ) {
+                      if ( !crossOK ) {
+                        crossOK = True ;
+                        Int pidx = prevnr + ipol * nrow + irow ;
+                        flCol->put( pidx, fl.row(ipol) ) ;
+                        flCol->put( pidx+nrow, fl.row(ipol+1) ) ;
+                      }
+                    }
+                    else {
+                      flCol->put( prevnr+ipol*nrow+irow, fl.row(ipol) ) ;
+                    }
                   }
                 }
@@ -495 +602 @@
               RefRows rows( prevnr, prevnr+addednr-1 ) ;
 
-              // CYCLENO
-              ScalarColumn<uInt> cyclenoCol( table_->table(), "CYCLENO" ) ;
-              Vector<uInt> cycleno( nrow ) ;
-              indgen( cycleno, cycle ) ;
-              for ( int i = 0 ; i < addednr ; i += nrow ) {
-                Int startrow = prevnr + i ;
-                Int endrow = startrow + nrow - 1 ;
-                RefRows prows( startrow, endrow ) ;
-                cyclenoCol.putColumnCells( prows, cycleno ) ;
-              }
-              cycle += nrow ;
-
-              // POLNO
-              ScalarColumn<uInt> polNoCol( table_->table(), "POLNO" ) ;
-              Vector<uInt> polno( nrow ) ;
-              Int pidx = 0 ;
-              Bool crossOK = False ;
-              for ( int i = 0 ; i < npol ; i++ ) {
-                Vector<uInt> polnos = getPolNo( corrtype[i] ) ;
-                if ( polnos.size() > 1 ) {
-                  if ( crossOK ) continue ;
-                  else crossOK = True ;
-                }
-                for ( uInt j = 0 ; j < polnos.size() ; j++ ) {
-                  Int startrow = prevnr + pidx * nrow ;
-                  Int endrow = startrow + nrow - 1 ;
-                  RefRows prows( startrow, endrow ) ;
-                  polno = polnos[j] ;
-                  polNoCol.putColumnCells( prows, polno ) ;
-                  pidx++ ;
-                }
-              }
-
-              // FLAGROW
-              ScalarColumn<uInt> flagRowCol( table_->table(), "FLAGROW" ) ;
-              ROScalarColumn<Bool> mFlagRowCol( t5, "FLAG_ROW" ) ;
-              Vector<uInt> fr( nrow ) ;
-              convertArray( fr, mFlagRowCol.getColumn() ) ;
-              for ( int i = 0 ; i < addednr ; i += nrow ) {
-                Int startrow = prevnr + i ;
-                Int endrow = startrow + nrow - 1 ;
-                RefRows prows( startrow, endrow ) ;
-                flagRowCol.putColumnCells( prows, fr ) ;
-              }
-
               // TIME
-              MEpoch::ScalarColumn timeCol( table_->table(), "TIME" ) ;
-              MEpoch::ROScalarColumn mTimeCol( t5, "TIME" ) ;
+              ROScalarMeasColumn<MEpoch> *mTimeCol = new ROScalarMeasColumn<MEpoch>( t5, "TIME" ) ;
               Int tidx = prevnr ;
-              for ( Int i = 0 ; i < addednr ; i += nrow ) {
+              for ( Int i = 0 ; i < nloop ; i++ ) {
                 for ( Int j = 0 ; j < nrow ; j++ ) {
-                  timeCol.put( tidx++, mTimeCol( j ) ) ;
+                  timeCol->put( tidx++, (*mTimeCol)( j ) ) ;
                 }
               }
             
-              // INTERVAL
-              ScalarColumn<Double> intervalCol( table_->table(), "INTERVAL" ) ;
-              ROScalarColumn<Double> mIntervalCol( t5, "INTERVAL" ) ;
-              Vector<Double> integ = mIntervalCol.getColumn() ;
-              for ( int i = 0 ; i < addednr ; i += nrow ) {
-                Int startrow = prevnr + i ;
-                Int endrow = startrow + nrow - 1 ;
-                RefRows prows( startrow, endrow ) ;
-                intervalCol.putColumnCells( prows, integ ) ;
-              }
-
-              // SRCTYPE
-              ScalarColumn<Int> srcTypeCol( table_->table(), "SRCTYPE" ) ;
-              Vector<Int> srcType( addednr, getSrcType( stateId ) ) ;
-              srcTypeCol.putColumnCells( rows, srcType ) ;
-
               // TSYS
-              ArrayColumn<Float> tsysCol( table_->table(), "TSYS" ) ;
               Vector<Double> sysCalTime ;
               if ( isSysCal_ ) {
-                sysCalTime = getSysCalTime( caltabsel, mTimeCol ) ;
+                sysCalTime = getSysCalTime( caltabsel, *mTimeCol ) ;
                 tidx = prevnr ;
                 uInt calidx = 0 ;
                 for ( Int i = 0 ; i < nrow ; i++ ) {
-                  Array<Float> tsys ;
+                  Matrix<Float> tsys ;
                   calidx = getTsys( calidx, tsys, caltabsel, sysCalTime(i) ) ;
                   //os_ << "tsys = " << tsys << LogIO::POST ;
-                  IPosition cShape = tsys.shape() ;
-                  //os_ << "cShape = " << cShape << LogIO::POST ;
-                  if ( cShape.size() == 0 ) {
-                    cShape = IPosition( 1, npol ) ;
+                  uInt ncol = tsys.ncolumn() ;
+                  if ( ncol == 0 ) {
+                    IPosition cShape = IPosition( 2, npol, 1 ) ;
                     tsys.resize( cShape ) ;
                     tsys = 1.0 ;
                   }
                   for ( Int ipol = 0 ; ipol < npol ; ipol++ ) {
-                    if ( cShape.nelements() == 1 ) {
-                      Array<Float> subtsys( IPosition(1,1), tsys(IPosition(1,ipol)) ) ;
-                      tsysCol.put( prevnr+i+nrow*ipol, subtsys ) ;
-                    }
-                    else {
-                      Slice paxis( ipol, 1, 1 ) ;
-                      Slice caxis( 0, cShape[1], 1 ) ;
-                      Slicer slicer( paxis, caxis ) ;
-                      Array<Float> subtsys = tsys( slicer ) ;
-                      tsysCol.put( prevnr+i+nrow*ipol, subtsys ) ;
-                    }
+                    //floatArrCol->put( prevnr+i+nrow*ipol, tsys.row( ipol ) ) ;
+                    tsysCol->put( prevnr+i+nrow*ipol, tsys.row( ipol ) ) ;
                   }                  
                 }
               }
               else {
-                Array<Float> tsys( IPosition( 2, 1, addednr ), 1.0 ) ;
-                tsysCol.putColumnCells( rows, tsys ) ;
+                Vector<Float> tsys( 1, 1.0 ) ;
+                for ( Int i = prevnr ; i < prevnr+addednr ; i++ )
+                  tsysCol->put( i, tsys ) ;
               }
 
+
+              // INTERVAL
+              tcolr = tpoolr->construct( t5, "INTERVAL" ) ;
+              //Vector<Double> integ = mIntervalCol->getColumn() ;
+              for ( int i = 0 ; i < nloop ; i++ ) {
+                //Int startrow = prevnr + i ;
+                //Int endrow = startrow + nrow - 1 ;
+                //RefRows prows( startrow, endrow ) ;
+                //intervalCol->putColumnCells( prows, integ ) ;
+                for ( int j = 0 ; j < nrow ; j++ ) {
+                  intervalCol->putScalar( prevnr+i*nrow+j, (Double)(tcolr->asdouble( j )) ) ;
+                }
+              }
+              tpoolr->destroy( tcolr ) ;
+
+              // SRCTYPE
+              Int srcType = getSrcType( stateId, tpoolr ) ;
+              for ( int i = 0 ; i < addednr ; i++ ) {
+                srctypeCol->putScalar( prevnr+i, srcType ) ;
+              }
+              //Vector<Int> *srcType = new Vector<Int>( addednr, getSrcType( stateId ) ) ;
+              //srcTypeCol->putColumnCells( rows, *srcType ) ;
+
               // DIRECTION, AZIMUTH, ELEVATION, SCANRATE
-              ArrayColumn<Double> dirCol( table_->table(), "DIRECTION" ) ;
-              ScalarColumn<Float> azCol( table_->table(), "AZIMUTH" ) ;
-              ScalarColumn<Float> elCol( table_->table(), "ELEVATION" ) ;
-              ArrayColumn<Double> scanRateCol( table_->table(), "SCANRATE" ) ;
               Vector<Double> defaultScanrate( 2, 0.0 ) ;
               uInt diridx = 0 ;
@@ -617 +671 @@
                   Vector<Double> scanrate ;
                   String refString ;
-                  diridx = getDirection( diridx, dir, scanrate, refString, pointCols, mTimeCol(i).get("s").getValue() ) ;
+                  diridx = getDirection( diridx, dir, scanrate, refString, pointtab, (*mTimeCol)(i).get("s").getValue() ) ;
                   //os_ << "diridx = " << diridx << " dmTimeCol(" << i << ") = " << mTimeCol(i).get("s").getValue()-mTimeCol(0).get("s").getValue() << LogIO::POST ;
                   //os_ << "dir = " << dir << LogIO::POST ;
@@ -624 +678 @@
                   MDirection::getType( dirType, refString ) ;
                   //os_ << "dirType = " << dirType << LogIO::POST ;
-                  mf.resetEpoch( mTimeCol(i) ) ;
+                  mf.resetEpoch( (*mTimeCol)(i) ) ;
                   mf.resetDirection( MDirection( MVDirection(dir), dirType ) ) ;
                   if ( refString == "J2000" ) {
                     //os_ << "J2000" << LogIO::POST ;
                     for ( Int ipol = 0 ; ipol < npol ; ipol++ ) {
-                      dirCol.put( prevnr+i+nrow*ipol, dir ) ;
+                      dirCol->put( prevnr+i+nrow*ipol, dir ) ;
                     }
                     MDirection::Convert toazel( dirType, MDirection::Ref( MDirection::AZEL, mf ) ) ;
                     Vector<Double> azel = toazel( dir ).getAngle("rad").getValue() ;
                     for ( Int ipol = 0 ; ipol < npol ; ipol++ ) {
-                      azCol.put( prevnr+i+nrow*ipol, azel(0) ) ;
-                      elCol.put( prevnr+i+nrow*ipol, azel(1) ) ;
+                      azCol->putScalar( prevnr+i+nrow*ipol, (Float)azel(0) ) ;
+                      elCol->putScalar( prevnr+i+nrow*ipol, (Float)azel(1) ) ;
                     }                  
                   }
@@ -641 +695 @@
                     //os_ << "AZEL" << LogIO::POST ;
                     for ( Int ipol = 0 ; ipol < npol ; ipol++ ) {
-                      azCol.put( prevnr+i+nrow*ipol, dir(0) ) ;
-                      elCol.put( prevnr+i+nrow*ipol, dir(1) ) ;
+                      azCol->putScalar( prevnr+i+nrow*ipol, (Float)dir(0) ) ;
+                      elCol->putScalar( prevnr+i+nrow*ipol, (Float)dir(1) ) ;
                     }
                     MDirection::Convert toj2000( dirType, MDirection::Ref( MDirection::J2000, mf ) ) ;
                     Vector<Double> newdir = toj2000( dir ).getAngle("rad").getValue() ;
                     for ( Int ipol = 0 ; ipol < npol ; ipol++ ) {
-                      dirCol.put( prevnr+i+nrow*ipol, newdir ) ;
+                      dirCol->put( prevnr+i+nrow*ipol, newdir ) ;
                     }                  
                   }
@@ -657 +711 @@
                     Vector<Double> newdir = toj2000( dir ).getAngle("rad").getValue() ;
                     for ( Int ipol = 0 ; ipol < npol ; ipol++ ) {
-                      dirCol.put( prevnr+i+nrow*ipol, newdir ) ;
-                      azCol.put( prevnr+i+nrow*ipol, dir(0) ) ;
-                      elCol.put( prevnr+i+nrow*ipol, dir(1) ) ;
+                      dirCol->put( prevnr+i+nrow*ipol, newdir ) ;
+                      azCol->putScalar( prevnr+i+nrow*ipol, (Float)dir(0) ) ;
+                      elCol->putScalar( prevnr+i+nrow*ipol, (Float)dir(1) ) ;
                     }                  
                   }
@@ -665 +719 @@
                     //os_ << "scanrate.size() = " << scanrate.size() << LogIO::POST ;
                     for ( Int ipol = 0 ; ipol < npol ; ipol++ ) {
-                      scanRateCol.put( prevnr+i+nrow*ipol, scanrate ) ;
+                      scanrateCol->put( prevnr+i+nrow*ipol, scanrate ) ;
                     }
                   }
@@ -671 +725 @@
                     //os_ << "scanrate.size() = " << scanrate.size() << LogIO::POST ;
                     for ( Int ipol = 0 ; ipol < npol ; ipol++ ) {
-                      scanRateCol.put( prevnr+i+nrow*ipol, defaultScanrate ) ;
+                      scanrateCol->put( prevnr+i+nrow*ipol, defaultScanrate ) ;
                     }
                   }
@@ -678 +732 @@
               else {
                 // All directions are set to source direction
-                ROArrayMeasColumn<MDirection> dmcol = pointCols.directionMeasCol() ;
-                ROArrayColumn<Double> dcol = pointCols.direction() ;
+                ROArrayMeasColumn<MDirection> dmcol( pointtab, "DIRECTION" ) ;
+                ROArrayColumn<Double> dcol( pointtab, "DIRECTION" ) ;
                 IPosition ip( dmcol(0).shape().nelements(), 0 ) ;
                 IPosition outp( 1, 2 ) ;
@@ -690 +744 @@
                 mf.resetDirection( MDirection( MVDirection(srcDir), dirType ) ) ;
                 if ( ref != "J2000" ) {
-                  mf.resetEpoch( pointCols.timeMeas()(0) ) ;
+                  ROScalarMeasColumn<MEpoch> tmCol( pointtab, "TIME" ) ;
+                  mf.resetEpoch( tmCol( 0 ) ) ;
                   MDirection::Convert toj2000( dirType, MDirection::Ref( MDirection::J2000, mf ) ) ;
                   defaultDir = toj2000( defaultDir ).getAngle("rad").getValue() ;
                 }
                 for ( Int i = 0 ; i < nrow ; i++ ) {
-                  mf.resetEpoch( mTimeCol(i) ) ;
+                  mf.resetEpoch( (*mTimeCol)(i) ) ;
                   for ( Int ipol = 0 ; ipol < npol ; ipol++ ) {
                     Int localidx = prevnr+i+nrow*ipol ;
                     MDirection::Convert toazel( dirType, MDirection::Ref( MDirection::AZEL, mf ) ) ;
                     Vector<Double> azel = toazel( defaultDir ).getAngle("rad").getValue() ;
-                    azCol.put( localidx, azel(0) ) ;
-                    elCol.put( localidx, azel(1) ) ;
-                    dirCol.put( localidx, defaultDir ) ;
-                    scanRateCol.put( localidx, defaultScanrate ) ;
+                    azCol->putScalar( localidx, (Float)azel(0) ) ;
+                    elCol->putScalar( localidx, (Float)azel(1) ) ;
+                    dirCol->put( localidx, defaultDir ) ;
+                    scanrateCol->put( localidx, defaultScanrate ) ;
                   }
                 }
               }
 
+              // CYCLENO
+              for ( int i = 0 ; i < nloop ; i++ ) {
+                for ( int j = 0 ; j < nrow ; j++ ) {
+                  cyclenoCol->putScalar( prevnr+nrow*i+j, cycle+j ) ;
+                }
+              }
+              cycle += nrow ;
+
+              // POLNO
+              Int pidx = 0 ;
+              Bool crossOK = False ;
+              for ( int i = 0 ; i < npol ; i++ ) {
+                Vector<uInt> polnos = getPolNo( corrtype[i] ) ;
+                if ( polnos.size() > 1 ) {
+                  if ( crossOK ) continue ;
+                  else crossOK = True ;
+                }
+                for ( uInt j = 0 ; j < polnos.size() ; j++ ) {
+                  for ( Int irow = 0 ; irow < nrow ; irow++ ) {
+                    polnoCol->putScalar( prevnr+pidx*nrow+irow, polnos[j] ) ;
+                  }
+                  pidx++ ;
+                } 
+              }
+
+              // FLAGROW
+              tcolr = tpoolr->construct( t5, "FLAG_ROW" ) ;
+              for ( int i = 0 ; i < nloop ; i++ ) {
+                for ( int j = 0 ; j < nrow ; j++ ) {
+                  flagrowCol->putScalar( prevnr+nrow*i+j, (uInt)(tcolr->asBool( j )) ) ;
+                }
+              }
+              tpoolr->destroy( tcolr ) ;
+
               // TCAL_ID
-              ScalarColumn<uInt> tcalIdCol( table_->table(), "TCAL_ID" ) ;
               if ( isSysCal_ ) {
                 for( Int irow = 0 ; irow < nrow ; irow++ ) {
@@ -718 +806 @@
                   }
                   for ( Int ipol = 0 ; ipol < npol ; ipol++ ) {
-                  tcalIdCol.put( prevnr+irow+nrow*ipol, tcalids[ipol] ) ;
+                    tcalidCol->putScalar( prevnr+irow+nrow*ipol, tcalids[ipol] ) ;
                   }
                 }
               }
               else {
-                Vector<uInt> tcalid( addednr, 0 ) ;
-                tcalIdCol.putColumnCells( rows, tcalid ) ;
+                //Vector<uInt> tcalid( addednr, 0 ) ;
+                //uIntCol->putColumnCells( rows, tcalid ) ;
+                uInt tcalid = 0 ;
+                for ( Int irow = 0 ; irow < addednr ; irow++ ) 
+                  tcalidCol->putScalar( prevnr+irow, tcalid ) ;
               }
 
               // WEATHER_ID
-              uInt widprev = 0 ;
-              Vector<uInt> vWid( nrow, 0 ) ;
               if ( isWeather_ ) {
-                for ( int j = 0 ; j < nrow ; j++ ) {
-                  //os_ << "TIME value = " << mTimeCol( j ).get("s").getValue() << LogIO::POST ;
-                  uInt wid = getWeatherId( widprev, mTimeCol( j ).get("s").getValue() ) ;
-                  //os_ << "wid = " << wid << LogIO::POST ;
-                  vWid[j] = wid ;
-                  widprev = wid ;
+                uInt wid = 0 ;
+                for ( Int irow = 0 ; irow < nrow ; irow++ ) {
+                  wid = getWeatherId( wid, (*mTimeCol)(irow).get("s").getValue() ) ;
+                  for ( Int ipol = 0 ; ipol < nloop ; ipol++ ) {
+                    weatheridCol->putScalar( prevnr+ipol*nrow+irow, wid ) ;
+                  }
                 }
               }
 
-              ScalarColumn<uInt> weatherIdCol( table_->table(), "WEATHER_ID" ) ;
-              for ( int i = 0 ; i < addednr ; i += nrow ) {
-                Int startrow = prevnr + i ;
-                Int endrow = startrow + nrow - 1 ;
-                RefRows prows( startrow, endrow ) ;
-                weatherIdCol.putColumnCells( prows, vWid ) ;                
-              }
+              delete mTimeCol ;
               
               //os_ << "field: " << fieldId << " scan: " << scanNum << " obs: " << obsId << " state: " << stateId << " ddid: " << ddId << endl ;
-              //os_ << "t.nrow() = " << t5.nrow() << endl ;
+              //os_ << "addednr = " << addednr << endl ;
               added5 += addednr ;
               iter5.next() ;
@@ -755 +838 @@
 
             // SCANNO
-            RefRows rows5( current5, current5+added5-1 ) ;
-            Vector<uInt> scanno( added5, scanNum ) ;
-            ScalarColumn<uInt> scannoCol( table_->table(), "SCANNO" ) ;
-            scannoCol.putColumnCells( rows5, scanno ) ;
-
+            // MS: 1-base
+            // Scantable: 0-base
+            Int dest5 = current5 + added5 ;
+            scanNum -= 1 ;
+            for ( Int irow = current5 ; irow < dest5 ; irow++ )
+              scannoCol->putScalar( irow, (uInt)scanNum ) ;
+
+            //os_ << "added5 = " << added5 << endl ;
             added4 += added5 ;
             iter4.next() ;
@@ -765 +851 @@
 
           // IFNO
-          RefRows rows4( current4, current4+added4-1 ) ;
-          Vector<uInt> shareduIArr( added4, spwId ) ;
-          ScalarColumn<uInt> shareduIArrCol( table_->table(), "IFNO" ) ;
-          shareduIArrCol.putColumnCells( rows4, shareduIArr ) ;
+          Int dest4 = current4 + added4 ;
+          for ( Int irow = current4 ; irow < dest4 ; irow++ ) 
+            ifnoCol->putScalar( irow, (uInt)spwId ) ;
 
           // FREQ_ID
-          shareduIArr = ifmap[spwId] ;
-          shareduIArrCol.attach( table_->table(), "FREQ_ID" ) ;
-          shareduIArrCol.putColumnCells( rows4, shareduIArr ) ;
+          uInt fid = ifmap[spwId] ;
+          for ( Int irow = current4 ; irow < dest4 ; irow++ ) 
+            freqidCol->putScalar( irow, fid ) ;
 
           // MOLECULE_ID
-          shareduIArr = molId ;
-          shareduIArrCol.attach( table_->table(), "MOLECULE_ID" ) ;
-          shareduIArrCol.putColumnCells( rows4, shareduIArr ) ;
+          for ( Int irow = current4 ; irow < dest4 ; irow++ ) 
+            molidCol->putScalar( irow, molId ) ;
 
           // SRCNAME
-          ScalarColumn<String> srcNameCol( table_->table(), "SRCNAME" ) ;
-          Vector<String> vSrcName( added4, srcName ) ;
-          srcNameCol.putColumnCells( rows4, vSrcName ) ;
+          for ( Int irow = current4 ; irow < dest4 ; irow++ )
+            srcnameCol->putScalar( irow, srcName ) ;
 
           // SRCVELOCITY, SRCPROPERMOTION and SRCDIRECTION
           // no reference conversion for direction at the moment (assume J2000)
           // no reference conversion for velocity at the moment (assume LSRK)
-          Matrix<Double> sharedDArr( 2, added4 ) ;
-          for ( uInt icol = 0 ; icol < added4 ; icol++ ) {
-            sharedDArr.column(icol) = srcPM ;
-          }
-          ArrayColumn<Double> sharedDArrCol( table_->table(), "SRCPROPERMOTION" ) ;
-          sharedDArrCol.putColumnCells( rows4, sharedDArr ) ;
-          for ( uInt icol = 0 ; icol < added4 ; icol++ ) {
-            sharedDArr.column(icol) = srcDir ;
-          }          
-          sharedDArrCol.attach( table_->table(), "SRCDIRECTION" ) ;
-          sharedDArrCol.putColumnCells( rows4, sharedDArr ) ;
-          ScalarColumn<Double> sysVelCol( table_->table(), "SRCVELOCITY" ) ;
-          Vector<Double> sysVelArr( added4, sysVel ) ;
-          sysVelCol.putColumnCells( rows4, sysVelArr ) ;
-
+          for ( Int irow = current4 ; irow < dest4 ; irow++ )
+            srcpmCol->put( irow, srcPM ) ;
+          for ( Int irow = current4 ; irow < dest4 ; irow++ )
+            srcdirCol->put( irow, srcDir ) ;
+          for ( Int irow = current4 ; irow < dest4 ; irow++ )
+            srcvelCol->putScalar( irow, sysVel ) ;
+
+          //os_ << "added4 = " << added4 << endl ;
           added3 += added4 ;
           iter3.next() ;
@@ -808 +884 @@
 
         // FIELDNAME
-        RefRows rows3( current3, current3+added3-1 ) ;
-        Vector<String> vFieldName( added3, fieldName ) ;
-        ScalarColumn<String> fieldNameCol( table_->table(), "FIELDNAME" ) ;
-        fieldNameCol.putColumnCells( rows3, vFieldName ) ;
-
+        Int dest3 = current3 + added3 ;
+        for ( Int irow = current3 ; irow < dest3 ; irow++ ) 
+          fieldnameCol->putScalar( irow, fieldName ) ;
+
+        //os_ << "added3 = " << added3 << endl ;
         added2 += added3 ;
         iter2.next() ;
@@ -818 +894 @@
 
       // BEAMNO
-      RefRows rows2( current2, current2+added2-1 ) ; 
-      Vector<uInt> beamno( added2, feedId ) ;
-      ScalarColumn<uInt> beamnoCol( table_->table(), "BEAMNO" ) ;
-      beamnoCol.putColumnCells( rows2, beamno ) ;
+      Int dest2 = current2 + added2 ;
+      for ( Int irow = current2 ; irow < dest2 ; irow++ ) 
+        beamnoCol->putScalar( irow, (uInt)feedId ) ;
 
       // FOCUS_ID
       // tentative
-      beamnoCol.attach( table_->table(), "FOCUS_ID" ) ;
-      beamno = 0 ;
-      beamnoCol.putColumnCells( rows2, beamno ) ;
-
+      uInt focusId = 0 ;
+      for ( Int irow = current2 ; irow < dest2 ; irow++ )
+        focusidCol->putScalar( irow, focusId ) ;
+      
+      //os_ << "added2 = " << added2 << endl ;
       added1 += added2 ;
       iter1.next() ;
@@ -834 +910 @@
     if ( sdh.nbeam < nbeam ) sdh.nbeam = nbeam ;
 
+    //os_ << "added1 = " << added1 << endl ;
     added0 += added1 ;
     iter0.next() ;
   }
 
+  //os_ << "added0 = " << added0 << endl ;
+
   // REFBEAMNO
   // set 0 at the moment
-  ScalarColumn<Int> sharedICol( table_->table(), "REFBEAMNO" ) ;
-  Vector<Int> sharedI( added0, 0 ) ;
-  sharedICol.putColumn( sharedI ) ;
+  tcolw = tpoolw->construct( table_->table(), "REFBEAMNO" ) ;
+  for ( Int irow = current0 ; irow < added0 ; irow++ )
+    tcolw->putScalar( irow, 0 ) ;
+  tpoolw->destroy( tcolw ) ;
+
+  // FIT_ID
+  // nothing to do
+  tcolw = tpoolw->construct( table_->table(), "FIT_ID" ) ;
+  for ( Int irow = current0 ; irow < added0 ; irow++ ) 
+    tcolw->putScalar( irow, -1 ) ;
+  tpoolw->destroy( tcolw ) ;
 
   // OPACITY
   // not used?
-  ScalarColumn<Float> opacityCol( table_->table(), "OPACITY" ) ;
-  Vector<Float> opacity( added0, 0.0 ) ;
-  opacityCol.putColumn( opacity ) ;
-  
-  // FIT_ID
-  // nothing to do
-  sharedICol.attach( table_->table(), "FIT_ID" ) ;
-  sharedI = -1 ;
-  sharedICol.putColumn( sharedI ) ;
+  tcolw = tpoolw->construct( table_->table(), "OPACITY" ) ;
+  for ( Int irow = current0 ; irow < added0 ; irow++ ) 
+    tcolw->putScalar( irow, 0.0 ) ;
+  tpoolw->destroy( tcolw ) ;
+
+  // delete Scantable columns
+  tpoolw->destroy( scannoCol ) ;
+  tpoolw->destroy( cyclenoCol ) ;
+  tpoolw->destroy( beamnoCol ) ;
+  tpoolw->destroy( ifnoCol ) ;
+  tpoolw->destroy( polnoCol ) ;
+  tpoolw->destroy( freqidCol ) ;
+  tpoolw->destroy( molidCol ) ;
+  tpoolw->destroy( flagrowCol ) ;
+  delete timeCol ;
+  tpoolw->destroy( intervalCol ) ;
+  tpoolw->destroy( srcnameCol ) ;
+  tpoolw->destroy( srctypeCol ) ;
+  tpoolw->destroy( fieldnameCol ) ;
+  delete spCol ;
+  delete flCol ;
+  delete tsysCol ;
+  delete dirCol ;
+  tpoolw->destroy( azCol ) ;
+  tpoolw->destroy( elCol ) ;
+  tpoolw->destroy( tcalidCol ) ;
+  tpoolw->destroy( focusidCol ) ;
+  tpoolw->destroy( weatheridCol ) ;
+  delete srcpmCol ;
+  delete srcdirCol ;
+  tpoolw->destroy( srcvelCol ) ;
+  delete scanrateCol ;
+
+  delete tpoolr ;
+  delete tpoolw ;
 
 
   // Table Keywords
   sdh.nif = ifmap.size() ;
-  String antennaName = antCols.name()(antenna_) ;
-  if ( antennaName == telescopeName ) {
+  if ( ( telescopeName == "" ) || ( antennaName == telescopeName ) ) {
     sdh.antennaname = antennaName ;
   }
@@ -869 +981 @@
     sdh.antennaname += "@" + stationName ;
   }
-  sdh.antennaposition = antCols.position()(antenna_);
-  ROMSPointingColumns pointingCols( mstable_.pointing() ) ;
-  String dirref = pointingCols.direction().keywordSet().asRecord("MEASINFO").asString("Ref") ;
+  ROArrayColumn<Double> pdirCol( pointtab, "DIRECTION" ) ; 
+  String dirref = pdirCol.keywordSet().asRecord("MEASINFO").asString("Ref") ;
   if ( dirref == "AZELGEO" || dirref == "AZEL" ) {
     dirref = "J2000" ;
@@ -893 +1004 @@
   }
   table_->setHeader( sdh ) ;
+
+  // save path to POINTING table
+  //Path datapath(mstable_.tableName()) ;
+  Path datapath( tablename_ ) ;
+  String pTabName = datapath.absoluteName() + "/POINTING" ;
+  table_->table().rwKeywordSet().define( "POINTING", pTabName ) ;
+
+  // for GBT
+  if ( antennaName == "GBT" ) {
+    String goTabName = datapath.absoluteName() + "/GBT_GO" ;
+    table_->table().rwKeywordSet().define( "GBT_GO", goTabName ) ;
+  }
+  //os_ << "end MSFiller::fill()" << LogIO::POST ;
 }
 
 void MSFiller::close()
 {
-  tablesel_.closeSubTables() ;
+  //tablesel_.closeSubTables() ;
   mstable_.closeSubTables() ;
-  tablesel_.unlock() ;
+  //tablesel_.unlock() ;
   mstable_.unlock() ;
 }
 
-void MSFiller::fillId( uInt idx, const char *colname, RefRows &rows )
+Int MSFiller::getSrcType( Int stateId, boost::object_pool<ROTableColumn> *tpool ) 
 {
-  ScalarColumn<uInt> col( table_->table(), colname ) ;
-  Vector<uInt> ids( rows.nrow(), idx ) ; 
-  col.putColumnCells( rows, ids ) ;
-}
-
-void MSFiller::fillId( Int idx, const char *colname, RefRows &rows )
-{
-  ScalarColumn<Int> col( table_->table(), colname ) ;
-  Vector<Int> ids( rows.nrow(), idx ) ; 
-  col.putColumnCells( rows, ids ) ;
-}
-
-Int MSFiller::getSrcType( Int stateId ) 
-{
+  //os_ << "start MSFiller::getSrcType()" << LogIO::POST ;
+
   MSState statetab = mstable_.state() ;
-  ROScalarColumn<String> obsModeCol( statetab, "OBS_MODE" ) ;
-  String obsMode = obsModeCol( stateId ) ;
-  ROScalarColumn<Bool> sigCol( statetab, "SIG" ) ;
-  ROScalarColumn<Bool> refCol( statetab, "REF" ) ;
-  Bool sig = sigCol( stateId ) ;
-  Bool ref = refCol( stateId ) ;
+  ROTableColumn *sharedCol ;
+  sharedCol = tpool->construct( statetab, "OBS_MODE" ) ;
+  String obsMode = sharedCol->asString( stateId ) ;
+  tpool->destroy( sharedCol ) ;
+  sharedCol = tpool->construct( statetab, "SIG" ) ;
+  Bool sig = sharedCol->asBool( stateId ) ;
+  tpool->destroy( sharedCol ) ;
+  sharedCol = tpool->construct( statetab, "REF" ) ;
+  Bool ref = sharedCol->asBool( stateId ) ;
+  tpool->destroy( sharedCol ) ;
+  sharedCol = tpool->construct( statetab, "CAL" ) ;
+  Double cal = (Double)(sharedCol->asdouble( stateId )) ;
+  tpool->destroy( sharedCol ) ;
   //os_ << "OBS_MODE = " << obsMode << LogIO::POST ;
 
@@ -953 +1072 @@
     //       SIG=1: FSON
     //       REF=1: FSOFF
+    // Calibration scan if CAL != 0
     Int epos = obsMode.find_first_of( sep ) ;
     Int nextpos = obsMode.find_first_of( sep, epos+1 ) ;
@@ -969 +1089 @@
         if ( ref ) srcType = SrcType::FSOFF ;
       }
+    }
+    if ( cal > 0.0 ) {
+      if ( srcType == SrcType::NOD )
+        srcType = SrcType::NODCAL ;
+      else if ( srcType == SrcType::PSON ) 
+        srcType = SrcType::PONCAL ;
+      else if ( srcType == SrcType::PSOFF ) 
+        srcType = SrcType::POFFCAL ;
+      else if ( srcType == SrcType::FSON ) 
+        srcType = SrcType::FONCAL ;
+      else if ( srcType == SrcType::FSOFF )
+        srcType = SrcType::FOFFCAL ;
+      else 
+        srcType = SrcType::CAL ;
     }
   }
@@ -1001 +1135 @@
     
   //os_ << "srcType = " << srcType << LogIO::POST ;
-
+  //os_ << "end MSFiller::getSrcType()" << LogIO::POST ;
   return srcType ;
 }
@@ -1007 +1141 @@
 Vector<uInt> MSFiller::getPolNo( Int corrType ) 
 {
+  //os_ << "start MSFiller::getPolNo()" << LogIO::POST ;
   Vector<uInt> polno( 1 ) ;
 
@@ -1036 +1171 @@
   }
   //os_ << "polno = " << polno << LogIO::POST ;
+  //os_ << "end MSFiller::getPolNo()" << LogIO::POST ;
   
   return polno ;
@@ -1042 +1178 @@
 String MSFiller::getPolType( Int corrType ) 
 {
+  //os_ << "start MSFiller::getPolType()" << LogIO::POST ;
   String poltype = "" ;
 
@@ -1053 +1190 @@
     poltype = "linpol" ;
 
+  //os_ << "end MSFiller::getPolType()" << LogIO::POST ;
   return poltype ;
 }
@@ -1058 +1196 @@
 void MSFiller::fillWeather()
 {
-  MSWeather mWeather( mstable_.weather() ) ;
-  MSWeather mWeatherSel( mWeather( mWeather.col("ANTENNA_ID") == antenna_ ).sort("TIME") ) ;
+  //os_ << "start MSFiller::fillWeather()" << LogIO::POST ;
+  Table mWeather = mstable_.weather()  ;
+  //Table mWeatherSel = mWeather( mWeather.col("ANTENNA_ID") == antenna_ ).sort("TIME") ;
+  Table mWeatherSel( mWeather( mWeather.col("ANTENNA_ID") == antenna_ ).sort("TIME") ) ;
   //os_ << "mWeatherSel.nrow() = " << mWeatherSel.nrow() << LogIO::POST ;
   if ( mWeatherSel.nrow() == 0 ) {
     os_ << "No rows with ANTENNA_ID = " << antenna_ << ", Try -1..." << LogIO::POST ; 
-    mWeatherSel = MSWeather( mWeather( mWeather.col("ANTENNA_ID") == -1 ) ) ;
+    mWeatherSel = Table( MSWeather( mWeather( mWeather.col("ANTENNA_ID") == -1 ) ) ) ;
     if ( mWeatherSel.nrow() == 0 ) {
       os_ << "No rows in WEATHER table" << LogIO::POST ;
     }
   }
-  ROMSWeatherColumns mWeatherCols( mWeatherSel ) ;
-  Int wnrow = mWeatherCols.nrow() ;
+  uInt wnrow = mWeatherSel.nrow() ;
   //os_ << "wnrow = " << wnrow << LogIO::POST ;
 
@@ -1078 +1217 @@
   wtab.addRow( wnrow ) ;
 
-  ScalarColumn<Float> tempCol( wtab, "TEMPERATURE" ) ;
-  tempCol.putColumn( mWeatherCols.temperature() ) ;
-  ScalarColumn<Float> pressCol( wtab, "PRESSURE" ) ;
-  pressCol.putColumn( mWeatherCols.pressure() ) ;
-  ScalarColumn<Float> humCol( wtab, "HUMIDITY" ) ;
-  humCol.putColumn( mWeatherCols.relHumidity() ) ;
-  ScalarColumn<Float> windVelCol( wtab, "WINDSPEED" ) ;
-  windVelCol.putColumn( mWeatherCols.windSpeed() ) ;
-  ScalarColumn<Float> windDirCol( wtab, "WINDAZ" ) ;
-  windDirCol.putColumn( mWeatherCols.windDirection() ) ;
-  Vector<uInt> ids( wnrow ) ;
-  indgen( ids ) ;
+  ScalarColumn<Float> *fCol ;
+  ROScalarColumn<Float> *sharedFloatCol ;
+  if ( mWeatherSel.tableDesc().isColumn( "TEMPERATURE" ) ) {
+    fCol = new ScalarColumn<Float>( wtab, "TEMPERATURE" ) ;
+    sharedFloatCol = new ROScalarColumn<Float>( mWeatherSel, "TEMPERATURE" ) ;
+    fCol->putColumn( *sharedFloatCol ) ;
+    delete sharedFloatCol ;
+    delete fCol ;
+  }
+  if ( mWeatherSel.tableDesc().isColumn( "PRESSURE" ) ) {
+    fCol = new ScalarColumn<Float>( wtab, "PRESSURE" ) ;
+    sharedFloatCol = new ROScalarColumn<Float>( mWeatherSel, "PRESSURE" ) ;
+    fCol->putColumn( *sharedFloatCol ) ;
+    delete sharedFloatCol ;
+    delete fCol ;
+  }
+  if ( mWeatherSel.tableDesc().isColumn( "REL_HUMIDITY" ) ) {
+    fCol = new ScalarColumn<Float>( wtab, "HUMIDITY" ) ;
+    sharedFloatCol = new ROScalarColumn<Float>( mWeatherSel, "REL_HUMIDITY" ) ;
+    fCol->putColumn( *sharedFloatCol ) ;
+    delete sharedFloatCol ;
+    delete fCol ;
+  }
+  if ( mWeatherSel.tableDesc().isColumn( "WIND_SPEED" ) ) {  
+    fCol = new ScalarColumn<Float>( wtab, "WINDSPEED" ) ;
+    sharedFloatCol = new ROScalarColumn<Float>( mWeatherSel, "WIND_SPEED" ) ;
+    fCol->putColumn( *sharedFloatCol ) ;
+    delete sharedFloatCol ;
+    delete fCol ;
+  }
+  if ( mWeatherSel.tableDesc().isColumn( "WIND_DIRECTION" ) ) {
+    fCol = new ScalarColumn<Float>( wtab, "WINDAZ" ) ;
+    sharedFloatCol = new ROScalarColumn<Float>( mWeatherSel, "WIND_DIRECTION" ) ;
+    fCol->putColumn( *sharedFloatCol ) ;
+    delete sharedFloatCol ;
+    delete fCol ;
+  }
   ScalarColumn<uInt> idCol( wtab, "ID" ) ;
-  idCol.putColumn( ids ) ;
-
-  String tUnit = mWeatherCols.timeQuant().getUnits() ;
-  mwTime_ = mWeatherCols.time().getColumn() ;
+  for ( uInt irow = 0 ; irow < wnrow ; irow++ ) 
+    idCol.put( irow, irow ) ;
+
+  ROScalarQuantColumn<Double> tqCol( mWeatherSel, "TIME" ) ;
+  ROScalarColumn<Double> tCol( mWeatherSel, "TIME" ) ;
+  String tUnit = tqCol.getUnits() ;
+  mwTime_ = tCol.getColumn() ;
   if ( tUnit == "d" ) 
     mwTime_ *= 86400.0 ;
-  String iUnit = mWeatherCols.intervalQuant().getUnits() ;
-  mwInterval_ = mWeatherCols.interval().getColumn() ;
+  tqCol.attach( mWeatherSel, "INTERVAL" ) ;
+  tCol.attach( mWeatherSel, "INTERVAL" ) ;
+  String iUnit = tqCol.getUnits() ;
+  mwInterval_ = tCol.getColumn() ;
   if ( iUnit == "d" ) 
     mwInterval_ *= 86400.0 ; 
   //os_ << "mwTime[0] = " << mwTime_[0] << " mwInterval[0] = " << mwInterval_[0] << LogIO::POST ; 
+  //os_ << "end MSFiller::fillWeather()" << LogIO::POST ;
 }
 
 void MSFiller::fillFocus()
 {
+  //os_ << "start MSFiller::fillFocus()" << LogIO::POST ;
   // tentative
   Table tab = table_->focus().table() ;
@@ -1111 +1282 @@
   ScalarColumn<uInt> idCol( tab, "ID" ) ;
   idCol.put( 0, 0 ) ;
+  //os_ << "end MSFiller::fillFocus()" << LogIO::POST ;
 }
 
-void MSFiller::fillTcal()
+void MSFiller::fillTcal( boost::object_pool<ROTableColumn> *tpool )
 {
-  MSSysCal sctab = mstable_.sysCal() ;
+  //os_ << "start MSFiller::fillTcal()" << LogIO::POST ;
+
+  //MSSysCal sctab = mstable_.sysCal() ;
+  Table sctab = mstable_.sysCal() ;
   if ( sctab.nrow() == 0 ) {
     os_ << "No SysCal rows" << LogIO::POST ;
@@ -1121 +1296 @@
   } 
   Bool isSp = sctab.tableDesc().isColumn( "TCAL_SPECTRUM" ) ;
-  MSSysCal sctabsel( sctab( sctab.col("ANTENNA_ID") == antenna_ ) ) ;
+  //MSSysCal sctabsel =  sctab( sctab.col("ANTENNA_ID") == antenna_ ) ;
+  //Table sctabsel =  sctab( sctab.col("ANTENNA_ID") == antenna_ ) ;
+  Table sctabsel( sctab( sctab.col("ANTENNA_ID") == antenna_ ) ) ;
   if ( sctabsel.nrow() == 0 ) {
     os_ << "No SysCal rows" << LogIO::POST ;
     return ;
   } 
-  ROArrayColumn<Float> tmpTcalCol( sctabsel, "TCAL" ) ;
-  uInt npol = tmpTcalCol.shape( 0 )(0) ;
+  ROArrayColumn<Float> *tmpTcalCol = new ROArrayColumn<Float>( sctabsel, "TCAL" ) ;
+  uInt npol = tmpTcalCol->shape( 0 )(0) ;
+  delete tmpTcalCol ;
   //os_ << "fillTcal(): npol = " << npol << LogIO::POST ;
   Table tab = table_->tcal().table() ;
@@ -1133 +1311 @@
   ScalarColumn<String> timeCol( tab, "TIME" ) ;
   ArrayColumn<Float> tcalCol( tab, "TCAL" ) ;
+  ROTableColumn *sharedCol ;
   uInt oldnr = 0 ;
   uInt newnr = 0 ;
   TableIterator iter0( sctabsel, "FEED_ID" ) ;
-  // Record for TCAL_ID
-  // "FIELD0": "SPW0": Vector<uInt>
-  //           "SPW1": Vector<uInt>
-  //  ...
   while( !iter0.pastEnd() ) {
-    MSSysCal t0( iter0.table() ) ;
-    ROScalarColumn<Int> feedIdCol( t0, "FEED_ID" ) ;
-    Int feedId = feedIdCol( 0 ) ;
+    Table t0 = iter0.table() ;
+    sharedCol = tpool->construct( t0, "FEED_ID" ) ;
+    Int feedId = sharedCol->asInt( 0 ) ;
+    tpool->destroy( sharedCol ) ;
     String ffield = "FEED" + String::toString( feedId ) ;
     Record rec ;
@@ -1150 +1326 @@
       MSSysCal t1( iter1.table().sort("TIME") ) ;
       uInt nrow = t1.nrow() ;
-      ROMSSysCalColumns scCols( t1 ) ;
-      Int spwId = scCols.spectralWindowId()(0) ;
+      sharedCol = tpool->construct( t1, "SPECTRAL_WINDOW_ID" ) ;
+      Int spwId = sharedCol->asInt( 0 ) ;
+      tpool->destroy( sharedCol ) ;
       String spwfield = "SPW" + String::toString( spwId ) ;
-      ROScalarQuantColumn<Double> scTimeCol = scCols.timeQuant() ;
+      ROScalarQuantColumn<Double> scTimeCol( t1, "TIME" ) ;
       ROArrayColumn<Float> scTcalCol ;
       IPosition newShape( 2, 1, nrow ) ;
       if ( isSp ) {
-        scTcalCol.reference( scCols.tcalSpectrum() ) ;
+        scTcalCol.attach( t1, "TCAL_SPECTRUM" ) ;
         newShape[0] = scTcalCol.shape(0)(1) ;
       }
       else {
-        scTcalCol.reference( scCols.tcal() ) ;
+        scTcalCol.attach( t1, "TCAL" ) ;
       }
-      Vector<uInt> idx( nrow ) ;
-      Vector<String> sTime( nrow ) ;
+      tab.addRow( nrow*npol ) ;
+      newnr += nrow*npol ;
       for ( uInt irow = 0 ; irow < nrow ; irow++ ) {
-        sTime[irow] = MVTime( scTimeCol(irow) ).string(MVTime::YMD) ;
+        String sTime = MVTime( scTimeCol(irow) ).string( MVTime::YMD ) ;
+        for ( uInt ipol = 0 ; ipol < npol ; ipol++ ) {
+          timeCol.put( oldnr+irow+ipol*nrow, sTime ) ;
+        }
+      }
+      uInt idx = oldnr ;
+      for ( uInt ipol = 0 ; ipol < npol ; ipol++ ) {
+        for ( uInt irow = 0 ; irow < nrow ; irow++ ) {
+          idCol.put( oldnr+ipol*nrow+irow, idx++ ) ;
+        }
       }
       Vector<uInt> idminmax( 2, oldnr ) ;
-      for ( uInt ipol = 0 ; ipol < npol ; ipol++ ) {
-        tab.addRow( nrow ) ;
-        newnr += nrow ;
-        RefRows rows( oldnr, newnr-1 ) ;
-        indgen( idx, oldnr ) ;
-        idCol.putColumnCells( rows, idx ) ;
-        timeCol.putColumnCells( rows, sTime ) ;
-        Slicer slicer ;
-        if ( isSp ) {
-          Slice paxis( ipol, 1, 1 ) ;
-          Slice caxis( 0, newShape[0], 1 ) ;
-          slicer = Slicer( paxis, caxis ) ;
+      for ( uInt irow = 0 ; irow < nrow ; irow++ ) {
+        Matrix<Float> subtcal = scTcalCol( irow ) ;
+        for ( uInt ipol = 0 ; ipol < npol ; ipol++ ) {
+          tcalCol.put( oldnr+ipol*nrow+irow, subtcal.row( ipol ) ) ;
         }
-        else {
-          Slice paxis( ipol, 1, 1 ) ;
-          slicer = Slicer( paxis ) ;
-        }
-        Array<Float> subtcal = scTcalCol.getColumn( slicer ).reform( newShape ) ;
-        tcalCol.putColumnCells( rows, subtcal ) ;
-        oldnr += nrow ;
       }
       idminmax[1] = newnr - 1 ;
+      oldnr = newnr ;
       rec.define( spwfield, idminmax ) ;
       iter1++ ;
@@ -1198 +1370 @@
   }
 
+
   //tcalrec_.print( std::cout ) ;
+  //os_ << "end MSFiller::fillFocus()" << LogIO::POST ;
 }
-
-// void MSFiller::fillMolecules()
-// {
-//   os_ << "MSFiller::fillMolecules()" << LogIO::POST ;
-//   // tentative
-//   Table tab = table_->molecules().table() ;
-//   tab.addRow( 1 ) ;
-//   ScalarColumn<uInt> idCol( tab, "ID" ) ;
-//   idCol.put( 0, 0 ) ;
-// }
-
-// void MSFiller::fillFit()
-// {
-//   os_ << "MSFiller::fillFit()" << LogIO::POST ;
-//   // tentative
-//   Table tab = table_->fit().table() ;
-//   tab.addRow( 1 ) ;
-//   ScalarColumn<uInt> idCol( tab, "ID" ) ;
-//   idCol.put( 0, 0 ) ;
-// }
-
-// void MSFiller::fillFrequencies()
-// {
-//   os_ << "MSFiller::fillFrequencies()" << LogIO::POST ;
-//   // tentative
-//   Table tab = table_->frequencies().table() ;
-//   tab.addRow( 1 ) ;
-//   ScalarColumn<uInt> idCol( tab, "ID" ) ;
-//   idCol.put( 0, 0 ) ;
-// }
-
-// void MSFiller::fillHistory()
-// {
-//   os_ << "MSFiller::fillHistory()" << LogIO::POST ;
-//   // tentative
-//   Table tab = table_->history().table() ;
-//   tab.addRow( 1 ) ;
-//   ScalarColumn<uInt> idCol( tab, "ID" ) ;
-//   idCol.put( 0, 0 ) ;
-// }
 
 uInt MSFiller::getWeatherId( uInt idx, Double wtime ) 
 {
+  //os_ << "start MSFiller::getWeatherId()" << LogIO::POST ;
   uInt nrow = mwTime_.size() ;
   if ( nrow == 0 ) 
@@ -1271 +1406 @@
   //os_ << LogIO::WARN << "Couldn't find correct WEATHER_ID for time " << wtime << LogIO::POST ;
 
+  //os_ << "end MSFiller::getWeatherId()" << LogIO::POST ;
   return wid ;
 }
@@ -1276 +1412 @@
 Vector<Double> MSFiller::getSysCalTime( MSSysCal &tab, MEpoch::ROScalarColumn &tcol )
 {
+  //os_ << "start MSFiller::getSysCalTime()" << LogIO::POST ;
   uInt nrow = tcol.table().nrow() ;
   Vector<Double> tstr( nrow, -1.0 ) ;
@@ -1281 +1418 @@
     return tstr ;
   uInt scnrow = tab.nrow() ;
-  ROMSSysCalColumns sysCalCols( tab ) ;
-  ROScalarMeasColumn<MEpoch> scTimeCol = sysCalCols.timeMeas() ;
-  ROScalarQuantColumn<Double> scIntervalCol = sysCalCols.intervalQuant() ;
+  ROScalarMeasColumn<MEpoch> scTimeCol( tab, "TIME" ) ;
+  ROScalarQuantColumn<Double> scIntervalCol( tab, "INTERVAL" ) ;
   uInt idx = 0 ;
   const Double half = 0.5e0 ;
@@ -1306 +1442 @@
     }
   }
+  //os_ << "end MSFiller::getSysCalTime()" << LogIO::POST ;
   return tstr ;
 }
 
-uInt MSFiller::getTsys( uInt idx, Array<Float> &tsys, MSSysCal &tab, Double t )
+uInt MSFiller::getTsys( uInt idx, Matrix<Float> &tsys, MSSysCal &tab, Double t )
 {
+  //os_ << "start MSFiller::getTsys()" << LogIO::POST ;
   uInt nrow = tab.nrow() ;
   if ( nrow == 0 ) {
@@ -1318 +1456 @@
   }
   Bool isSp = tab.tableDesc().isColumn( "TSYS_SPECTRUM" ) ;
-  ROMSSysCalColumns calCols( tab ) ;
-  ROScalarMeasColumn<MEpoch> scTimeCol = calCols.timeMeas() ;
+  ROScalarMeasColumn<MEpoch> scTimeCol( tab, "TIME" ) ;
   ROArrayColumn<Float> mTsysCol ;
   if ( isSp ) {
-    mTsysCol.reference( calCols.tsysSpectrum() ) ;
+    mTsysCol.attach( tab, "TSYS_SPECTRUM" ) ;
   }
   else {
-    mTsysCol.reference( calCols.tsys() ) ;
+    mTsysCol.attach( tab, "TSYS" ) ;
   }
   for ( uInt i = idx ; i < nrow ; i++ ) {
@@ -1335 +1472 @@
     }
   }
+  //os_ << "MSFiller::getTsys() idx = " << idx << " tsys = " << tsys << LogIO::POST ;
+  //os_ << "end MSFiller::getTsys()" << LogIO::POST ;
   return idx ;
 }
@@ -1340 +1479 @@
 Vector<uInt> MSFiller::getTcalId( Int fid, Int spwid, Double t ) 
 {
+  //os_ << "start MSFiller::getTcalId()" << LogIO::POST ;
   String feed = "FEED" + String::toString(fid) ;
   String spw = "SPW" + String::toString(spwid) ;
@@ -1350 +1490 @@
   }
   Vector<uInt> ids = tcalrec_.asRecord(feed).asArrayuInt(spw) ;
-  Table ttabsel = ttab( ttab.col("TIME") == sctime && ttab.col("ID") >= ids[0] && ttab.col("ID") <= ids[1] ).sort("ID") ;
+  //Table ttabsel = ttab( ttab.col("TIME") == sctime && ttab.col("ID") >= ids[0] && ttab.col("ID") <= ids[1] ).sort("ID") ;
+  Table ttabsel( ttab( ttab.col("TIME") == sctime && ttab.col("ID") >= ids[0] && ttab.col("ID") <= ids[1] ).sort("ID")) ;
   uInt nrow = ttabsel.nrow() ;
   Vector<uInt> tcalids( nrow ) ;
@@ -1372 +1513 @@
   }
   
+  //os_ << "end MSFiller::getTcalId()" << LogIO::POST ;
   return tcalids ;
 }
 
-uInt MSFiller::getDirection( uInt idx, Vector<Double> &dir, Vector<Double> &srate, String &ref, ROMSPointingColumns &cols, Double t ) 
+uInt MSFiller::getDirection( uInt idx, Vector<Double> &dir, Vector<Double> &srate, String &ref, MSPointing &tab, Double t ) 
 {
+  //os_ << "start MSFiller::getDirection()" << LogIO::POST ;
   // assume that cols is sorted by TIME
   Bool doInterp = False ;
-  uInt nrow = cols.nrow() ;
+  //uInt nrow = cols.nrow() ;
+  uInt nrow = tab.nrow() ;
   if ( nrow == 0 ) 
     return 0 ;
-  ROScalarMeasColumn<MEpoch> tcol = cols.timeMeas() ;
-  ROArrayMeasColumn<MDirection> dmcol = cols.directionMeasCol() ;
-  ROArrayColumn<Double> dcol = cols.direction() ;
+  ROScalarMeasColumn<MEpoch> tcol( tab, "TIME" ) ;
+  ROArrayMeasColumn<MDirection> dmcol( tab, "DIRECTION" ) ;
+  ROArrayColumn<Double> dcol( tab, "DIRECTION" ) ;
   // ensure that tcol(idx) < t
   //os_ << "tcol(idx) = " << tcol(idx).get("s").getValue() << " t = " << t << " diff = " << tcol(idx).get("s").getValue()-t << endl ;
@@ -1414 +1558 @@
   //os_ << "searched idx = " << idx << LogIO::POST ;
 
-  Slice ds( 0, 2, 1 ) ;
-  Slice ds0( 0, 1, 1 ) ;
-  Slice ds1( 1, 1, 1 ) ;
-  Slicer dslice0( ds, ds0 ) ;
-  Slicer dslice1( ds, ds1 ) ;
   //os_ << "dmcol(idx).shape() = " << dmcol(idx).shape() << LogIO::POST ;
   IPosition ip( dmcol(idx).shape().nelements(), 0 ) ;
@@ -1424 +1563 @@
   ref = dmcol(idx)(ip).getRefString() ;
   //os_ << "ref = " << ref << LogIO::POST ;
-  IPosition outp(1,2) ;
   if ( doInterp ) {
     //os_ << "do interpolation" << LogIO::POST ;
@@ -1430 +1568 @@
     Double tref0 = tcol(idx).get("s").getValue() ;
     Double tref1 = tcol(idx+1).get("s").getValue() ;
-    Vector<Double> dir0 = dcol(idx)(dslice0).reform(outp) ;
+    Matrix<Double> mdir0 = dcol( idx ) ;
+    Matrix<Double> mdir1 = dcol( idx+1 ) ;
+    Vector<Double> dir0 = mdir0.column( 0 ) ;
     //os_ << "dir0 = " << dir0 << LogIO::POST ; 
-    Vector<Double> dir1 = dcol(idx+1)(dslice0).reform(outp) ;
+    Vector<Double> dir1 = mdir1.column( 0 ) ;
     //os_ << "dir1 = " << dir1 << LogIO::POST ; 
     Double dt0 = t - tref0 ;
     Double dt1 = tref1 - t ;
     dir.reference( (dt0*dir1+dt1*dir0)/(dt0+dt1) ) ;
-    if ( dcol(idx).shape()(1) > 1 ) {
-      if ( dt0 >= dt1 ) {
-        srate.reference( dcol(idx)(dslice1).reform(outp) ) ;
-      }
-      else {
-        srate.reference( dcol(idx+1)(dslice1) ) ;
-      }
+    if ( mdir0.ncolumn() > 1 ) {
+      if ( dt0 >= dt1 )
+        srate.reference( mdir0.column( 1 ) ) ;
+      else
+        srate.reference( mdir1.column( 1 ) ) ;
     }
     //os_ << "dir = " << dir << LogIO::POST ; 
@@ -1449 +1587 @@
   else {
     //os_ << "no interpolation" << LogIO::POST ;
-    dir.reference( dcol(idx)(dslice0).reform(outp) ) ;
-    if ( dcol(idx).shape()(1) > 1 ) {
-      srate.reference( dcol(idx)(dslice1).reform(outp) ) ;
-    }
-  }
-
+    Matrix<Double> mdir0 = dcol( idx ) ;
+    dir.reference( mdir0.column( 0 ) ) ;
+    if ( mdir0.ncolumn() > 1 )
+      srate.reference( mdir0.column( 1 ) ) ;
+  }
+
+  //os_ << "end MSFiller::getDirection()" << LogIO::POST ;
   return idx ;
 }

trunk/src/MSFiller.h

@@ -16 +16 @@
 // STL
 #include <string>
+
+// Boost
+#include <boost/pool/object_pool.hpp>
+
 // AIPS++
 #include <casa/aips.h>
 #include <casa/Utilities/CountedPtr.h>
 #include <casa/Arrays/Vector.h>
+#include <casa/Arrays/Matrix.h>
 #include <casa/Logging/LogIO.h>
 
 #include <casa/Containers/Record.h>
-#include <tables/Tables/RefRows.h>
+
+//#include <tables/Tables/TableColumn.h>
 
 #include <ms/MeasurementSets/MeasurementSet.h>
-#include <ms/MeasurementSets/MSColumns.h>
+#include <ms/MeasurementSets/MSPointing.h>
 
 #include "Scantable.h"
@@ -59 +65 @@
   //void fillHistory() ;
   //void fillFit() ;
-  void fillTcal() ;
-
-  // fill ID columns
-  void fillId( casa::uInt idx, const char *colname, casa::RefRows &rows ) ; 
-  void fillId( casa::Int idx, const char *colname, casa::RefRows &rows ) ; 
+  void fillTcal( boost::object_pool<casa::ROTableColumn> *pool ) ;
 
   // get SRCTYPE from STATE_ID
-  casa::Int getSrcType( casa::Int stateId ) ;
+  casa::Int getSrcType( casa::Int stateId, boost::object_pool<casa::ROTableColumn> *pool ) ;
+  //casa::Int getSrcType( casa::Int stateId ) ;
 
   // get POLNO from CORR_TYPE
@@ -85 +88 @@
   // assume that tab is selected by ANTENNA_ID, FEED_ID, SPECTRAL_WINDOW_ID 
   // and sorted by TIME
-  casa::uInt getTsys( casa::uInt idx, casa::Array<casa::Float> &tsys, casa::MSSysCal &tab, casa::Double t ) ;
+  casa::uInt getTsys( casa::uInt idx, casa::Matrix<casa::Float> &tsys, casa::MSSysCal &tab, casa::Double t ) ;
 
   // get TCAL_ID 
@@ -91 +94 @@
 
   // get direction for DIRECTION, AZIMUTH, and ELEVATION columns
-  casa::uInt getDirection( casa::uInt idx, casa::Vector<casa::Double> &dir, casa::Vector<casa::Double> &srate, casa::String &ref, casa::ROMSPointingColumns &cols, casa::Double t ) ;
+  casa::uInt getDirection( casa::uInt idx, casa::Vector<casa::Double> &dir, casa::Vector<casa::Double> &srate, casa::String &ref, casa::MSPointing &tab, casa::Double t ) ;
   
   casa::CountedPtr<Scantable> table_ ;
   casa::MeasurementSet mstable_ ;
-  casa::MeasurementSet tablesel_ ;
+  casa::String tablename_ ;
   casa::Int antenna_ ;
   casa::Bool getPt_ ;
@@ -115 +118 @@
   casa::Vector<casa::Double> mwInterval_ ;
 
+  // Record for TCAL_ID
+  // "FIELD0": "SPW0": Vector<uInt>
+  //           "SPW1": Vector<uInt>
+  //  ...
   casa::Record tcalrec_ ;
+
+  //casa::ROTableColumn *scCol_ ;
 };
 

trunk/src/MSWriter.cpp

@@ -358 +358 @@
         
         // SCAN_NUMBER
+        // MS: 1-based
+        // Scantable: 0-based
         RefRows rows3( current3, current3+added3-1 ) ;
-        Vector<Int> scanNum( added3, scanNo ) ;
+        Vector<Int> scanNum( added3, scanNo+1 ) ;
         ScalarColumn<Int> scanNumCol( *mstable_, "SCAN_NUMBER" ) ;
         scanNumCol.putColumnCells( rows3, scanNum ) ;

trunk/src/Scantable.cpp

@@ -1267 +1267 @@
   String out;
   table_.keywordSet().get("AntennaName", out);
+  String::size_type pos1 = out.find("@") ;
+  String::size_type pos2 = out.find("//") ;
+  if ( pos2 != String::npos ) 
+    out = out.substr(pos2+2,pos1) ;
+  else if ( pos1 != String::npos )
+    out = out.substr(0,pos1) ;
   return out;
 }