Changeset 2291

Timestamp:

09/12/11 12:07:41 (13 years ago)

Author:

Takeshi Nakazato

Message:

New Development: No

JIRA Issue: No

Ready for Test: Yes

Interface Changes: Yes

What Interface Changed: MSFillerUtils and MSWriterUtils added

Test Programs: sd regressions, test_sdsave

Put in Release Notes: No

Module(s): Module Names change impacts.

Description: Describe your changes here...

Rewrote MSFiller and MSWriter based on TableTraverse.
TableTraverse is changed a bit since it doesn't work on plain table.

Location:

trunk/src

Files:

• MSFiller.cpp (modified) (22 diffs)
• MSFiller.h (modified) (4 diffs)
• MSWriter.cpp (modified) (17 diffs)
• MSWriter.h (modified) (5 diffs)
• TableTraverse.cpp (modified) (1 diff)

trunk/src/MSFiller.cpp

@@ +1 @@
+
 //
 // C++ Interface: MSFiller
@@ -4 +5 @@
 // Description:
 //
-// This class is specific filler for MS format
+// This class is specific filler for MS format 
+// New version that is implemented using TableVisitor instead of TableIterator
 //
-// Takeshi Nakazato <takeshi.nakazato@nao.ac.jp>, (C) 2010
+// Takeshi Nakazato <takeshi.nakazato@nao.ac.jp>, (C) 2011
 //
 // Copyright: See COPYING file that comes with this distribution
@@ -12 +14 @@
 //
 
+#include <assert.h>
 #include <iostream>
 #include <map>
@@ -51 +54 @@
 #include "STHeader.h" 
 
-// #include <ctime>
-// #include <sys/time.h>
-
 #include "MathUtils.h"
 
@@ -60 +60 @@
 
 namespace asap {
-// double MSFiller::gettimeofday_sec()
-// {
-//   struct timeval tv ;
-//   gettimeofday( &tv, NULL ) ;
-//   return tv.tv_sec + (double)tv.tv_usec*1.0e-6 ;
-// }
+
+class BaseMSFillerVisitor: public TableVisitor {
+  uInt lastRecordNo ;
+  Int lastObservationId ;
+  Int lastFeedId ;
+  Int lastFieldId ;
+  Int lastDataDescId ;
+  Int lastScanNo ;
+  Int lastStateId ;
+  Double lastTime ;
+protected:
+  const Table &table;
+  uInt count;
+public:
+  BaseMSFillerVisitor(const Table &table)
+   : table(table)
+  {
+    count = 0;
+  }
+  
+  virtual void enterObservationId(const uInt recordNo, Int columnValue) { }
+  virtual void leaveObservationId(const uInt recordNo, Int columnValue) { }
+  virtual void enterFeedId(const uInt recordNo, Int columnValue) { }
+  virtual void leaveFeedId(const uInt recordNo, Int columnValue) { }
+  virtual void enterFieldId(const uInt recordNo, Int columnValue) { }
+  virtual void leaveFieldId(const uInt recordNo, Int columnValue) { }
+  virtual void enterDataDescId(const uInt recordNo, Int columnValue) { }
+  virtual void leaveDataDescId(const uInt recordNo, Int columnValue) { }
+  virtual void enterScanNo(const uInt recordNo, Int columnValue) { }
+  virtual void leaveScanNo(const uInt recordNo, Int columnValue) { }
+  virtual void enterStateId(const uInt recordNo, Int columnValue) { }
+  virtual void leaveStateId(const uInt recordNo, Int columnValue) { }
+  virtual void enterTime(const uInt recordNo, Double columnValue) { }
+  virtual void leaveTime(const uInt recordNo, Double columnValue) { }
+
+  virtual Bool visitRecord(const uInt recordNo,
+                           const Int ObservationId,
+                           const Int feedId,
+                           const Int fieldId,
+                           const Int dataDescId,
+                           const Int scanNo,
+                           const Int stateId,
+                           const Double time) { return True ; }
+
+  virtual Bool visit(Bool isFirst, const uInt recordNo,
+                     const uInt nCols, void const *const colValues[]) {
+    Int observationId, feedId, fieldId, dataDescId, scanNo, stateId;
+    Double time;
+    { // prologue
+      uInt i = 0;
+      {
+        const Int *col = (const Int *)colValues[i++];
+        observationId = col[recordNo];
+      }
+      {
+        const Int *col = (const Int *)colValues[i++];
+        feedId = col[recordNo];
+      }
+      {
+        const Int *col = (const Int *)colValues[i++];
+        fieldId = col[recordNo];
+      }
+      {
+        const Int *col = (const Int *)colValues[i++];
+        dataDescId = col[recordNo];
+      }
+      {
+        const Int *col = (const Int *)colValues[i++];
+        scanNo = col[recordNo];
+      }
+      {
+        const Int *col = (const Int *)colValues[i++];
+        stateId = col[recordNo];
+      }
+      {
+        const Double *col = (const Double *)colValues[i++];
+        time = col[recordNo];
+      }
+      assert(nCols == i);
+    }
+
+    if (isFirst) {
+      enterObservationId(recordNo, observationId);
+      enterFeedId(recordNo, feedId);
+      enterFieldId(recordNo, fieldId);
+      enterDataDescId(recordNo, dataDescId);
+      enterScanNo(recordNo, scanNo);
+      enterStateId(recordNo, stateId);
+      enterTime(recordNo, time);
+    } else {
+      if (lastObservationId != observationId) {
+        leaveTime(lastRecordNo, lastTime);
+        leaveStateId(lastRecordNo, lastStateId);
+        leaveScanNo(lastRecordNo, lastScanNo);
+        leaveDataDescId(lastRecordNo, lastDataDescId);
+        leaveFieldId(lastRecordNo, lastFieldId);
+        leaveFeedId(lastRecordNo, lastFeedId);
+        leaveObservationId(lastRecordNo, lastObservationId);
+
+        enterObservationId(recordNo, observationId);
+        enterFeedId(recordNo, feedId);
+        enterFieldId(recordNo, fieldId);
+        enterDataDescId(recordNo, dataDescId);
+        enterScanNo(recordNo, scanNo);
+        enterStateId(recordNo, stateId);
+        enterTime(recordNo, time);
+      } else if (lastFeedId != feedId) {
+        leaveTime(lastRecordNo, lastTime);
+        leaveStateId(lastRecordNo, lastStateId);
+        leaveScanNo(lastRecordNo, lastScanNo);
+        leaveDataDescId(lastRecordNo, lastDataDescId);
+        leaveFieldId(lastRecordNo, lastFieldId);
+        leaveFeedId(lastRecordNo, lastFeedId);
+
+        enterFeedId(recordNo, feedId);
+        enterFieldId(recordNo, fieldId);
+        enterDataDescId(recordNo, dataDescId);
+        enterScanNo(recordNo, scanNo);
+        enterStateId(recordNo, stateId);
+        enterTime(recordNo, time);
+      } else if (lastFieldId != fieldId) {
+        leaveTime(lastRecordNo, lastTime);
+        leaveStateId(lastRecordNo, lastStateId);
+        leaveScanNo(lastRecordNo, lastScanNo);
+        leaveDataDescId(lastRecordNo, lastDataDescId);
+        leaveFieldId(lastRecordNo, lastFieldId);
+
+        enterFieldId(recordNo, fieldId);
+        enterDataDescId(recordNo, dataDescId);
+        enterScanNo(recordNo, scanNo);
+        enterStateId(recordNo, stateId);
+        enterTime(recordNo, time);
+      } else if (lastDataDescId != dataDescId) {
+        leaveTime(lastRecordNo, lastTime);
+        leaveStateId(lastRecordNo, lastStateId);
+        leaveScanNo(lastRecordNo, lastScanNo);
+        leaveDataDescId(lastRecordNo, lastDataDescId);
+
+        enterDataDescId(recordNo, dataDescId);
+        enterScanNo(recordNo, scanNo);
+        enterStateId(recordNo, stateId);
+        enterTime(recordNo, time);
+      } else if (lastScanNo != scanNo) {
+        leaveTime(lastRecordNo, lastTime);
+        leaveStateId(lastRecordNo, lastStateId);
+        leaveScanNo(lastRecordNo, lastScanNo);
+
+        enterScanNo(recordNo, scanNo);
+        enterStateId(recordNo, stateId);
+        enterTime(recordNo, time);
+      } else if (lastStateId != stateId) {
+        leaveTime(lastRecordNo, lastTime);
+        leaveStateId(lastRecordNo, lastStateId);
+
+        enterStateId(recordNo, stateId);
+        enterTime(recordNo, time);
+      } else if (lastTime != time) {
+        leaveTime(lastRecordNo, lastTime);
+        enterTime(recordNo, time);
+      }
+    }
+    count++;
+    Bool result = visitRecord(recordNo, observationId, feedId, fieldId, dataDescId,
+                              scanNo, stateId, time);
+
+    { // epilogue
+      lastRecordNo = recordNo;
+
+      lastObservationId = observationId;
+      lastFeedId = feedId;
+      lastFieldId = fieldId;
+      lastDataDescId = dataDescId;
+      lastScanNo = scanNo;
+      lastStateId = stateId;
+      lastTime = time;
+    }
+    return result ;
+  }
+
+  virtual void finish() {
+    if (count > 0) {
+      leaveTime(lastRecordNo, lastTime);
+      leaveStateId(lastRecordNo, lastStateId);
+      leaveScanNo(lastRecordNo, lastScanNo);
+      leaveDataDescId(lastRecordNo, lastDataDescId);
+      leaveFieldId(lastRecordNo, lastFieldId);
+      leaveFeedId(lastRecordNo, lastFeedId);
+      leaveObservationId(lastRecordNo, lastObservationId);
+    }
+  }
+};
+
+class MSFillerVisitor: public BaseMSFillerVisitor, public MSFillerUtils {
+public:
+  MSFillerVisitor(const Table &from, Scantable &to)
+    : BaseMSFillerVisitor(from),
+      scantable( to )
+  { 
+    antennaId = 0 ;
+    rowidx = 0 ;
+    tablerow = TableRow( scantable.table() ) ;
+    feedEntry = Vector<Int>( 64, -1 ) ;
+    nbeam = 0 ;
+    ifmap.clear() ;
+    const TableDesc &desc = table.tableDesc() ;
+    if ( desc.isColumn( "DATA" ) )
+      dataColumnName = "DATA" ;
+    else if ( desc.isColumn( "FLOAT_DATA" ) )
+      dataColumnName = "FLOAT_DATA" ;
+    getpt = False ;
+    isWeather = False ;
+    isSysCal = False ;
+    cycleNo = 0 ;
+    numSysCalRow = 0 ;
+    header = scantable.getHeader() ;
+    fluxUnit( header.fluxunit ) ;
+
+    // MS subtables
+    const TableRecord &hdr = table.keywordSet();
+    obstab = hdr.asTable( "OBSERVATION" ) ;
+    sctab = hdr.asTable( "SYSCAL" ) ;
+    spwtab = hdr.asTable( "SPECTRAL_WINDOW" ) ;
+    statetab = hdr.asTable( "STATE" ) ;
+    ddtab = hdr.asTable( "DATA_DESCRIPTION" ) ;
+    poltab = hdr.asTable( "POLARIZATION" ) ;
+    fieldtab = hdr.asTable( "FIELD" ) ;
+    anttab = hdr.asTable( "ANTENNA" ) ;
+    srctab = hdr.asTable( "SOURCE" ) ;
+
+    // attach to columns
+    // MS MAIN
+    intervalCol.attach( table, "INTERVAL" ) ;
+    flagRowCol.attach( table, "FLAG_ROW" ) ;
+    flagCol.attach( table, "FLAG" ) ;
+    if ( dataColumnName.compare( "DATA" ) == 0 )
+      dataCol.attach( table, dataColumnName ) ;
+    else
+      floatDataCol.attach( table, dataColumnName ) ;
+
+    // set dummy epoch
+    mf.set( currentTime ) ;
+
+    // initialize dirType
+    dirType = MDirection::N_Types ;
+
+    //
+    // add rows to scantable
+    //
+    // number of polarization is up to 4
+    uInt addrow = table.nrow() * maxNumPol() ;
+    scantable.table().addRow( addrow ) ;
+
+    // attach to columns
+    // Scantable MAIN
+    TableRecord &r = tablerow.record() ;
+    timeRF.attachToRecord( r, "TIME" ) ;
+    intervalRF.attachToRecord( r, "INTERVAL" ) ;
+    directionRF.attachToRecord( r, "DIRECTION" ) ;
+    azimuthRF.attachToRecord( r, "AZIMUTH" ) ;
+    elevationRF.attachToRecord( r, "ELEVATION" ) ;
+    scanRateRF.attachToRecord( r, "SCANRATE" ) ;
+    weatherIdRF.attachToRecord( r, "WEATHER_ID" ) ;
+    cycleNoRF.attachToRecord( r, "CYCLENO" ) ;
+    flagRowRF.attachToRecord( r, "FLAGROW" ) ;
+    polNoRF.attachToRecord( r, "POLNO" ) ;
+    tcalIdRF.attachToRecord( r, "TCAL_ID" ) ;
+    spectraRF.attachToRecord( r, "SPECTRA" ) ;
+    flagtraRF.attachToRecord( r, "FLAGTRA" ) ;
+    tsysRF.attachToRecord( r, "TSYS" ) ;
+    beamNoRF.attachToRecord( r, "BEAMNO" ) ;
+    ifNoRF.attachToRecord( r, "IFNO" ) ;
+    freqIdRF.attachToRecord( r, "FREQ_ID" ) ;
+    moleculeIdRF.attachToRecord( r, "MOLECULE_ID" ) ;
+    sourceNameRF.attachToRecord( r, "SRCNAME" ) ;
+    sourceProperMotionRF.attachToRecord( r, "SRCPROPERMOTION" ) ;
+    sourceDirectionRF.attachToRecord( r, "SRCDIRECTION" ) ;
+    sourceVelocityRF.attachToRecord( r, "SRCVELOCITY" ) ;
+    focusIdRF.attachToRecord( r, "FOCUS_ID" ) ;
+    fieldNameRF.attachToRecord( r, "FIELDNAME" ) ;
+    sourceTypeRF.attachToRecord( r, "SRCTYPE" ) ;
+    scanNoRF.attachToRecord( r, "SCANNO" ) ;
+
+    // put values
+    RecordFieldPtr<Int> refBeamNoRF( r, "REFBEAMNO" ) ;
+    *refBeamNoRF = -1 ;
+    RecordFieldPtr<Int> fitIdRF( r, "FIT_ID" ) ;
+    *fitIdRF = -1 ;
+    RecordFieldPtr<Float> opacityRF( r, "OPACITY" ) ;
+    *opacityRF = 0.0 ;
+  }
+
+  virtual void enterObservationId(const uInt recordNo, Int columnValue) {
+    //printf("%u: ObservationId: %d\n", recordNo, columnValue);
+    // update header 
+    if ( header.observer.empty() ) 
+      getScalar( String("OBSERVER"), (uInt)columnValue, obstab, header.observer ) ;
+    if ( header.project.empty() )
+      getScalar( "PROJECT", (uInt)columnValue, obstab, header.project ) ;
+    if ( header.utc == 0.0 ) {
+      Vector<MEpoch> amp ;
+      getArrayMeas( "TIME_RANGE", (uInt)columnValue, obstab, amp ) ;
+      header.utc = amp[0].get( "d" ).getValue() ;
+    }
+    if ( header.antennaname.empty() )
+      getScalar( "TELESCOPE_NAME", (uInt)columnValue, obstab, header.antennaname ) ;
+  }
+  virtual void leaveObservationId(const uInt recordNo, Int columnValue) {
+    // update header
+    header.nbeam = max( header.nbeam, (Int)nbeam ) ;
+
+    nbeam = 0 ;
+    feedEntry = -1 ;
+  }
+  virtual void enterFeedId(const uInt recordNo, Int columnValue) {
+    //printf("%u: FeedId: %d\n", recordNo, columnValue);
+
+    // update feed entry
+    if ( allNE( feedEntry, columnValue ) ) {
+      feedEntry[nbeam] = columnValue ;
+      nbeam++ ;
+    }
+
+    // put values
+    *beamNoRF = (uInt)columnValue ;
+    *focusIdRF = (uInt)0 ;
+  }
+  virtual void leaveFeedId(const uInt recordNo, Int columnValue) {
+    Int nelem = (Int)feedEntry.nelements() ;
+    if ( nbeam > nelem ) {
+      feedEntry.resize( nelem+64, True ) ;
+      Slicer slice( IPosition( 1, nelem ), IPosition( 1, feedEntry.nelements()-1 ) ) ;
+      feedEntry( slice ) = -1 ;
+    }
+  }
+  virtual void enterFieldId(const uInt recordNo, Int columnValue) {
+    //printf("%u: FieldId: %d\n", recordNo, columnValue);
+    // update sourceId and fieldName
+    getScalar( "SOURCE_ID", (uInt)columnValue, fieldtab, sourceId ) ;
+    String fieldName ;
+    getScalar( "NAME", (uInt)columnValue, fieldtab, fieldName ) ; 
+    fieldName += "__" + String::toString( columnValue ) ;
+
+    // put values
+    *fieldNameRF = fieldName ;
+  }
+  virtual void leaveFieldId(const uInt recordNo, Int columnValue) {
+    sourceId = -1 ;
+  }
+  virtual void enterDataDescId(const uInt recordNo, Int columnValue) {
+    //printf("%u: DataDescId: %d\n", recordNo, columnValue);
+    // update polarization and spectral window ids
+    getScalar( "POLARIZATION_ID", (uInt)columnValue, ddtab, polId ) ;
+    getScalar( "SPECTRAL_WINDOW_ID", (uInt)columnValue, ddtab, spwId ) ;
+
+    // polarization setup
+    getScalar( "NUM_CORR", (uInt)polId, poltab, npol ) ;
+    Vector<Int> corrtype ;
+    getArray( "CORR_TYPE", (uInt)polId, poltab, corrtype ) ;
+    polnos = getPolNos( corrtype ) ; 
+    
+    // process SOURCE table
+    String sourceName ;
+    Vector<Double> sourcePM, restFreqs, sysVels ;
+    Vector<String> transition ;
+    processSource( sourceId, spwId, sourceName, sourceDir, sourcePM, 
+                   restFreqs, transition, sysVels ) ;
+
+    // spectral setup
+    uInt freqId ;
+    Double reffreq, bandwidth ;
+    String freqref ;
+    getScalar( "NUM_CHAN", (uInt)spwId, spwtab, nchan ) ;
+    Bool iswvr = (Bool)(nchan == 4) ;
+    map<Int,uInt>::iterator iter = ifmap.find( spwId ) ;
+    if ( iter == ifmap.end() ) {
+      MEpoch me ;
+      getScalarMeas( "TIME", recordNo, table, me ) ;
+      spectralSetup( spwId, me, antpos, sourceDir, 
+                     freqId, nchan, 
+                     freqref, reffreq, bandwidth ) ;
+      ifmap.insert( pair<Int,uInt>(spwId,freqId) ) ;
+    }
+    else {
+      freqId = iter->second ;
+    }
+    sp.resize( npol, nchan ) ;
+    fl.resize( npol, nchan ) ;
+
+
+    // molecular setup
+    STMolecules mtab = scantable.molecules() ;
+    uInt molId = mtab.addEntry( restFreqs, transition, transition ) ;
+
+    // process SYSCAL table
+    if ( isSysCal )
+      processSysCal( spwId ) ;
+
+    // update header
+    if ( !iswvr ) {
+      header.nchan = max( header.nchan, nchan ) ;
+      header.bandwidth = max( header.bandwidth, bandwidth ) ;
+      if ( header.reffreq == -1.0 )
+        header.reffreq = reffreq ;
+      header.npol = max( header.npol, npol ) ;
+      if ( header.poltype.empty() )
+        header.poltype = getPolType( corrtype[0] ) ;
+      if ( header.freqref.empty() )
+        header.freqref = freqref ;
+    }
+    
+    // put values
+    *ifNoRF = (uInt)spwId ;
+    *freqIdRF = freqId ;
+    *moleculeIdRF = molId ;
+    *sourceNameRF = sourceName ;
+    sourceProperMotionRF.define( sourcePM ) ;
+    Vector<Double> srcD = sourceDir.getAngle().getValue( "rad" ) ;
+    sourceDirectionRF.define( srcD ) ;
+    if ( !sysVels.empty() ) 
+      *sourceVelocityRF = sysVels[0] ;
+    else {
+      *sourceVelocityRF = (Double)0.0 ;
+    }
+  }
+  virtual void leaveDataDescId(const uInt recordNo, Int columnValue) {
+    npol = 0 ;
+    nchan = 0 ;
+    numSysCalRow = 0 ;
+  }
+  virtual void enterScanNo(const uInt recordNo, Int columnValue) {
+    //printf("%u: ScanNo: %d\n", recordNo, columnValue);
+    // put value
+    // scan number is 1-based in MS while 0-based in Scantable
+    *scanNoRF = (uInt)columnValue - 1 ;
+  }
+  virtual void leaveScanNo(const uInt recordNo, Int columnValue) {
+    cycleNo = 0 ;
+  }
+  virtual void enterStateId(const uInt recordNo, Int columnValue) {
+    //printf("%u: StateId: %d\n", recordNo, columnValue);
+    // SRCTYPE
+    Int srcType = getSrcType( columnValue ) ;
+    
+    // update header
+    if ( header.obstype.empty() ) 
+      getScalar( "OBS_MODE", (uInt)columnValue, statetab, header.obstype ) ;
+
+    // put value
+    *sourceTypeRF = srcType ;
+  }
+  virtual void leaveStateId(const uInt recordNo, Int columnValue) { }
+  virtual void enterTime(const uInt recordNo, Double columnValue) {
+    //printf("%u: Time: %f\n", recordNo, columnValue);
+    currentTime = MEpoch( Quantity( columnValue, "s" ), MEpoch::UTC ) ;
+
+    // DIRECTION, AZEL, and SCANRATE
+    Vector<Double> direction, azel ;
+    Vector<Double> scanrate( 2, 0.0 ) ;
+    if ( getpt )
+      getDirection( direction, azel, scanrate ) ;
+    else 
+      getSourceDirection( direction, azel, scanrate ) ;
+
+    // INTERVAL
+    Double interval = intervalCol.asdouble( recordNo ) ;
+
+    // WEATHER_ID
+    uInt wid = 0 ;
+    if ( isWeather ) 
+      wid = getWeatherId() ;
+
+    // put value
+    Double t = currentTime.get( "d" ).getValue() ;
+    *timeRF = t ;
+    *intervalRF = interval ;
+    directionRF.define( direction ) ;
+    *azimuthRF = (Float)azel[0] ;
+    *elevationRF = (Float)azel[1] ;
+    scanRateRF.define( scanrate ) ;
+    *weatherIdRF = wid ;
+  }
+  virtual void leaveTime(const uInt recordNo, Double columnValue) { }
+  virtual Bool visitRecord(const uInt recordNo,
+                           const Int observationId,
+                           const Int feedId,
+                           const Int fieldId,
+                           const Int dataDescId,
+                           const Int scanNo,
+                           const Int stateId,
+                           const Double time)
+  {
+    //printf("%u: %d, %d, %d, %d, %d, %d, %f\n", recordNo,
+    //observationId, feedId, fieldId, dataDescId, scanNo, stateId, time);
+
+    // SPECTRA and FLAGTRA
+    //Matrix<Float> sp;
+    //Matrix<uChar> fl;
+    spectraAndFlagtra( recordNo, sp, fl ) ;
+
+    // FLAGROW
+    Bool flr = flagRowCol.asBool( recordNo ) ;
+
+    // TSYS
+    Matrix<Float> tsys ;
+    uInt scIdx = getSysCalIndex() ;
+    if ( numSysCalRow > 0 ) {
+      tsys = sysCalTsysCol( syscalRow[scIdx] ) ;
+    }
+    else {
+      tsys.resize( npol, 1 ) ;
+      tsys = 1.0 ;
+    }
+
+    // TCAL_ID
+    Block<uInt> tcalids( npol, 0 ) ;
+    if ( numSysCalRow > 0 ) {
+      tcalids = getTcalId( syscalTime[scIdx] ) ;
+    }
+
+    // put value
+    *cycleNoRF = cycleNo ;
+    *flagRowRF = (uInt)flr ;
+
+    // for each polarization component
+    for ( Int ipol = 0 ; ipol < npol ; ipol++ ) {
+      // put value depending on polarization component
+      *polNoRF = polnos[ipol] ;
+      *tcalIdRF = tcalids[ipol] ;
+      spectraRF.define( sp.row( ipol ) ) ;
+      flagtraRF.define( fl.row( ipol ) ) ;
+      tsysRF.define( tsys.row( ipol ) ) ;
+      
+      // commit row
+      tablerow.put( rowidx ) ;
+      rowidx++ ;
+    }
+
+    // increment CYCLENO
+    cycleNo++ ;
+
+    return True ;
+  }
+  virtual void finish()
+  {
+    BaseMSFillerVisitor::finish();
+    //printf("Total: %u\n", count);
+    // remove redundant rows
+    //cout << "filled " << rowidx << " rows out of " << scantable.nrow() << " rows" << endl ;
+    if ( scantable.nrow() > rowidx ) {
+      uInt numRemove = scantable.nrow() - rowidx ;
+      //cout << "numRemove = " << numRemove << endl ;
+      Vector<uInt> rows( numRemove ) ;
+      indgen( rows, rowidx ) ;
+      scantable.table().removeRow( rows ) ;
+    }
+    
+    // antenna name and station name
+    String antennaName ;
+    getScalar( "NAME", (uInt)antennaId, anttab, antennaName ) ;
+    String stationName ;
+    getScalar( "STATION", (uInt)antennaId, anttab, stationName ) ;
+
+    // update header
+    header.nif = ifmap.size() ;
+    header.antennaposition = antpos.get( "m" ).getValue() ;
+    if ( header.antennaname.empty() || header.antennaname == antennaName )
+      header.antennaname = antennaName ;
+    else 
+      header.antennaname += "//" + antennaName ;
+    if ( !stationName.empty() && stationName != antennaName )
+      header.antennaname += "@" + stationName ;
+    if ( header.fluxunit.empty() || header.fluxunit == "CNTS" )
+      header.fluxunit = "K" ;
+    header.epoch = "UTC" ;
+    header.equinox = 2000.0 ;
+    if (header.freqref == "TOPO") {
+      header.freqref = "TOPOCENT";
+    } else if (header.freqref == "GEO") {
+      header.freqref = "GEOCENTR";
+    } else if (header.freqref == "BARY") {
+      header.freqref = "BARYCENT";
+    } else if (header.freqref == "GALACTO") {
+      header.freqref = "GALACTOC";
+    } else if (header.freqref == "LGROUP") {
+      header.freqref = "LOCALGRP";
+    } else if (header.freqref == "CMB") {
+      header.freqref = "CMBDIPOL";
+    } else if (header.freqref == "REST") {
+      header.freqref = "SOURCE";
+    }
+    scantable.setHeader( header ) ;
+  }
+  void setAntenna( Int id )
+  { 
+    antennaId = id ; 
+
+    Vector< Quantum<Double> > pos ;
+    getArrayQuant( "POSITION", (uInt)antennaId, anttab, pos ) ;
+    antpos = MPosition( MVPosition( pos ), MPosition::ITRF ) ; 
+    mf.set( antpos ) ;
+  } 
+  void setPointingTable( const Table &tab, String columnToUse="DIRECTION" )
+  {
+    // input POINTING table must be
+    //  1) selected by antenna
+    //  2) sorted by TIME
+    ROScalarColumn<Double> tcol( tab, "TIME" ) ;
+    ROArrayColumn<Double> dcol( tab, columnToUse ) ;
+    tcol.getColumn( pointingTime ) ;
+    dcol.getColumn( pointingDirection ) ;
+    const TableRecord &rec = dcol.keywordSet() ;
+    String pointingRef = rec.asRecord( "MEASINFO" ).asString( "Ref" ) ;
+    MDirection::getType( dirType, pointingRef ) ;
+    getpt = True ;
+  }
+  void setWeatherTime( const Vector<Double> &t, const Vector<Double> &it )
+  {
+    isWeather = True ;
+    weatherTime = t ;
+    weatherInterval = it ;
+  }
+  void setSysCalRecord( const Record &r )
+  //void setSysCalRecord( const map< String,Vector<uInt> > &r )
+  {
+    isSysCal = True ;
+    syscalRecord = r ;
+
+    const TableDesc &desc = sctab.tableDesc() ;
+    uInt nrow = sctab.nrow() ;
+    syscalRow.resize( nrow ) ;
+    syscalTime.resize( nrow ) ;
+    syscalInterval.resize( nrow ) ;
+    String tsysCol = "NONE" ;
+    Vector<String> tsysCols = stringToVector( "TSYS_SPECTRUM,TSYS" ) ;
+    for ( uInt i = 0 ; i < tsysCols.nelements() ; i++ ) {
+      if ( tsysCol == "NONE" && desc.isColumn( tsysCols[i] ) )
+        tsysCol = tsysCols[i] ;
+    }
+    sysCalTsysCol.attach( sctab, tsysCol ) ;
+  }
+  STHeader getHeader() { return header ; }
+  uInt getNumBeam() { return nbeam ; }
+  uInt getFilledRowNum() { return rowidx ; }
+private:
+  void fluxUnit( String &u )
+  {
+    ROTableColumn col( table, dataColumnName ) ;
+    const TableRecord &rec = col.keywordSet() ;
+    if ( rec.isDefined( "UNIT" ) )
+      u = rec.asString( "UNIT" ) ;
+    else if ( rec.isDefined( "QuantumUnits" ) )
+      u = rec.asString( "QuantumUnits" ) ;
+    if ( u.empty() )
+      u = "K" ;
+  }
+  void processSource( Int sourceId, Int spwId,
+                      String &name, MDirection &dir, Vector<Double> &pm,
+                      Vector<Double> &rf, Vector<String> &trans, Vector<Double> &vel )
+  {
+    // find row
+    uInt nrow = srctab.nrow() ;
+    Int idx = -1 ;
+    ROTableRow row( srctab ) ;
+    for ( uInt irow = 0 ; irow < nrow ; irow++ ) {
+      const TableRecord &r = row.get( irow ) ;
+      if ( r.asInt( "SOURCE_ID" ) == sourceId ) {
+        Int tmpSpwId = r.asInt( "SPECTRAL_WINDOW_ID" ) ;
+        if ( tmpSpwId == spwId || tmpSpwId == -1 ) {
+          idx = (Int)irow ;
+          break ;
+        }
+      }
+    }
+
+    // fill
+    Int numLines = 0 ;
+    if ( idx != -1 ) {
+      const TableRecord &r = row.get( idx ) ;
+      name = r.asString( "NAME" ) ;
+      getScalarMeas( "DIRECTION", idx, srctab, dir ) ;
+      pm = r.toArrayDouble( "PROPER_MOTION" ) ;
+      numLines = r.asInt( "NUM_LINES" ) ;
+    }
+    else {
+      name = "" ;
+      pm = Vector<Double>( 2, 0.0 ) ;
+      dir = MDirection( Quantum<Double>(0.0,Unit("rad")), Quantum<Double>(0.0,Unit("rad")) ) ;
+    }
+    if ( !getpt ) {
+      String ref = dir.getRefString() ;
+      MDirection::getType( dirType, ref ) ;
+    }
+
+    rf.resize( numLines ) ;
+    trans.resize( numLines ) ;
+    vel.resize( numLines ) ;
+    if ( numLines > 0 ) {
+      Block<Bool> isDefined = row.getDefined() ;
+      Vector<String> colNames = row.columnNames() ;
+      Vector<Int> indexes( 3, -1 ) ;
+      Vector<String> cols = stringToVector( "REST_FREQUENCY,TRANSITION,SYSVEL" ) ;
+      for ( uInt icol = 0 ; icol < colNames.nelements() ; icol++ ) {
+        if ( anyEQ( indexes, -1 ) ) {
+          for ( uInt jcol = 0 ; jcol < cols.nelements() ; jcol++ ) {
+            if ( colNames[icol] == cols[jcol] )
+              indexes[jcol] = icol ;
+          }
+        }
+      }
+      if ( indexes[0] != -1 && isDefined[indexes[0]] == True ) {
+        Vector< Quantum<Double> > qrf ;
+        getArrayQuant( "REST_FREQUENCY", idx, srctab, qrf ) ;
+        for ( int i = 0 ; i < numLines ; i++ )
+          rf[i] = qrf[i].getValue( "Hz" ) ;
+      }
+      if ( indexes[1] != -1 && isDefined[indexes[1]] == True ) {
+        getArray( "TRANSITION", idx, srctab, trans ) ;
+      }
+      if ( indexes[2] != -1 && isDefined[indexes[2]] == True ) {
+        Vector< Quantum<Double> > qsv ;
+        getArrayQuant( "SYSVEL", idx, srctab, qsv ) ;
+        for ( int i = 0 ; i < numLines ; i++ )
+          vel[i] = qsv[i].getValue( "m/s" ) ;
+      }
+    }
+  }
+  void spectralSetup( Int &spwId, MEpoch &me, MPosition &mp, MDirection &md,
+                      uInt &freqId, Int &nchan,
+                      String &freqref, Double &reffreq, Double &bandwidth )
+  {
+    // fill
+    Int measFreqRef ;
+    getScalar( "MEAS_FREQ_REF", spwId, spwtab, measFreqRef ) ;
+    MFrequency::Types freqRef = MFrequency::castType( measFreqRef ) ;
+    //freqref = MFrequency::showType( freqRef ) ;
+    freqref = "LSRK" ;
+    Quantum<Double> q ;
+    getScalarQuant( "TOTAL_BANDWIDTH", spwId, spwtab, q ) ;
+    bandwidth = q.getValue( "Hz" ) ;
+    getScalarQuant( "REF_FREQUENCY", spwId, spwtab, q ) ;
+    reffreq = q.getValue( "Hz" ) ;
+    Double refpix = 0.5 * ( (Double)nchan-1.0 ) ;
+    Int refchan = ( nchan - 1 ) / 2 ;
+    Bool even = (Bool)( nchan % 2 == 0 ) ;
+    Vector< Quantum<Double> > qa ;
+    getArrayQuant( "CHAN_WIDTH", spwId, spwtab, qa ) ;
+    Double increment = qa[refchan].getValue( "Hz" ) ;
+    getArrayQuant( "CHAN_FREQ", spwId, spwtab, qa ) ;
+    if ( nchan == 1 ) {
+      Int netSideband ;
+      getScalar( "NET_SIDEBAND", spwId, spwtab, netSideband ) ;
+      if ( netSideband == 1 ) increment *= -1.0 ;
+    }
+    else {
+      if ( qa[0].getValue( "Hz" ) > qa[1].getValue( "Hz" ) )
+        increment *= -1.0 ;
+    }
+    Double refval = qa[refchan].getValue( "Hz" ) ;
+    if ( even )
+      refval = 0.5 * ( refval + qa[refchan+1].getValue( "Hz" ) ) ;
+    if ( freqRef != MFrequency::LSRK ) {
+      MeasFrame mframe( me, mp, md ) ;
+      MFrequency::Convert tolsr( freqRef, MFrequency::Ref( MFrequency::LSRK, mframe ) ) ;
+      refval = tolsr( Quantum<Double>( refval, "Hz" ) ).get( "Hz" ).getValue() ;
+    }
+    
+    // add new row to FREQUENCIES
+    Table ftab = scantable.frequencies().table() ;
+    freqId = ftab.nrow() ;
+    ftab.addRow() ;
+    TableRow row( ftab ) ;
+    TableRecord &r = row.record() ;
+    RecordFieldPtr<uInt> idRF( r, "ID" ) ;
+    *idRF = freqId ;
+    RecordFieldPtr<Double> refpixRF( r, "REFPIX" ) ;
+    RecordFieldPtr<Double> refvalRF( r, "REFVAL" ) ;
+    RecordFieldPtr<Double> incrRF( r, "INCREMENT" ) ;
+    *refpixRF = refpix ;
+    *refvalRF = refval ;
+    *incrRF = increment ;
+    row.put( freqId ) ;
+  }
+  void spectraAndFlagtra( uInt recordNo, Matrix<Float> &sp, Matrix<uChar> &fl )
+  {
+    Matrix<Bool> b = flagCol( recordNo ) ;
+    if ( dataColumnName.compare( "FLOAT_DATA" ) == 0 ) {
+      sp = floatDataCol( recordNo ) ;
+      convertArray( fl, b ) ;
+    }
+    else {
+      Bool notyet = True ;
+      Matrix<Complex> c = dataCol( recordNo ) ;
+      for ( Int ipol = 0 ; ipol < npol ; ipol++ ) {
+        if ( ( header.poltype == "linear" || header.poltype == "circular" ) 
+             && ( polnos[ipol] == 2 || polnos[ipol] == 3 ) ) {
+          if ( notyet ) {
+            Vector<Float> tmp = ComplexToReal( c.row( ipol ) ) ;
+            IPosition start( 1, 0 ) ;
+            IPosition end( 1, 2*nchan-1 ) ;
+            IPosition inc( 1, 2 ) ;
+            if ( polnos[ipol] == 2 ) {
+              sp.row( ipol ) = tmp( start, end, inc ) ;
+              Vector<Bool> br = b.row( ipol ) ;
+              Vector<uChar> flr = fl.row( ipol ) ;
+              convertArray( flr, br ) ;
+              start = IPosition( 1, 1 ) ;
+              Int jpol = ipol+1 ;
+              while( polnos[jpol] != 3 && jpol < npol )
+                jpol++ ;
+              sp.row( jpol ) = tmp( start, end, inc ) ;
+              flr.reference( fl.row( jpol ) ) ;
+              convertArray( flr, br ) ;
+            }
+            else if ( polnos[ipol] == 3 ) {
+              sp.row( ipol ) = sp.row( ipol ) * (Float)(-1.0) ;
+              Int jpol = ipol+1 ;
+              while( polnos[jpol] != 2 && jpol < npol )
+                jpol++ ;
+              Vector<Bool> br = b.row( ipol ) ;
+              Vector<uChar> flr = fl.row( jpol ) ;
+              sp.row( jpol ) = tmp( start, end, inc ) ;
+              convertArray( flr, br ) ;
+              start = IPosition( 1, 1 ) ;
+              sp.row( ipol ) = tmp( start, end, inc ) * (Float)(-1.0) ;
+              flr.reference( fl.row( ipol ) ) ;
+              convertArray( flr, br ) ;
+            }
+            notyet = False ;
+          }
+        }
+        else {
+          Vector<Float> tmp = ComplexToReal( c.row( ipol ) ) ;
+          IPosition start( 1, 0 ) ;
+          IPosition end( 1, 2*nchan-1 ) ;
+          IPosition inc( 1, 2 ) ;
+          sp.row( ipol ) = tmp( start, end, inc ) ;
+          Vector<Bool> br = b.row( ipol ) ;
+          Vector<uChar> flr = fl.row( ipol ) ;
+          convertArray( flr, br ) ;
+        }
+      }
+    }
+  }
+  uInt binarySearch( Vector<Double> &timeList, Double target )
+  {
+    Int low = 0 ;
+    Int high = timeList.nelements() ;
+    uInt idx = 0 ;
+    
+    while ( low <= high ) {
+      idx = (Int)( 0.5 * ( low + high ) ) ;
+      Double t = timeList[idx] ;
+      if ( t < target ) 
+        low = idx + 1 ;
+      else if ( t > target )
+        high = idx - 1 ;
+      else {
+        return idx ;
+      }
+    }
+    
+    idx = max( 0, min( low, high ) ) ;
+    return idx ;
+  }
+  void getDirection( Vector<Double> &dir, Vector<Double> &azel, Vector<Double> &srate )
+  {
+    // @todo At the moment, do binary search every time
+    //       if this is bottleneck, frequency of binary search must be reduced
+    Double t = currentTime.get( "s" ).getValue() ;
+    uInt idx = min( binarySearch( pointingTime, t ), pointingTime.nelements()-1 ) ;
+    Matrix<Double> d ;
+    if ( pointingTime[idx] == t )
+      d = pointingDirection.xyPlane( idx ) ;
+    else if ( pointingTime[idx] < t ) {
+      if ( idx == pointingTime.nelements()-1 ) 
+        d = pointingDirection.xyPlane( idx ) ;
+      else 
+        d = interp( pointingTime[idx], pointingTime[idx+1], t,
+                    pointingDirection.xyPlane( idx ), pointingDirection.xyPlane( idx+1 ) ) ;
+    }
+    else {
+      if ( idx == 0 )
+        d = pointingDirection.xyPlane( idx ) ;
+      else 
+        d = interp( pointingTime[idx-1], pointingTime[idx], t,
+                    pointingDirection.xyPlane( idx-1 ), pointingDirection.xyPlane( idx ) ) ;
+    }
+    mf.resetEpoch( currentTime ) ;
+    Quantum< Vector<Double> > tmp( d.column( 0 ), Unit( "rad" ) ) ;
+    if ( dirType != MDirection::J2000 ) {
+      MDirection::Convert toj2000( dirType, MDirection::Ref( MDirection::J2000, mf ) ) ;
+      dir = toj2000( tmp ).getAngle( "rad" ).getValue() ;
+    }
+    else {
+      dir = d.column( 0 ) ;
+    }
+    if ( dirType != MDirection::AZELGEO ) {
+      MDirection::Convert toazel( dirType, MDirection::Ref( MDirection::AZELGEO, mf ) ) ;
+      //MDirection::Convert toazel( dirType, MDirection::Ref( MDirection::AZEL, mf ) ) ;
+      azel = toazel( tmp ).getAngle( "rad" ).getValue() ;
+    }
+    else {
+      azel = d.column( 0 ) ;
+    }
+    if ( d.ncolumn() > 1 )
+      srate = d.column( 1 ) ;
+  }
+  void getSourceDirection( Vector<Double> &dir, Vector<Double> &azel, Vector<Double> &srate )
+  {
+    dir = sourceDir.getAngle( "rad" ).getValue() ;
+    mf.resetEpoch( currentTime ) ;
+    MDirection::Convert toazel( dirType, MDirection::Ref( MDirection::AZELGEO, mf ) ) ;
+    azel = toazel( Quantum< Vector<Double> >( dir, Unit("rad") ) ).getAngle( "rad" ).getValue() ;
+    if ( dirType != MDirection::J2000 ) {
+      MDirection::Convert toj2000( dirType, MDirection::Ref( MDirection::J2000, mf ) ) ;
+      dir = toj2000( Quantum< Vector<Double> >( dir, Unit("rad") ) ).getAngle( "rad" ).getValue() ;
+    }
+  }
+  String detectSeparator( String &s )
+  {
+    String tmp = s.substr( 0, s.find_first_of( "," ) ) ;
+    Char *separators[] = { ":", "#", ".", "_" } ;
+    uInt nsep = 4 ;
+    for ( uInt i = 0 ; i < nsep ; i++ ) {
+      if ( tmp.find( separators[i] ) != String::npos )
+        return separators[i] ;
+    }
+    return "" ;
+  }
+  Int getSrcType( Int stateId )
+  {
+    // get values
+    Bool sig ;
+    getScalar( "SIG", stateId, statetab, sig ) ;
+    Bool ref ;
+    getScalar( "REF", stateId, statetab, ref ) ;
+    Double cal ;
+    getScalar( "CAL", stateId, statetab, cal ) ;
+    String obsmode ;
+    getScalar( "OBS_MODE", stateId, statetab, obsmode ) ;
+    String sep = detectSeparator( obsmode ) ;
+    
+    Int srcType = SrcType::NOTYPE ;
+    if ( sep == ":" )
+      srcTypeGBT( srcType, sep, obsmode, sig, ref, cal ) ;
+    else if ( sep == "." || sep == "#" ) 
+      srcTypeALMA( srcType, sep, obsmode ) ;
+    else if ( sep == "_" )
+      srcTypeOldALMA( srcType, sep, obsmode, sig, ref ) ;
+    else 
+      srcTypeDefault( srcType, sig, ref ) ;
+
+    return srcType ;
+  }
+  void srcTypeDefault( Int &st, Bool &sig, Bool &ref )
+  {
+    if ( sig ) st = SrcType::SIG ;
+    else if ( ref ) st = SrcType::REF ;
+  }
+  void srcTypeGBT( Int &st, String &sep, String &mode, Bool &sig, Bool &ref, Double &cal )
+  {
+    Int epos = mode.find_first_of( sep ) ;
+    Int nextpos = mode.find_first_of( sep, epos+1 ) ;
+    String m1 = mode.substr( 0, epos ) ;
+    String m2 = mode.substr( epos+1, nextpos-epos-1 ) ;
+    if ( m1 == "Nod" ) {
+      st = SrcType::NOD ;
+    }
+    else if ( m1 == "OffOn" ) {
+      if ( m2 == "PSWITCHON" ) st = SrcType::PSON ;
+      if ( m2 == "PSWITCHOFF" ) st = SrcType::PSOFF ;
+    }
+    else {
+      if ( m2 == "FSWITCH" ) {
+        if ( sig ) st = SrcType::FSON ;
+        else if ( ref ) st = SrcType::FSOFF ;
+      }
+    }
+    if ( cal > 0.0 ) {
+      if ( st == SrcType::NOD )
+        st = SrcType::NODCAL ;
+      else if ( st == SrcType::PSON ) 
+        st = SrcType::PONCAL ;
+      else if ( st == SrcType::PSOFF )
+        st = SrcType::POFFCAL ;
+      else if ( st == SrcType::FSON ) 
+        st = SrcType::FONCAL ;
+      else if ( st == SrcType::FSOFF ) 
+        st = SrcType::FOFFCAL ;
+      else
+        st = SrcType::CAL ;
+    }
+  }
+  void srcTypeALMA( Int &st, String &sep, String &mode )
+  {
+    Int epos = mode.find_first_of( "," ) ;
+    String first = mode.substr( 0, epos ) ;
+    epos = first.find_first_of( sep ) ;
+    Int nextpos = first.find_first_of( sep, epos+1 ) ;
+    String m1 = first.substr( 0, epos ) ;
+    String m2 = first.substr( epos+1, nextpos-epos-1 ) ;
+    if ( m1.find( "CALIBRATE_" ) == 0 ) {
+      if ( m2.find( "ON_SOURCE" ) == 0 )
+        st = SrcType::PONCAL ;
+      else if ( m2.find( "OFF_SOURCE" ) == 0 )
+        st = SrcType::POFFCAL ;
+    }
+    else if ( m1.find( "OBSERVE_TARGET" ) == 0 ) {
+      if ( m2.find( "ON_SOURCE" ) == 0 ) 
+        st = SrcType::PSON ;
+      else if ( m2.find( "OFF_SOURCE" ) == 0 )
+        st = SrcType::PSOFF ;
+    }
+  }
+  void srcTypeOldALMA( Int &st, String &sep, String &mode, Bool &sig, Bool &ref )
+  {
+    Int epos = mode.find_first_of( "," ) ;
+    String first = mode.substr( 0, epos ) ;
+    string substr[4] ;
+    int numSubstr = split( first, substr, 4, sep ) ;
+    String m1( substr[0] ) ;
+    String m2( substr[2] ) ;
+    if ( numSubstr == 4 ) {
+      if ( m1.find( "CALIBRATE" ) == 0 ) {
+        if ( m2.find( "ON" ) == 0 ) 
+          st = SrcType::PONCAL ;
+        else if ( m2.find( "OFF" ) == 0 )
+          st = SrcType::POFFCAL ;
+      }
+      else if ( m1.find( "OBSERVE" ) == 0 ) {
+        if ( m2.find( "ON" ) == 0 ) 
+          st = SrcType::PSON ;
+        else if ( m2.find( "OFF" ) == 0 )
+          st = SrcType::PSOFF ;
+      }
+    }
+    else {
+      if ( sig ) st = SrcType::SIG ;
+      else if ( ref ) st = SrcType::REF ;
+    }
+  }
+  Block<uInt> getPolNos( Vector<Int> &corr )
+  {
+    Block<uInt> polnos( npol ) ;
+    for ( Int ipol = 0 ; ipol < npol ; ipol++ ) {
+      if ( corr[ipol] == Stokes::I || corr[ipol] == Stokes::RR || corr[ipol] == Stokes::XX )
+        polnos[ipol] = 0 ;
+      else if ( corr[ipol] == Stokes::Q || corr[ipol] == Stokes::LL || corr[ipol] == Stokes::YY )
+        polnos[ipol] = 1 ;
+      else if ( corr[ipol] == Stokes::U || corr[ipol] == Stokes::RL || corr[ipol] == Stokes::XY )
+        polnos[ipol] = 2 ;
+      else if ( corr[ipol] == Stokes::V || corr[ipol] == Stokes::LR || corr[ipol] == Stokes::YX )
+        polnos[ipol] = 3 ;
+    }
+    return polnos ;
+  }
+  String getPolType( Int &corr )
+  {
+    String poltype = "" ;
+    if ( corr == Stokes::I || corr == Stokes::Q || corr == Stokes::U || corr == Stokes::V )
+      poltype = "stokes" ;
+    else if ( corr == Stokes::XX || corr == Stokes::YY || corr == Stokes::XY || corr == Stokes::YX ) 
+      poltype = "linear" ;
+    else if ( corr == Stokes::RR || corr == Stokes::LL || corr == Stokes::RL || corr == Stokes::LR ) 
+      poltype = "circular" ;
+    else if ( corr == Stokes::Plinear || corr == Stokes::Pangle )
+      poltype = "linpol" ;
+    return poltype ;    
+  }
+  uInt getWeatherId()
+  {
+    // if only one row, return 0
+    if ( weatherTime.nelements() == 1 )
+      return 0 ;
+
+    // @todo At the moment, do binary search every time
+    //       if this is bottleneck, frequency of binary search must be reduced
+    Double t = currentTime.get( "s" ).getValue() ;
+    uInt idx = min( binarySearch( weatherTime, t ), weatherTime.nelements()-1 ) ;
+    if ( weatherTime[idx] < t ) {
+      if ( idx != weatherTime.nelements()-1 ) {
+        if ( weatherTime[idx+1] - t < 0.5 * weatherInterval[idx+1] )
+          idx++ ;
+      }
+    }
+    else if ( weatherTime[idx] > t ) {
+      if ( idx != 0 ) {
+        if ( weatherTime[idx] - t > 0.5 * weatherInterval[idx] )
+          idx-- ;
+      }
+    }
+    return idx ;
+  }
+  void processSysCal( Int &spwId )
+  {
+    // get feedId from row
+    Int feedId = (Int)tablerow.record().asuInt( "BEAMNO" ) ;
+
+    uInt nrow = sctab.nrow() ;
+    ROScalarColumn<Int> col( sctab, "ANTENNA_ID" ) ;
+    Vector<Int> aids = col.getColumn() ;
+    col.attach( sctab, "FEED_ID" ) ;
+    Vector<Int> fids = col.getColumn() ;
+    col.attach( sctab, "SPECTRAL_WINDOW_ID" ) ;
+    Vector<Int> sids = col.getColumn() ;
+    ROScalarColumn<Double> timeCol( sctab, "TIME" ) ;
+    ROScalarColumn<Double> intCol( sctab, "INTERVAL" ) ;
+    for ( uInt irow = 0 ; irow < nrow ; irow++ ) {
+      if ( aids[irow] == antennaId 
+           && fids[irow] == feedId 
+           && sids[irow] == spwId ) {
+        syscalRow[numSysCalRow] = irow ;
+        syscalTime[numSysCalRow] = timeCol( irow ) ;
+        syscalInterval[numSysCalRow] = intCol( irow ) ;
+        numSysCalRow++ ;
+      }
+    }
+  }
+  uInt getSysCalIndex()
+  {
+    // if only one row, return 0
+    if ( numSysCalRow == 1 || !isSysCal )
+      return 0 ;
+
+    // @todo At the moment, do binary search every time
+    //       if this is bottleneck, frequency of binary search must be reduced
+    Double t = currentTime.get( "s" ).getValue() ;
+    Vector<Double> tslice  = syscalTime( Slice(0, numSysCalRow) ) ;
+    uInt idx = min( binarySearch( tslice, t ), numSysCalRow-1 ) ;
+    if ( syscalTime[idx] < t ) {
+      if ( idx != numSysCalRow-1 ) {
+        if ( syscalTime[idx+1] - t < 0.5 * syscalInterval[idx+1] )
+          idx++ ;
+      }
+    }
+    else if ( syscalTime[idx] > t ) {
+      if ( idx != 0 ) {
+        if ( syscalTime[idx] - t > 0.5 * syscalInterval[idx] )
+          idx-- ;
+      }
+    }
+    return idx ;    
+  }
+  Block<uInt> getTcalId( Double &t )
+  {
+    // return 0 if no SysCal table
+    if ( !isSysCal ) {
+      return Block<uInt>( 4, 0 ) ;
+    }
+      
+    // get feedId from row
+    Int feedId = (Int)tablerow.record().asuInt( "BEAMNO" ) ;
+
+    // key
+    String key = keyTcal( feedId, spwId, t ) ;
+    
+    // retrieve ids
+    Vector<uInt> ids = syscalRecord.asArrayuInt( key ) ;
+    //Vector<uInt> ids = syscalRecord[key] ;
+    uInt np = ids[1] - ids[0] + 1 ;
+    Block<uInt> tcalids( np ) ;
+    if ( np > 0 ) {
+      tcalids[0] = ids[0] ;
+      if ( np > 1 ) {
+        tcalids[1] = ids[1] ;
+        for ( uInt ip = 2 ; ip < np ; ip++ )
+          tcalids[ip] = ids[0] + ip - 1 ;
+      }
+    }
+    return tcalids ;
+  }
+  uInt maxNumPol()
+  {
+    ROScalarColumn<Int> numCorrCol( poltab, "NUM_CORR" ) ;
+    return max( numCorrCol.getColumn() ) ;
+  }
+
+  Scantable &scantable;
+  Int antennaId;
+  uInt rowidx;
+  String dataColumnName;
+  TableRow tablerow;
+  STHeader header;
+  Vector<Int> feedEntry;
+  uInt nbeam;
+  Int npol;
+  Int nchan;
+  Int sourceId;
+  Int polId;
+  Int spwId;
+  uInt cycleNo;
+  MDirection sourceDir;
+  MPosition antpos;
+  MEpoch currentTime;
+  map<Int,uInt> ifmap;
+  Block<uInt> polnos;
+  Bool getpt;
+  Vector<Double> pointingTime;
+  Cube<Double> pointingDirection;
+  MDirection::Types dirType;
+  Bool isWeather;
+  Vector<Double> weatherTime;
+  Vector<Double> weatherInterval;
+  Bool isSysCal;
+  Record syscalRecord;
+  //map< String,Vector<uInt> > syscalRecord;
+  uInt numSysCalRow ;
+  Vector<uInt> syscalRow;
+  Vector<Double> syscalTime;
+  Vector<Double> syscalInterval;
+  //String tsysCol;
+  //String tcalCol;
+
+  // MS subtables
+  Table obstab;
+  Table sctab;
+  Table spwtab;
+  Table statetab;
+  Table ddtab;
+  Table poltab;
+  Table fieldtab;
+  Table anttab;
+  Table srctab;
+  Matrix<Float> sp;
+  Matrix<uChar> fl;
+  MeasFrame mf;
+
+  // MS MAIN columns
+  ROTableColumn intervalCol;
+  ROTableColumn flagRowCol;
+  ROArrayColumn<Float> floatDataCol;
+  ROArrayColumn<Complex> dataCol;
+  ROArrayColumn<Bool> flagCol;
+
+  // MS SYSCAL columns 
+  ROArrayColumn<Float> sysCalTsysCol;
+
+  // Scantable MAIN columns
+  RecordFieldPtr<Double> timeRF,intervalRF,sourceVelocityRF;
+  RecordFieldPtr< Vector<Double> > directionRF,scanRateRF,
+    sourceProperMotionRF,sourceDirectionRF;
+  RecordFieldPtr<Float> azimuthRF,elevationRF;
+  RecordFieldPtr<uInt> weatherIdRF,cycleNoRF,flagRowRF,polNoRF,tcalIdRF,
+    ifNoRF,freqIdRF,moleculeIdRF,beamNoRF,focusIdRF,scanNoRF;
+  RecordFieldPtr< Vector<Float> > spectraRF,tsysRF;
+  RecordFieldPtr< Vector<uChar> > flagtraRF;
+  RecordFieldPtr<String> sourceNameRF,fieldNameRF;
+  RecordFieldPtr<Int> sourceTypeRF;
+};
+
+class BaseTcalVisitor: public TableVisitor {
+  uInt lastRecordNo ;
+  Int lastAntennaId ;
+  Int lastFeedId ;
+  Int lastSpwId ;
+  Double lastTime ;
+protected:
+  const Table &table;
+  uInt count;
+public:
+  BaseTcalVisitor(const Table &table)
+   : table(table)
+  {
+    count = 0;
+  }
+  
+  virtual void enterAntennaId(const uInt recordNo, Int columnValue) { }
+  virtual void leaveAntennaId(const uInt recordNo, Int columnValue) { }
+  virtual void enterFeedId(const uInt recordNo, Int columnValue) { }
+  virtual void leaveFeedId(const uInt recordNo, Int columnValue) { }
+  virtual void enterSpwId(const uInt recordNo, Int columnValue) { }
+  virtual void leaveSpwId(const uInt recordNo, Int columnValue) { }
+  virtual void enterTime(const uInt recordNo, Double columnValue) { }
+  virtual void leaveTime(const uInt recordNo, Double columnValue) { }
+
+  virtual Bool visitRecord(const uInt recordNo,
+                           const Int antennaId,
+                           const Int feedId,
+                           const Int spwId,
+                           const Double time) { return True ; }
+
+  virtual Bool visit(Bool isFirst, const uInt recordNo,
+                     const uInt nCols, void const *const colValues[]) {
+    Int antennaId, feedId, spwId; 
+    Double time;
+    { // prologue
+      uInt i = 0;
+      {
+        const Int *col = (const Int *)colValues[i++];
+        antennaId = col[recordNo];
+      }
+      {
+        const Int *col = (const Int *)colValues[i++];
+        feedId = col[recordNo];
+      }
+      {
+        const Int *col = (const Int *)colValues[i++];
+        spwId = col[recordNo];
+      }
+      {
+        const Double *col = (const Double *)colValues[i++];
+        time = col[recordNo];
+      }
+      assert(nCols == i);
+    }
+
+    if (isFirst) {
+      enterAntennaId(recordNo, antennaId);
+      enterFeedId(recordNo, feedId);
+      enterSpwId(recordNo, spwId);
+      enterTime(recordNo, time);
+    } else {
+      if ( lastAntennaId != antennaId ) {
+        leaveTime(lastRecordNo, lastTime);
+        leaveSpwId(lastRecordNo, lastSpwId);
+        leaveFeedId(lastRecordNo, lastFeedId);
+        leaveAntennaId(lastRecordNo, lastAntennaId);
+
+        enterAntennaId(recordNo, antennaId);
+        enterFeedId(recordNo, feedId);
+        enterSpwId(recordNo, spwId);
+        enterTime(recordNo, time);
+      }        
+      else if (lastFeedId != feedId) {
+        leaveTime(lastRecordNo, lastTime);
+        leaveSpwId(lastRecordNo, lastSpwId);
+        leaveFeedId(lastRecordNo, lastFeedId);
+
+        enterFeedId(recordNo, feedId);
+        enterSpwId(recordNo, spwId);
+        enterTime(recordNo, time);
+      } else if (lastSpwId != spwId) {
+        leaveTime(lastRecordNo, lastTime);
+        leaveSpwId(lastRecordNo, lastSpwId);
+
+        enterSpwId(recordNo, spwId);
+        enterTime(recordNo, time);
+      } else if (lastTime != time) {
+        leaveTime(lastRecordNo, lastTime);
+        enterTime(recordNo, time);
+      }
+    }
+    count++;
+    Bool result = visitRecord(recordNo, antennaId, feedId, spwId, time);
+
+    { // epilogue
+      lastRecordNo = recordNo;
+
+      lastAntennaId = antennaId;
+      lastFeedId = feedId;
+      lastSpwId = spwId;
+      lastTime = time;
+    }
+    return result ;
+  }
+
+  virtual void finish() {
+    if (count > 0) {
+      leaveTime(lastRecordNo, lastTime);
+      leaveSpwId(lastRecordNo, lastSpwId);
+      leaveFeedId(lastRecordNo, lastFeedId);
+      leaveAntennaId(lastRecordNo, lastAntennaId);
+    }
+  }
+};
+
+class TcalVisitor: public BaseTcalVisitor, public MSFillerUtils {
+public:
+  TcalVisitor(const Table &table, Table &tcaltab, Record &r, Int aid )
+  //TcalVisitor(const Table &table, Table &tcaltab, map< String,Vector<uInt> > &r, Int aid )
+    : BaseTcalVisitor( table ),
+      tcal(tcaltab),
+      rec(r),
+      antenna(aid) 
+  { 
+    process = False ;
+    rowidx = 0 ;
+
+    // attach to SYSCAL columns
+    timeCol.attach( table, "TIME" ) ;
+
+    // add rows
+    uInt addrow = table.nrow() * 4 ;
+    tcal.addRow( addrow ) ;
+
+    // attach to TCAL columns
+    row = TableRow( tcal ) ;
+    TableRecord &trec = row.record() ;
+    idRF.attachToRecord( trec, "ID" ) ;
+    timeRF.attachToRecord( trec, "TIME" ) ;
+    tcalRF.attachToRecord( trec, "TCAL" ) ;
+  }
+
+  virtual void enterAntennaId(const uInt recordNo, Int columnValue) {
+    if ( columnValue == antenna )
+      process = True ;
+  }
+  virtual void leaveAntennaId(const uInt recordNo, Int columnValue) {
+    process = False ;
+  }
+  virtual void enterFeedId(const uInt recordNo, Int columnValue) { }
+  virtual void leaveFeedId(const uInt recordNo, Int columnValue) { }
+  virtual void enterSpwId(const uInt recordNo, Int columnValue) { }
+  virtual void leaveSpwId(const uInt recordNo, Int columnValue) { }
+  virtual void enterTime(const uInt recordNo, Double columnValue) {
+    qtime = timeCol( recordNo ) ;
+  }
+  virtual void leaveTime(const uInt recordNo, Double columnValue) { }
+  virtual Bool visitRecord(const uInt recordNo,
+                           const Int antennaId,
+                           const Int feedId,
+                           const Int spwId,
+                           const Double time) 
+  { 
+    //cout << "(" << recordNo << "," << antennaId << "," << feedId << "," << spwId << ")" << endl ;
+    if ( process ) {
+      String sTime = MVTime( qtime ).string( MVTime::YMD ) ;
+      *timeRF = sTime ;
+      uInt oldidx = rowidx ;
+      Matrix<Float> subtcal = tcalCol( recordNo ) ;
+      Vector<uInt> idminmax( 2 ) ;
+      for ( uInt ipol = 0 ; ipol < subtcal.nrow() ; ipol++ ) {
+        *idRF = rowidx ;
+        tcalRF.define( subtcal.row( ipol ) ) ;
+        
+        // commit row
+        row.put( rowidx ) ;
+        rowidx++ ;
+      }
+      
+      idminmax[0] = oldidx ;
+      idminmax[1] = rowidx - 1 ;
+      
+      String key = keyTcal( feedId, spwId, sTime ) ;
+      rec.define( key, idminmax ) ;
+      //rec[key] = idminmax ;
+    }
+    return True ; 
+  }
+  virtual void finish() 
+  {
+    BaseTcalVisitor::finish() ;
+
+    if ( tcal.nrow() > rowidx ) {
+      uInt numRemove = tcal.nrow() - rowidx ;
+      //cout << "numRemove = " << numRemove << endl ;
+      Vector<uInt> rows( numRemove ) ;
+      indgen( rows, rowidx ) ;
+      tcal.removeRow( rows ) ;
+    }
+
+  }
+  void setTcalColumn( String &col ) 
+  {
+    //colName = col ;
+    tcalCol.attach( table, col ) ;
+  }
+private:
+  Table &tcal;
+  Record &rec;
+  //map< String,Vector<uInt> > &rec;
+  Int antenna;
+  uInt rowidx;
+  Bool process;
+  Quantum<Double> qtime;
+  TableRow row;
+  String colName;
+
+  // MS SYSCAL columns
+  ROScalarQuantColumn<Double> timeCol;
+  ROArrayColumn<Float> tcalCol;
+
+  // TCAL columns
+  RecordFieldPtr<uInt> idRF;
+  RecordFieldPtr<String> timeRF;
+  RecordFieldPtr< Vector<Float> > tcalRF;
+};
 
 MSFiller::MSFiller( casa::CountedPtr<Scantable> stable )
@@ -122 +1593 @@
 
   MeasurementSet *tmpMS = new MeasurementSet( filename, Table::Old ) ;
-  //mstable_ = (*tmpMS)( tmpMS->col("ANTENNA1") == antenna_ 
-  //                     && tmpMS->col("ANTENNA1") == tmpMS->col("ANTENNA2") ) ;
   tablename_ = tmpMS->tableName() ;
   if ( antenna_ == -1 && antennaStr_.size() > 0 ) {
@@ -139 +1608 @@
   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 ;
 
@@ -156 +1622 @@
 void MSFiller::fill()
 {
-  os_.origin( LogOrigin( "MSFiller", "fill()", WHERE ) ) ;
   //double startSec = mathutil::gettimeofday_sec() ;
   //os_ << "start MSFiller::fill() startSec=" << startSec << LogIO::POST ;
 
-  //double time0 = mathutil::gettimeofday_sec() ;
-  //os_ << "start init fill: " << time0 << LogIO::POST ;
+  os_.origin( LogOrigin( "MSFiller", "fill()", WHERE ) ) ;
 
   // Initialize header
   STHeader sdh ;  
   initHeader( sdh ) ;
+  table_->setHeader( sdh ) ;
  
   // check if optional table exists
-  //const TableRecord msrec = tablesel_.keywordSet() ;
-  const TableRecord msrec = mstable_.keywordSet() ;
+  const TableRecord &msrec = mstable_.keywordSet() ;
   isDoppler_ = msrec.isDefined( "DOPPLER" ) ;
   if ( isDoppler_ )
@@ -199 +1663 @@
       isWeather_ = False ;
 
-  // Access to MS subtables
-  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 ;
-  else {
+  // column name for Tsys and Tcal
+  if ( isSysCal_ ) {
+    const MSSysCal &caltab = mstable_.sysCal() ;
     if ( !caltab.tableDesc().isColumn( colTcal_ ) ) {
       colTcal_ = "TCAL" ;
@@ -221 +1677 @@
     }
   }
-//   colTcal_ = "TCAL" ;
-//   colTsys_ = "TSYS" ;
-  MSPointing pointtab = mstable_.pointing() ;
-  if ( mstable_.weather().nrow() == 0 ) 
-    isWeather_ = False ;
-  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> ;
-  //
+  else {
+    colTcal_ = "NONE" ;
+    colTsys_ = "NONE" ;
+  }
+
+  // Access to MS subtables
+  //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() ; 
+  MSPointing &pointtab = mstable_.pointing() ;
+  //MSState &stattab = mstable_.state() ;
+  //MSAntenna &anttab = mstable_.antenna() ;
 
   // SUBTABLES: FREQUENCIES
@@ -247 +1707 @@
 
   // SUBTABLES: TCAL
-  fillTcal( tpoolr ) ;
+  fillTcal() ;
 
   // SUBTABLES: FIT
@@ -255 +1715 @@
   //fillHistory() ;
 
-  // MAIN 
-  // Iterate over several ids
-  map<Int, uInt> ifmap ; // (IFNO, FREQ_ID) pair
-  ROArrayQuantColumn<Double> *sharedQDArrCol = new ROArrayQuantColumn<Double>( anttab, "POSITION" ) ;
-  Vector< Quantum<Double> > antpos = (*sharedQDArrCol)( antenna_ ) ;
-  delete sharedQDArrCol ;
-  MPosition mp( MVPosition( antpos ), MPosition::ITRF ) ;
-  Vector<Double> pt ;
-  ROArrayColumn<Double> pdcol ;
-  Vector<Double> defaultScanrate( 2, 0.0 ) ;
-  if ( getPt_ ) {
-    pointtab = MSPointing( pointtab( pointtab.col("ANTENNA_ID")==antenna_ ).sort("TIME") ) ;
-    ROScalarColumn<Double> ptcol( pointtab, "TIME" ) ;
-    ptcol.getColumn( pt ) ;
-    TableRecord trec = ptcol.keywordSet() ;
-    String tUnit = trec.asArrayString( "QuantumUnits" ).data()[0] ;
-    if ( tUnit == "d" )
-      pt *= 86400.0 ;
-    pdcol.attach( pointtab, "DIRECTION" ) ; 
-  }
-  String stationName = asString( "STATION", antenna_, anttab, tpoolr ) ;
-  String antennaName = asString( "NAME", antenna_, anttab, tpoolr ) ;
-  sdh.antennaposition.resize( 3 ) ;
-  for ( int i = 0 ; i < 3 ; i++ )
-    sdh.antennaposition[i] = antpos[i].getValue( "m" ) ;
-  String telescopeName = "" ;
-
-  //double time1 = mathutil::gettimeofday_sec() ;
-  //os_ << "end init fill: " << time1 << " (" << time1-time0 << "sec)" << LogIO::POST ;
-
-  // row based 
-  Table &stab = table_->table() ; 
-  TableRow row( stab ) ;
-  TableRecord &trec = row.record() ;
-  RecordFieldPtr< Array<Float> > spRF( trec, "SPECTRA" ) ;
-  RecordFieldPtr< Array<uChar> > ucarrRF( trec, "FLAGTRA" ) ;
-  RecordFieldPtr<Double> timeRF( trec, "TIME" ) ;
-  RecordFieldPtr< Array<Float> > tsysRF( trec, "TSYS" ) ;
-  RecordFieldPtr<Double> intervalRF( trec, "INTERVAL" ) ;
-  RecordFieldPtr< Array<Double> > dirRF( trec, "DIRECTION" ) ;
-  RecordFieldPtr<Float> azRF( trec, "AZIMUTH" ) ;
-  RecordFieldPtr<Float> elRF( trec, "ELEVATION" ) ;
-  RecordFieldPtr< Array<Double> > scrRF( trec, "SCANRATE" ) ;
-  RecordFieldPtr<uInt> cycleRF( trec, "CYCLENO" ) ;
-  RecordFieldPtr<uInt> flrRF( trec, "FLAGROW" ) ;
-  RecordFieldPtr<uInt> tcalidRF( trec, "TCAL_ID" ) ;
-  RecordFieldPtr<uInt> widRF( trec, "WEATHER_ID" ) ;
-  RecordFieldPtr<uInt> polnoRF( trec, "POLNO" ) ;
-  RecordFieldPtr<Int> refbRF( trec, "REFBEAMNO" ) ;
-  RecordFieldPtr<Int> fitidRF( trec, "FIT_ID" ) ;
-  RecordFieldPtr<Float> tauRF( trec, "OPACITY" ) ;
-  RecordFieldPtr<uInt> beamRF( trec, "BEAMNO" ) ;
-  RecordFieldPtr<uInt> focusidRF( trec, "FOCUS_ID" ) ;
-  RecordFieldPtr<uInt> ifnoRF( trec, "IFNO" ) ;
-  RecordFieldPtr<uInt> molidRF( trec, "MOLECULE_ID" ) ;
-  RecordFieldPtr<uInt> freqidRF( trec, "FREQ_ID" ) ;
-  RecordFieldPtr<uInt> scanRF( trec, "SCANNO" ) ;
-  RecordFieldPtr<Int> srctypeRF( trec, "SRCTYPE" ) ;
-  RecordFieldPtr<String> srcnameRF( trec, "SRCNAME" ) ;
-  RecordFieldPtr<String> fieldnameRF( trec, "FIELDNAME" ) ;
-  RecordFieldPtr< Array<Double> > srcpmRF( trec, "SRCPROPERMOTION" ) ;
-  RecordFieldPtr< Array<Double> > srcdirRF( trec, "SRCDIRECTION" ) ;
-  RecordFieldPtr<Double> sysvelRF( trec, "SRCVELOCITY" ) ;
-
-  // REFBEAMNO
-  *refbRF = -1 ;
-
-  // FIT_ID
-  *fitidRF = -1 ;
-
-  // OPACITY
-  *tauRF = 0.0 ;
-
-  //
-  // ITERATION: OBSERVATION_ID
-  //
-  TableIterator iter0( mstable_, "OBSERVATION_ID" ) ;
-  while( !iter0.pastEnd() ) {
-    //time0 = mathutil::gettimeofday_sec() ;
-    //os_ << "start 0th iteration: " << time0 << LogIO::POST ;
-    Table t0 = iter0.table() ;
-    Int obsId = asInt( "OBSERVATION_ID", 0, t0, tpoolr ) ;
-    if ( sdh.observer == "" ) {
-      sdh.observer = asString( "OBSERVER", obsId, obstab, tpoolr ) ;
-    }
-    if ( sdh.project == "" ) {
-      sdh.project = asString( "PROJECT", obsId, obstab, tpoolr ) ;
-    }
-    ROArrayMeasColumn<MEpoch> *tmpMeasCol = new ROArrayMeasColumn<MEpoch>( obstab, "TIME_RANGE" ) ;
-    MEpoch me = (*tmpMeasCol)( obsId )( IPosition(1,0) ) ;
-    delete tmpMeasCol ;
-    if ( sdh.utc == 0.0 ) {
-      sdh.utc = me.get( "d" ).getValue() ;
-    }
-    if ( telescopeName == "" ) {
-      telescopeName = asString( "TELESCOPE_NAME", obsId, obstab, tpoolr ) ;
-    }
-    Int nbeam = 0 ;
-    //time1 = mathutil::gettimeofday_sec() ;
-    //os_ << "end 0th iteration init: " << time1 << " (" << time1-time0 << "sec)" << LogIO::POST ;
-    //
-    // ITERATION: FEED1
-    //
-    TableIterator iter1( t0, "FEED1" ) ;
-    while( !iter1.pastEnd() ) {
-      //time0 = mathutil::gettimeofday_sec() ;
-      //os_ << "start 1st iteration: " << time0 << LogIO::POST ;
-      Table t1 = iter1.table() ;
-      // assume FEED1 == FEED2
-      Int feedId = asInt( "FEED1", 0, t1, tpoolr ) ;
-      nbeam++ ;
-
-      // BEAMNO
-      *beamRF = feedId ;
-
-      // FOCUS_ID
-      *focusidRF = 0 ;
-
-      //time1 = mathutil::gettimeofday_sec() ;
-      //os_ << "end 1st iteration init: " << time1 << " (" << time1-time0 << "sec)" << LogIO::POST ;
-      // 
-      // ITERATION: FIELD_ID 
-      //
-      TableIterator iter2( t1, "FIELD_ID" ) ;
-      while( !iter2.pastEnd() ) {
-        //time0 = mathutil::gettimeofday_sec() ;
-        //os_ << "start 2nd iteration: " << time0 << LogIO::POST ;
-        Table t2 = iter2.table() ;
-        Int fieldId = asInt( "FIELD_ID", 0, t2, tpoolr ) ;
-        Int srcId = asInt( "SOURCE_ID", fieldId, fieldtab, tpoolr ) ;
-        String fieldName = asString( "NAME", fieldId, fieldtab, tpoolr ) ;
-        fieldName += "__" + String::toString(fieldId) ;
-        ROArrayMeasColumn<MDirection> *delayDirCol = new ROArrayMeasColumn<MDirection>( fieldtab, "DELAY_DIR" ) ;
-        Vector<MDirection> delayDir = (*delayDirCol)( fieldId ) ;
-        delete delayDirCol ;          
-
-        // FIELDNAME
-        *fieldnameRF = fieldName ;
-
-
-        //time1 = mathutil::gettimeofday_sec() ;
-        //os_ << "end 2nd iteration init: " << time1 << " (" << time1-time0 << "sec)" << LogIO::POST ;
-        // 
-        // ITERATION: DATA_DESC_ID
-        //
-        TableIterator iter3( t2, "DATA_DESC_ID" ) ;
-        while( !iter3.pastEnd() ) {
-          //time0 = mathutil::gettimeofday_sec() ;
-          //os_ << "start 3rd iteration: " << time0 << LogIO::POST ;
-          Table t3 = iter3.table() ;
-          Int ddId = asInt( "DATA_DESC_ID", 0, t3, tpoolr ) ;
-          Int polId = asInt( "POLARIZATION_ID", ddId, ddtab, tpoolr ) ;
-          Int spwId = asInt( "SPECTRAL_WINDOW_ID", ddId, ddtab, tpoolr ) ;
-
-          // IFNO
-          *ifnoRF = (uInt)spwId ;
-
-          // polarization information
-          Int npol = asInt( "NUM_CORR", polId, poltab, tpoolr ) ;
-          ROArrayColumn<Int> *roArrICol = new ROArrayColumn<Int>( poltab, "CORR_TYPE" ) ;
-          Vector<Int> corrtype = (*roArrICol)( polId ) ;
-          delete roArrICol ;
-          String srcName( "" ) ;
-          Vector<Double> srcPM( 2, 0.0 ) ;
-          Vector<Double> srcDir( 2, 0.0 ) ;
-          MDirection md ;
-          Vector<Double> restFreqs ;
-          Vector<String> transitionName ;
-          Vector<Double> sysVels ;
-//           os_ << "npol = " << npol << LogIO::POST ;
-//           os_ << "corrtype = " << corrtype << LogIO::POST ;
-
-          // source and molecular transition
-          sourceInfo( srcId, spwId, srcName, md, srcPM, restFreqs, transitionName, sysVels, tpoolr ) ;
-//           os_ << "srcId = " << srcId << ", spwId = " << spwId << LogIO::POST ;
-
-          // SRCNAME
-          *srcnameRF = srcName ;
-
-//           os_ << "srcName = " << srcName << LogIO::POST ;
-
-          // SRCPROPERMOTION
-          *srcpmRF = srcPM ;
-
-          //os_ << "srcPM = " << srcPM << LogIO::POST ;
-
-          // SRCDIRECTION
-          *srcdirRF = md.getAngle().getValue( "rad" ) ;
-
-          //os_ << "srcDir = " << srcDir << LogIO::POST ;
-
-          // SRCVELOCITY
-          Double sysVel = 0.0 ;
-          if ( !sysVels.empty() ) 
-            sysVel = sysVels[0] ;
-          *sysvelRF = sysVel ;
-
-//           os_ << "sysVel = " << sysVel << LogIO::POST ;
-
-          uInt molId = table_->molecules().addEntry( restFreqs, transitionName, transitionName ) ;
-
-          // MOLECULE_ID
-          *molidRF = molId ;
-
-          // spectral setup
-          uInt freqId ;
-          Int nchan = asInt( "NUM_CHAN", spwId, spwtab, tpoolr ) ;
-          Bool iswvr = False ;
-          if ( nchan == 4 ) iswvr = True ;
-          sdh.nchan = max( sdh.nchan, nchan ) ;
-          map<Int,uInt>::iterator iter = ifmap.find( spwId ) ;
-          if ( iter == ifmap.end() ) {
-            ROScalarMeasColumn<MEpoch> *tmpMeasCol = new ROScalarMeasColumn<MEpoch>( t3, "TIME" ) ;
-            me = (*tmpMeasCol)( 0 ) ;
-            delete tmpMeasCol ;
-            Double refpix ;
-            Double refval ;
-            Double increment ;
-            spectralSetup( spwId, 
-                           me,
-                           mp, 
-                           md,
-                           refpix,
-                           refval,
-                           increment,
-                           nchan,
-                           sdh.freqref,
-                           sdh.reffreq,
-                           sdh.bandwidth,
-                           tpoolr ) ;
-            freqId = table_->frequencies().addEntry( refpix, refval, increment ) ;
-            ifmap.insert( pair<Int, uInt>(spwId,freqId) ) ;
-            //os_ << "added to ifmap: (" << spwId << "," << freqId << ")" << LogIO::POST ;
-          }
-          else {
-            freqId = iter->second ;
-          }
-
-          // FREQ_ID
-          *freqidRF = freqId ;
-
-          // for TSYS and TCAL
-          Vector<MEpoch> scTime ;
-          Vector<Double> scInterval ;
-          ROArrayColumn<Float> scTsysCol ;
-          MSSysCal caltabsel ;
-          if ( isSysCal_ ) {
-            caltabsel = caltab( caltab.col("ANTENNA_ID") == antenna_ && caltab.col("FEED_ID") == feedId && caltab.col("SPECTRAL_WINDOW_ID") == spwId ).sort("TIME") ;
-            ROScalarMeasColumn<MEpoch> scTimeCol( caltabsel, "TIME" ) ;
-            scTime.resize( caltabsel.nrow() ) ;
-            for ( uInt irow = 0 ; irow < caltabsel.nrow() ; irow++ ) 
-              scTime[irow] = scTimeCol( irow ) ;
-            ROScalarColumn<Double> scIntervalCol( caltabsel, "INTERVAL" ) ;
-            scIntervalCol.getColumn( scInterval ) ;
-            if ( colTsys_ != "NONE" )
-              scTsysCol.attach( caltabsel, colTsys_ ) ;
-          }
-
-          sdh.npol = max( sdh.npol, npol ) ;
-          if ( !iswvr && sdh.poltype == "" ) sdh.poltype = getPolType( corrtype[0] ) ;
-
-          //time1 = mathutil::gettimeofday_sec() ;
-          //os_ << "end 3rd iteration init: " << time1 << " (" << time1-time0 << "sec)" << LogIO::POST ;
-          //
-          // ITERATION: SCAN_NUMBER
-          //
-          TableIterator iter4( t3, "SCAN_NUMBER" ) ;
-          while( !iter4.pastEnd() ) {
-            //time0 = mathutil::gettimeofday_sec() ;
-            //os_ << "start 4th iteration: " << time0 << LogIO::POST ;
-            Table t4 = iter4.table() ;
-            Int scanNum = asInt( "SCAN_NUMBER", 0, t4, tpoolr ) ;
-
-            // SCANNO
-            *scanRF = scanNum - 1 ;
-
-            uInt cycle = 0 ;
-
-            //time1 = mathutil::gettimeofday_sec() ;
-            //os_ << "end 4th iteration init: " << time1 << " (" << time1-time0 << "sec)" << LogIO::POST ;
-            // 
-            // ITERATION: STATE_ID
-            //
-            TableIterator iter5( t4, "STATE_ID" ) ; 
-            while( !iter5.pastEnd() ) {
-              //time0 = mathutil::gettimeofday_sec() ;
-              //os_ << "start 5th iteration: " << time0 << LogIO::POST ;
-              Table t5 = iter5.table() ;
-              Int stateId = asInt( "STATE_ID", 0, t5, tpoolr ) ;
-              String obstype = asString( "OBS_MODE", 0, stattab, tpoolr ) ;
-              if ( sdh.obstype == "" ) sdh.obstype = obstype ;
-
-              Int nrow = t5.nrow() ;
-              //time1 = mathutil::gettimeofday_sec() ;
-              //os_ << "end 5th iteration init: " << time1 << " (" << time1-time0 << "sec)" << LogIO::POST ;
-
-              Cube<Float> spArr ;
-              Cube<Bool> flArr ;
-              reshapeSpectraAndFlagtra( spArr, 
-                                        flArr, 
-                                        t5, 
-                                        npol, 
-                                        nchan, 
-                                        nrow,
-                                        corrtype ) ;
-              if ( sdh.fluxunit == "" ) {
-                String colName = "FLOAT_DATA" ;
-                if ( isData_ ) colName = "DATA" ;
-                ROTableColumn dataCol( t5, colName ) ;
-                const TableRecord &dataColKeys = dataCol.keywordSet() ;
-                if ( dataColKeys.isDefined( "UNIT" ) )
-                  sdh.fluxunit = dataColKeys.asString( "UNIT" ) ;
-                else if ( dataColKeys.isDefined( "QuantumUnits" ) )
-                  sdh.fluxunit = dataColKeys.asString( "QuantumUnits" ) ;
-              }
-
-              ROScalarMeasColumn<MEpoch> *mTimeCol = new ROScalarMeasColumn<MEpoch>( t5, "TIME" ) ;
-              Block<MEpoch> mTimeB( nrow ) ;
-              for ( Int irow = 0 ; irow < nrow ; irow++ ) 
-                mTimeB[irow] = (*mTimeCol)( irow ) ;
-              Block<Int> sysCalIdx( nrow, -1 ) ;
-              if ( isSysCal_ ) {
-                getSysCalTime( scTime, scInterval, mTimeB, sysCalIdx ) ;
-              }
-              delete mTimeCol ;
-              Matrix<Float> defaulttsys( npol, 1, 1.0 ) ;
-              Int srcType = getSrcType( stateId, tpoolr ) ;
-              uInt diridx = 0 ;
-              uInt wid = 0 ;
-              Int pidx = 0 ;
-              Bool crossOK = False ;
-              Block<uInt> polnos( npol, 99 ) ;
-              for ( Int ipol = 0 ; ipol < npol ; ipol++ ) {
-                Block<uInt> p = getPolNo( corrtype[ipol] ) ;
-                if ( p.size() > 1 ) {
-                  if ( crossOK ) continue ;
-                  else {
-                    polnos[pidx] = p[0] ;
-                    pidx++ ;
-                    polnos[pidx] = p[1] ;
-                    pidx++ ;
-                    crossOK = True ;
-                  }
-                }
-                else {
-                  polnos[pidx] = p[0] ;
-                  pidx++ ;
-                }
-              }
-              
-              // SRCTYPE
-              *srctypeRF = srcType ;
-
-              for ( Int irow = 0 ; irow < nrow ; irow++ ) {
-                // CYCLENO
-                *cycleRF = cycle ;
-
-                // FLAGROW
-                *flrRF = (uInt)asBool( "FLAG_ROW", irow, t5, tpoolr ) ;
-
-                // SPECTRA, FLAG
-                Matrix<Float> sp = spArr.xyPlane( irow ) ;
-                Matrix<Bool> flb = flArr.xyPlane( irow ) ;
-                Matrix<uChar> fl( flb.shape() ) ;
-                convertArray( fl, flb ) ;
-
-                // TIME
-                *timeRF = mTimeB[irow].get("d").getValue() ;
-
-                // INTERVAL
-                *intervalRF = asDouble( "INTERVAL", irow, t5, tpoolr ) ;
-
-                // TSYS
-                Matrix<Float> tsys ;
-                if ( sysCalIdx[irow] != -1 && colTsys_ != "NONE" )
-                  tsys = scTsysCol( sysCalIdx[irow] ) ;
-                else 
-                  tsys = defaulttsys ;
-
-                // TCAL_ID
-                Block<uInt> tcalids( npol, 0 ) ;
-                if ( sysCalIdx[irow] != -1 && colTcal_ != "NONE" ) {
-                  tcalids = getTcalId( feedId, spwId, scTime[sysCalIdx[irow]] ) ;
-                }
-
-                // WEATHER_ID
-                if ( isWeather_ ) {
-                  wid = getWeatherId( wid, mTimeB[irow].get("s").getValue() ) ;
-                  *widRF = mwIndex_[wid] ;
-                }
-                else {
-                  *widRF = wid ;
-                }
-                  
-
-                // DIRECTION, AZEL, SCANRATE
-                Vector<Double> dir ;
-                Vector<Double> azel ;
-                Vector<Double> scanrate = defaultScanrate ;
-                String refString ;
-                if ( getPt_ )
-                  diridx = getDirection( diridx, dir, azel, scanrate, pt, pdcol, mTimeB[irow], mp ) ;
-                else
-                  getSourceDirection( dir, azel, scanrate, mTimeB[irow], mp, delayDir ) ;
-                *dirRF = dir ;
-                *azRF = azel[0] ;
-                *elRF = azel[1] ;
-                *scrRF = scanrate ;
-
-                // Polarization dependent things
-                for ( Int ipol = 0 ; ipol < npol ; ipol++ ) {
-                  // POLNO
-                  *polnoRF = polnos[ipol] ;
-
-                  spRF.define( sp.row( ipol ) ) ;
-                  ucarrRF.define( fl.row( ipol ) ) ;
-                  tsysRF.define( tsys.row( ipol ) ) ;
-                  *tcalidRF = tcalids[ipol] ;
-
-                  // Commit row
-                  stab.addRow() ;
-                  row.put( stab.nrow()-1 ) ;
-                }
-
-                cycle++ ;
-              }
-              
-              //time1 = mathutil::gettimeofday_sec() ;
-              //os_ << "end 5th iteration: " << time1 << " (" << time1-time0 << "sec)" << LogIO::POST ;
-
-              iter5.next() ;
-            }
-            iter4.next() ;
-          }
-          iter3.next() ;
-        }
-        iter2.next() ;
-      }
-      iter1.next() ;
-    }
-    if ( sdh.nbeam < nbeam ) sdh.nbeam = nbeam ;
-
-    iter0.next() ;
-  }
-
-
-  delete tpoolr ;
-
-
-  // Table Keywords
-  sdh.nif = ifmap.size() ;
-  if ( ( telescopeName == "" ) || ( antennaName == telescopeName ) ) {
-    sdh.antennaname = antennaName ;
-  }
-  else {
-    sdh.antennaname = telescopeName + "//" + antennaName ;
-  }
-  if ( stationName != "" && stationName != antennaName ) {
-    sdh.antennaname += "@" + stationName ;
-  }
-  ROArrayColumn<Double> pdirCol( pointtab, "DIRECTION" ) ; 
-  String dirref = pdirCol.keywordSet().asRecord("MEASINFO").asString("Ref") ;
-  if ( dirref == "AZELGEO" || dirref == "AZEL" ) {
-    dirref = "J2000" ;
-  }
-  sscanf( dirref.chars()+1, "%f", &sdh.equinox ) ;
-  sdh.epoch = "UTC" ;
-  if (sdh.freqref == "TOPO") {
-    sdh.freqref = "TOPOCENT";
-  } else if (sdh.freqref == "GEO") {
-    sdh.freqref = "GEOCENTR";
-  } else if (sdh.freqref == "BARY") {
-    sdh.freqref = "BARYCENT";
-  } else if (sdh.freqref == "GALACTO") {
-    sdh.freqref = "GALACTOC";
-  } else if (sdh.freqref == "LGROUP") {
-    sdh.freqref = "LOCALGRP";
-  } else if (sdh.freqref == "CMB") {
-    sdh.freqref = "CMBDIPOL";
-  } else if (sdh.freqref == "REST") {
-    sdh.freqref = "SOURCE";
-  }
-
-  if ( sdh.fluxunit == "" || sdh.fluxunit == "CNTS" )
-    sdh.fluxunit = "K" ;
-  table_->setHeader( sdh ) ;
+  /***
+   * Start iteration using TableVisitor
+   ***/
+  Table stab = table_->table() ;
+  {
+    static const char *cols[] = {
+      "OBSERVATION_ID", "FEED1", "FIELD_ID", "DATA_DESC_ID", "SCAN_NUMBER", 
+      "STATE_ID", "TIME",
+      NULL
+    };
+    static const TypeManagerImpl<Int> tmInt;
+    static const TypeManagerImpl<Double> tmDouble;
+    static const TypeManager *const tms[] = {
+      &tmInt, &tmInt, &tmInt, &tmInt, &tmInt, &tmInt, &tmDouble, NULL
+    };
+    //double t0 = mathutil::gettimeofday_sec() ;
+    MSFillerVisitor myVisitor(mstable_, *table_ );
+    //double t1 = mathutil::gettimeofday_sec() ;
+    //cout << "MSFillerVisitor(): elapsed time " << t1-t0 << " sec" << endl ;
+    myVisitor.setAntenna( antenna_ ) ;
+    //myVisitor.setHeader( sdh ) ;
+    if ( getPt_ ) {
+      Table ptsel = pointtab( pointtab.col("ANTENNA_ID")==antenna_ ).sort( "TIME" ) ;
+      myVisitor.setPointingTable( ptsel ) ;
+    }
+    if ( isWeather_ )
+      myVisitor.setWeatherTime( mwTime_, mwInterval_ ) ;
+    if ( isSysCal_ ) 
+      myVisitor.setSysCalRecord( tcalrec_ ) ;
+    
+    //double t2 = mathutil::gettimeofday_sec() ;
+    traverseTable(mstable_, cols, tms, &myVisitor);
+    //double t3 = mathutil::gettimeofday_sec() ;
+    //cout << "traverseTable(): elapsed time " << t3-t2 << " sec" << endl ;
+    
+    sdh = myVisitor.getHeader() ;
+  }
+  /***
+   * End iteration using TableVisitor
+   ***/
+
+  // set header
+  //sdh = myVisitor.getHeader() ;
+  //table_->setHeader( sdh ) ;
 
   // save path to POINTING table
@@ -753 +1771 @@
 
   // for GBT
-  if ( antennaName.contains( "GBT" ) ) {
+  if ( sdh.antennaname.contains( "GBT" ) ) {
     String goTabName = datapath.absoluteName() + "/GBT_GO" ;
     stab.rwKeywordSet().define( "GBT_GO", goTabName ) ;
@@ -759 +1777 @@
 
   // for MS created from ASDM
-  //mstable_.keywordSet().print(cout) ;
   const TableRecord &msKeys = mstable_.keywordSet() ;
   uInt nfields = msKeys.nfields() ;
@@ -782 +1799 @@
   //tablesel_.unlock() ;
   mstable_.unlock() ;
-}
-
-Int MSFiller::getSrcType( Int stateId, boost::object_pool<ROTableColumn> *tpool ) 
-{
-  //double startSec = mathutil::gettimeofday_sec() ;
-  //os_ << "start MSFiller::getSrcType() startSec=" << startSec << LogIO::POST ;
-
-  MSState statetab = mstable_.state() ;
-  String obsMode = asString( "OBS_MODE", stateId, statetab, tpool ) ;
-  Bool sig = asBool( "SIG", stateId, statetab, tpool ) ;
-  Bool ref = asBool( "REF", stateId, statetab, tpool ) ;
-  Double cal = asDouble( "CAL", stateId, statetab, tpool ) ;
-  //os_ << "OBS_MODE = " << obsMode << LogIO::POST ;
-
-  // determine separator
-  String sep = "" ;
-  String tmpStr = obsMode.substr( 0, obsMode.find_first_of( "," ) ) ;
-  //os_ << "tmpStr = " << tmpStr << LogIO::POST ;
-  //if ( obsMode.find( ":" ) != String::npos ) {
-  if ( tmpStr.find( ":" ) != String::npos ) {
-    sep = ":" ;
-  }
-  //else if ( obsMode.find( "." ) != String::npos ) {
-  else if ( tmpStr.find( "." ) != String::npos ) {
-    sep = "." ;
-  }
-  else if ( tmpStr.find( "#" ) != String::npos ) {
-    sep = "#" ;
-  }
-  //else if ( obsMode.find( "_" ) != String::npos ) {
-  else if ( tmpStr.find( "_" ) != String::npos ) {
-    sep = "_" ;
-  }
-  //os_ << "separator = " << sep << LogIO::POST ;
-
-  // determine SRCTYPE
-  Int srcType = SrcType::NOTYPE ;
-  if ( sep == ":" ) {
-    // sep == ":"
-    // 
-    // GBT case 
-    //
-    // obsMode1=Nod
-    //    NOD
-    // obsMode1=OffOn
-    //    obsMode2=PSWITCHON:  PSON
-    //    obsMode2=PSWITCHOFF: PSOFF
-    // obsMode1=??
-    //    obsMode2=FSWITCH: 
-    //       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 ) ;
-    String obsMode1 = obsMode.substr( 0, epos ) ;
-    String obsMode2 = obsMode.substr( epos+1, nextpos-epos-1 ) ;
-    if ( obsMode1 == "Nod" ) {
-      srcType = SrcType::NOD ;
-    }
-    else if ( obsMode1 == "OffOn" ) {
-      if ( obsMode2 == "PSWITCHON" ) srcType = SrcType::PSON ;
-      if ( obsMode2 == "PSWITCHOFF" ) srcType = SrcType::PSOFF ;
-    }
-    else {
-      if ( obsMode2 == "FSWITCH" ) {
-        if ( sig ) srcType = SrcType::FSON ;
-        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 ;
-    }
-  }
-  else if ( sep == "." || sep == "#" ) {
-    // sep == "." or "#"
-    //
-    // ALMA & EVLA case (MS via ASDM) before3.1
-    //
-    // obsMode1=CALIBRATE_*
-    //    obsMode2=ON_SOURCE: PONCAL
-    //    obsMode2=OFF_SOURCE: POFFCAL
-    // obsMode1=OBSERVE_TARGET
-    //    obsMode2=ON_SOURCE: PON
-    //    obsMode2=OFF_SOURCE: POFF
-    string substr[2] ; 
-    int numSubstr = split( obsMode, substr, 2, "," ) ;
-    //os_ << "numSubstr = " << numSubstr << LogIO::POST ;
-    //for ( int i = 0 ; i < numSubstr ; i++ )
-    //os_ << "substr[" << i << "] = " << substr[i] << LogIO::POST ;
-    String obsType( substr[0] ) ;
-    //os_ << "obsType = " << obsType << LogIO::POST ;
-    Int epos = obsType.find_first_of( sep ) ;
-    Int nextpos = obsType.find_first_of( sep, epos+1 ) ;
-    String obsMode1 = obsType.substr( 0, epos ) ;
-    String obsMode2 = obsType.substr( epos+1, nextpos-epos-1 ) ;
-    //os_ << "obsMode1 = " << obsMode1 << LogIO::POST ;
-    //os_ << "obsMode2 = " << obsMode2 << LogIO::POST ;
-    if ( obsMode1.find( "CALIBRATE_" ) == 0 ) {
-      if ( obsMode2 == "ON_SOURCE" ) srcType = SrcType::PONCAL ;
-      if ( obsMode2 == "OFF_SOURCE" ) srcType = SrcType::POFFCAL ;
-    }
-    else if ( obsMode1 == "OBSERVE_TARGET" ) {
-      if ( obsMode2 == "ON_SOURCE" ) srcType = SrcType::PSON ;
-      if ( obsMode2 == "OFF_SOURCE" ) srcType = SrcType::PSOFF ;
-    }
-  }
-  else if ( sep == "_" ) {
-    // sep == "_"
-    //
-    // ALMA & EVLA case (MS via ASDM) after 3.2
-    //
-    // obsMode1=CALIBRATE_*
-    //    obsMode2=ON_SOURCE: PONCAL
-    //    obsMode2=OFF_SOURCE: POFFCAL
-    // obsMode1=OBSERVE_TARGET
-    //    obsMode2=ON_SOURCE: PON
-    //    obsMode2=OFF_SOURCE: POFF
-    string substr[2] ; 
-    int numSubstr = split( obsMode, substr, 2, "," ) ;
-    //os_ << "numSubstr = " << numSubstr << LogIO::POST ;
-    //for ( int i = 0 ; i < numSubstr ; i++ )
-    //os_ << "substr[" << i << "] = " << substr[i] << LogIO::POST ;
-    String obsType( substr[0] ) ;
-    //os_ << "obsType = " << obsType << LogIO::POST ;
-    string substr2[4] ;
-    int numSubstr2 = split( obsType, substr2, 4, sep ) ; 
-    //Int epos = obsType.find_first_of( sep ) ;
-    //Int nextpos = obsType.find_first_of( sep, epos+1 ) ;
-    //String obsMode1 = obsType.substr( 0, epos ) ;
-    //String obsMode2 = obsType.substr( epos+1, nextpos-epos-1 ) ;
-    String obsMode1( substr2[0] ) ;
-    String obsMode2( substr2[2] ) ;
-    //os_ << "obsMode1 = " << obsMode1 << LogIO::POST ;
-    //os_ << "obsMode2 = " << obsMode2 << LogIO::POST ;
-    if ( obsMode1.find( "CALIBRATE" ) == 0 ) {
-      if ( obsMode2 == "ON" ) srcType = SrcType::PONCAL ;
-      if ( obsMode2 == "OFF" ) srcType = SrcType::POFFCAL ;
-    }
-    else if ( obsMode1 == "OBSERVE" ) {
-      if ( obsMode2 == "ON" ) srcType = SrcType::PSON ;
-      if ( obsMode2 == "OFF" ) srcType = SrcType::PSOFF ;
-    }
-  }
-  else {
-    if ( sig ) srcType = SrcType::SIG ;
-    if ( ref ) srcType = SrcType::REF ;
-  }
-    
-  //os_ << "srcType = " << srcType << LogIO::POST ;
-  //double endSec = mathutil::gettimeofday_sec() ;
-  //os_ << "end MSFiller::getSrcType() endSec=" << endSec << " (" << endSec-startSec << "sec)" << LogIO::POST ;
-  return srcType ;
-}
-
-//Vector<uInt> MSFiller::getPolNo( Int corrType ) 
-Block<uInt> MSFiller::getPolNo( Int corrType ) 
-{
-  //double startSec = mathutil::gettimeofday_sec() ;
-  //os_ << "start MSFiller::getPolNo() startSec=" << startSec << LogIO::POST ;
-  Block<uInt> polno( 1 ) ;
-
-  if ( corrType == Stokes::I || corrType == Stokes::RR || corrType == Stokes::XX ) {
-    polno = 0 ;
-  }
-  else if ( corrType == Stokes::Q || corrType == Stokes::LL || corrType == Stokes::YY ) {
-    polno = 1 ;
-  }
-  else if ( corrType == Stokes::U ) {
-    polno = 2 ;
-  }
-  else if ( corrType == Stokes::V ) {
-    polno = 3 ;
-  }
-  else if ( corrType == Stokes::RL || corrType == Stokes::XY || corrType == Stokes::LR || corrType == Stokes::RL ) {
-    polno.resize( 2 ) ;
-    polno[0] = 2 ;
-    polno[1] = 3 ;
-  }
-  else if ( corrType == Stokes::Plinear ) {
-    polno[0] = 1 ;
-  }
-  else if ( corrType == Stokes::Pangle ) {
-    polno[0] = 2 ;
-  }
-  else {
-    polno = 99 ;
-  }
-  //os_ << "polno = " << polno << LogIO::POST ;
-  //double endSec = mathutil::gettimeofday_sec() ;
-  //os_ << "end MSFiller::getPolNo() endSec=" << endSec << " (" << endSec-startSec << "sec)" << LogIO::POST ;
-  
-  return polno ;
-}
-
-String MSFiller::getPolType( Int corrType ) 
-{
-  //double startSec = mathutil::gettimeofday_sec() ;
-  //os_ << "start MSFiller::getPolType() startSec=" << startSec << LogIO::POST ;
-  String poltype = "" ;
-
-  if ( corrType == Stokes::I || corrType == Stokes::Q || corrType == Stokes::U || corrType == Stokes::V )
-    poltype = "stokes" ;
-  else if ( corrType == Stokes::XX || corrType == Stokes::YY || corrType == Stokes::XY || corrType == Stokes::YX ) 
-    poltype = "linear" ;
-  else if ( corrType == Stokes::RR || corrType == Stokes::LL || corrType == Stokes::RL || corrType == Stokes::LR ) 
-    poltype = "circular" ;
-  else if ( corrType == Stokes::Plinear || corrType == Stokes::Pangle )
-    poltype = "linpol" ;
-
-  //double endSec = mathutil::gettimeofday_sec() ;
-  //os_ << "end MSFiller::getPolType() endSec=" << endSec << " (" << endSec-startSec << "sec)" << LogIO::POST ;
-  return poltype ;
 }
 
@@ -1164 +1958 @@
 }
 
-void MSFiller::fillTcal( boost::object_pool<ROTableColumn> *tpoolr )
+void MSFiller::fillTcal()
 {
   //double startSec = mathutil::gettimeofday_sec() ;
@@ -1189 +1983 @@
   }
 
-  Table sctab = mstable_.sysCal() ;
+  Table &sctab = mstable_.sysCal() ;
   if ( sctab.nrow() == 0 ) {
     os_ << "No SYSCAL rows" << LogIO::POST ;
     return ;
   } 
-  Table sctabsel( sctab( sctab.col("ANTENNA_ID") == antenna_ ) ) ;
-  if ( sctabsel.nrow() == 0 ) {
+  ROScalarColumn<Int> antCol( sctab, "ANTENNA_ID" ) ;
+  Vector<Int> ant = antCol.getColumn() ;
+  if ( allNE( ant, antenna_ ) ) {
     os_ << "No SYSCAL rows" << LogIO::POST ;
     return ;
   } 
-  ROArrayColumn<Float> *tmpTcalCol = new ROArrayColumn<Float>( sctabsel, colTcal_ ) ;
-  // return if any rows without Tcal value exists
+  ROTableColumn tcalCol( sctab, colTcal_ ) ;
   Bool notDefined = False ;
-  for ( uInt irow = 0 ; irow < sctabsel.nrow() ; irow++ ) {
-    if ( !tmpTcalCol->isDefined( irow ) ) {
+  for ( uInt irow = 0 ; irow < sctab.nrow() ; irow++ ) {
+    if ( ant[irow] == antenna_ && !tcalCol.isDefined( irow ) ) {
       notDefined = True ;
       break ;
@@ -1210 +2004 @@
   if ( notDefined ) {
     os_ << "No TCAL value" << LogIO::POST ;
-    delete tmpTcalCol ;
     table_->tcal().table().addRow(1,True) ;
     Vector<Float> defaultTcal( 1, 1.0 ) ;
@@ -1217 +2010 @@
     return ;
   }    
-  uInt npol = tmpTcalCol->shape( 0 )(0) ;
-  delete tmpTcalCol ;
-  //os_ << "fillTcal(): npol = " << npol << LogIO::POST ;
+  
+  static const char *cols[] = {
+    "ANTENNA_ID", "FEED_ID", "SPECTRAL_WINDOW_ID", "TIME",
+    NULL
+  };
+  static const TypeManagerImpl<Int> tmInt;
+  static const TypeManagerImpl<Double> tmDouble;
+  static const TypeManager *const tms[] = {
+    &tmInt, &tmInt, &tmInt, &tmDouble, NULL
+  };
   Table tab = table_->tcal().table() ;
-  ArrayColumn<Float> tcalCol( tab, "TCAL" ) ;
-  uInt oldnr = 0 ;
-  uInt newnr = 0 ;
-  TableRow row( tab ) ;
-  TableRecord &trec = row.record() ;
-  RecordFieldPtr<uInt> idRF( trec, "ID" ) ;
-  RecordFieldPtr<String> timeRF( trec, "TIME" ) ;
-  RecordFieldPtr< Array<Float> > tcalRF( trec, "TCAL" ) ;
-  TableIterator iter0( sctabsel, "FEED_ID" ) ;
-  while( !iter0.pastEnd() ) {
-    Table t0 = iter0.table() ;
-    Int feedId = asInt( "FEED_ID", 0, t0, tpoolr ) ;
-    TableIterator iter1( t0, "SPECTRAL_WINDOW_ID" ) ;
-    while( !iter1.pastEnd() ) {
-      Table t1 = iter1.table() ;
-      Int spwId = asInt( "SPECTRAL_WINDOW_ID", 0, t1, tpoolr ) ;
-      tmpTcalCol = new ROArrayColumn<Float>( t1, colTcal_ ) ;
-      ROScalarQuantColumn<Double> scTimeCol( t1, "TIME" ) ;
-      Vector<uInt> idminmax( 2, oldnr ) ;
-      for ( uInt irow = 0 ; irow < t1.nrow() ; irow++ ) {
-        String sTime = MVTime( scTimeCol(irow) ).string( MVTime::YMD ) ;
-        *timeRF = sTime ;
-        uInt idx = oldnr ;
-        Matrix<Float> subtcal = (*tmpTcalCol)( irow ) ;
-        for ( uInt ipol = 0 ; ipol < npol ; ipol++ ) {
-          *idRF = idx++ ;
-          //*tcalRF = subtcal.row( ipol ) ;
-          tcalRF.define( subtcal.row( ipol ) ) ;
-
-          // commit row
-          tab.addRow() ;
-          row.put( tab.nrow()-1 ) ;
-
-          newnr++ ;
-        }
-        idminmax[0] = oldnr ;
-        idminmax[1] = newnr - 1 ;
-        oldnr = newnr ;
-
-        String key = keyTcal( feedId, spwId, sTime ) ;
-        tcalrec_.define( key, idminmax ) ;
-      }
-      delete tmpTcalCol ;
-      iter1++ ;
-    }
-    iter0++ ;
-  }
+  TcalVisitor visitor( sctab, tab, tcalrec_, antenna_ ) ;
+  visitor.setTcalColumn( colTcal_ ) ;
+  
+  traverseTable(sctab, cols, tms, &visitor);
 
   //tcalrec_.print( std::cout ) ;
   //double endSec = mathutil::gettimeofday_sec() ;
   //os_ << "end MSFiller::fillTcal() endSec=" << endSec << " (" << endSec-startSec << "sec)" << LogIO::POST ;
-}
-
-uInt MSFiller::getWeatherId( uInt idx, Double wtime ) 
-{
-  //double startSec = mathutil::gettimeofday_sec() ;
-  //os_ << "start MSFiller::getWeatherId() startSec=" << startSec << LogIO::POST ;
-  uInt nrow = mwTime_.size() ;
-  if ( nrow < 2 ) 
-    return 0 ;
-  uInt wid = nrow ;
-  if ( idx == 0 ) {
-    wid = 0 ;
-    Double tStart = mwTime_[wid]-0.5*mwInterval_[wid] ;
-    if ( wtime < tStart )
-      return wid ;
-  }
-  for ( uInt i = idx ; i < nrow-1 ; i++ ) {
-    Double tStart = mwTime_[i]-0.5*mwInterval_[i] ;
-    // use of INTERVAL column is problematic 
-    // since there are "blank" time of weather monitoring
-    //Double tEnd = tStart + mwInterval_[i] ;
-    Double tEnd = mwTime_[i+1]-0.5*mwInterval_[i+1] ;
-    //os_ << "tStart = " << tStart << " dtEnd = " << tEnd-tStart << " dwtime = " << wtime-tStart << LogIO::POST ;
-    if ( wtime >= tStart && wtime <= tEnd ) {
-      wid = i ;
-      break ;
-    }
-  }
-  if ( wid == nrow ) {
-    uInt i = nrow - 1 ;
-    Double tStart = mwTime_[i-1]+0.5*mwInterval_[i-1] ;
-    Double tEnd = mwTime_[i]+0.5*mwInterval_[i] ;
-    //os_ << "tStart = " << tStart << " dtEnd = " << tEnd-tStart << " dwtime = " << wtime-tStart << LogIO::POST ;
-    if ( wtime >= tStart && wtime <= tEnd )
-      wid = i-1 ;
-    else 
-      wid = i ;
-  }
-
-  //if ( wid == nrow ) 
-  //os_ << LogIO::WARN << "Couldn't find correct WEATHER_ID for time " << wtime << LogIO::POST ;
-
-  //double endSec = mathutil::gettimeofday_sec() ;
-  //os_ << "end MSFiller::getWeatherId() endSec=" << endSec << " (" << endSec-startSec << "sec)" << LogIO::POST ;
-  return wid ;
-}
-
-void MSFiller::getSysCalTime( Vector<MEpoch> &scTime, Vector<Double> &scInterval, Block<MEpoch> &tcol, Block<Int> &tidx )
-{
-  //double startSec = mathutil::gettimeofday_sec() ;
-  //os_ << "start MSFiller::getSysCalTime() startSec=" << startSec << LogIO::POST ;
-
-  if ( !isSysCal_ )
-    return ;
-
-  uInt nrow = tidx.nelements() ;
-  if ( scTime.nelements() == 0 ) 
-    return ;
-  else if ( scTime.nelements() == 1 ) {
-    tidx[0] = 0 ;
-    return ;
-  }
-  uInt scnrow = scTime.nelements() ;
-  uInt idx = 0 ;
-  const Double half = 0.5e0 ;
-  // execute  binary search
-  idx = binarySearch( scTime, tcol[0].get( "s" ).getValue() ) ;
-  if ( idx != 0 )
-    idx -= 1 ;
-  for ( uInt i = 0 ; i < nrow ; i++ ) {
-    Double t = tcol[i].get( "s" ).getValue() ;
-    Double tsc = scTime[0].get( "s" ).getValue() ;
-    if ( t < tsc ) {
-      tidx[i] = 0 ;
-      continue ;
-    }
-    for ( uInt j = idx ; j < scnrow-1 ; j++ ) {
-      Double tsc1 = scTime[j].get( "s" ).getValue() ;
-      Double dt1 = scInterval[j] ;
-      Double tsc2 = scTime[j+1].get( "s" ).getValue() ;
-      Double dt2 = scInterval[j+1] ;
-      if ( t > tsc1-half*dt1 && t <= tsc2-half*dt2 ) {
-        tidx[i] = j ;
-        idx = j ;
-        break ;
-      }
-    }
-    if ( tidx[i] == -1 ) {
-//       Double tsc = scTime[scnrow-1].get( "s" ).getValue() ;
-//       Double dt = scInterval[scnrow-1] ;
-//       if ( t <= tsc+0.5*dt ) {
-//         tidx[i] = scnrow-1 ;
-//       }
-      tidx[i] = scnrow-1 ;
-    }
-  }
-  //double endSec = mathutil::gettimeofday_sec() ;
-  //os_ << "end MSFiller::getSysCalTime() endSec=" << endSec << " (" << endSec-startSec << "sec) scnrow = " << scnrow << " tcol.nelements = " << tcol.nelements() << LogIO::POST ;
-  return ;
-}
-
-Block<uInt> MSFiller::getTcalId( Int fid, Int spwid, MEpoch &t ) 
-{
-  //double startSec = mathutil::gettimeofday_sec() ;
-  //os_ << "start MSFiller::getTcalId() startSec=" << startSec << LogIO::POST ;
-  //if ( table_->tcal().table().nrow() == 0 ) {
-  if ( !isSysCal_ ) {
-    os_ << "No TCAL rows" << LogIO::POST ;
-    Block<uInt> tcalids( 4, 0 ) ;
-    return  tcalids ;
-  }    
-  //String sctime = MVTime( Quantum<Double>(t,"s") ).string(MVTime::YMD) ;
-  String sctime = MVTime( t.getValue() ).string(MVTime::YMD) ;
-  String key = keyTcal( fid, spwid, sctime ) ;
-  if ( !tcalrec_.isDefined( key ) ) {
-    os_ << "No TCAL rows" << LogIO::POST ;
-    Block<uInt> tcalids( 4, 0 ) ;
-    return tcalids ;
-  }
-  Vector<uInt> ids = tcalrec_.asArrayuInt( key ) ;
-  uInt npol = ids[1] - ids[0] + 1 ;
-  Block<uInt> tcalids( npol ) ;
-  tcalids[0] = ids[0] ;
-  tcalids[1] = ids[1] ;
-  for ( uInt ipol = 2 ; ipol < npol ; ipol++ )
-    tcalids[ipol] = ids[0] + ipol - 1 ;
-
-  //double endSec = mathutil::gettimeofday_sec() ;
-  //os_ << "end MSFiller::getTcalId() endSec=" << endSec << " (" << endSec-startSec << "sec)" << LogIO::POST ;
-  return tcalids ;
-}
-
-uInt MSFiller::getDirection( uInt idx, 
-                             Vector<Double> &dir, 
-                             Vector<Double> &srate, 
-                             String &ref, 
-                             Vector<Double> &tcol, 
-                             ROArrayColumn<Double> &dcol, 
-                             Double t ) 
-{
-  //double startSec = mathutil::gettimeofday_sec() ;
-  //os_ << "start MSFiller::getDirection1() startSec=" << startSec << LogIO::POST ;
-  //double time0 = mathutil::gettimeofday_sec() ;
-  //os_ << "start getDirection 1st stage startSec=" << time0 << LogIO::POST ;
-  // assume that cols is sorted by TIME
-  Bool doInterp = False ;
-  uInt nrow = dcol.nrow() ;
-  if ( nrow == 0 ) 
-    return 0 ;
-  if ( idx == 0 ) {
-    uInt nrowb = 1000 ;
-    if ( nrow > nrowb ) {
-      uInt nblock = nrow / nrowb + 1 ;
-      for ( uInt iblock = 0 ; iblock < nblock ; iblock++ ) {
-        uInt high = min( nrowb, nrow-iblock*nrowb ) ;
-
-        if ( tcol( high-1 ) < t ) {
-          idx = iblock * nrowb ;
-          continue ;
-        }
-
-        Slice slice( iblock*nrowb, nrowb ) ;
-        Vector<Double> tarr = tcol( slice ) ;
-
-        uInt bidx = binarySearch( tarr, t ) ;
-
-        idx = iblock * nrowb + bidx ;
-        break ;
-      }
-    }
-    else {
-      idx = binarySearch( tcol, t ) ;
-    }
-  }
-  //double time1 = mathutil::gettimeofday_sec() ;
-  //os_ << "end getDirection 1st stage endSec=" << time1 << " (" << time1-time0 << "sec)" << LogIO::POST ;
-  // ensure that tcol(idx) < t
-  //os_ << "tcol(idx) = " << tcol(idx).get("s").getValue() << " t = " << t << " diff = " << tcol(idx).get("s").getValue()-t << endl ;
-  //time0 = mathutil::gettimeofday_sec() ;
-  //os_ << "start getDirection 2nd stage startSec=" << time0 << LogIO::POST ;
-  //while( tcol( idx ) * factor > t && idx > 0 )
-  while( tcol[idx] > t && idx > 0 )
-    idx-- ;
-  //os_ << "idx = " << idx << LogIO::POST ;
-
-  // index search
-  for ( uInt i = idx ; i < nrow ; i++ ) {
-    Double tref = tcol[i] ;
-    if ( tref == t ) {
-      idx = i ;
-      break ;
-    }
-    else if ( tref > t ) {
-      if ( i == 0 ) {
-        idx = i ;
-      }
-      else {
-        idx = i-1 ;
-        doInterp = True ;
-      }
-      break ;
-    }
-    else {
-      idx = nrow - 1 ;
-    }
-  }
-  //time1 = mathutil::gettimeofday_sec() ;
-  //os_ << "end getDirection 2nd stage endSec=" << time1 << " (" << time1-time0 << "sec)" << LogIO::POST ;
-  //os_ << "searched idx = " << idx << LogIO::POST ;
-
-  //time0 = mathutil::gettimeofday_sec() ;
-  //os_ << "start getDirection 3rd stage startSec=" << time0 << LogIO::POST ;
-  //os_ << "dmcol(idx).shape() = " << dmcol(idx).shape() << LogIO::POST ;
-  //IPosition ip( dmcol(idx).shape().nelements(), 0 ) ;
-  IPosition ip( dcol(idx).shape().nelements(), 0 ) ;
-  //os_ << "ip = " << ip << LogIO::POST ;
-  //ref = dmcol(idx)(ip).getRefString() ;
-  TableRecord trec = dcol.keywordSet() ;
-  Record rec = trec.asRecord( "MEASINFO" ) ;
-  ref = rec.asString( "Ref" ) ;
-  //os_ << "ref = " << ref << LogIO::POST ;
-  if ( doInterp ) {
-    //os_ << "do interpolation" << LogIO::POST ;
-    //os_ << "dcol(idx).shape() = " << dcol(idx).shape() << LogIO::POST ;
-    Double tref0 = tcol[idx] ;
-    Double tref1 = tcol[idx+1] ;
-    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 = 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 ( mdir0.ncolumn() > 1 ) {
-      if ( dt0 >= dt1 )
-        srate.reference( mdir0.column( 1 ) ) ;
-      else
-        srate.reference( mdir1.column( 1 ) ) ;
-    }
-    //os_ << "dir = " << dir << LogIO::POST ; 
-  }
-  else {
-    //os_ << "no interpolation" << LogIO::POST ;
-    Matrix<Double> mdir0 = dcol( idx ) ;
-    dir.reference( mdir0.column( 0 ) ) ;
-    if ( mdir0.ncolumn() > 1 )
-      srate.reference( mdir0.column( 1 ) ) ;
-  }
-
-  //time1 = mathutil::gettimeofday_sec() ;
-  //os_ << "end getDirection 3rd stage endSec=" << time1 << " (" << time1-time0 << "sec)" << LogIO::POST ;
-  //double endSec = mathutil::gettimeofday_sec() ;
-  //os_ << "end MSFiller::getDirection1() endSec=" << endSec << " (" << endSec-startSec << "sec)" << LogIO::POST ;
-  return idx ;
-}
-
-String MSFiller::keyTcal( Int feedid, Int spwid, String stime ) 
-{
-  String sfeed = "FEED" + String::toString( feedid ) ;
-  String sspw = "SPW" + String::toString( spwid ) ;
-  return sfeed+":"+sspw+":"+stime ;
-}
-
-uInt MSFiller::binarySearch( Vector<MEpoch> &timeList, Double target ) 
-{
-  Int low = 0 ;
-  Int high = timeList.nelements() ;
-  uInt idx = 0 ;
-
-  while ( low <= high ) {
-    idx = (Int)( 0.5 * ( low + high ) ) ;
-    Double t = timeList[idx].get( "s" ).getValue() ;
-    if ( t < target ) 
-      low = idx + 1 ;
-    else if ( t > target )
-      high = idx - 1 ;
-    else {
-      return idx ;
-    }
-  }
-
-  idx = max( 0, min( low, high ) ) ;
-
-  return idx ;
-}
-
-uInt MSFiller::binarySearch( Vector<Double> &timeList, Double target ) 
-{
-  Int low = 0 ;
-  Int high = timeList.nelements() ;
-  uInt idx = 0 ;
-
-  while ( low <= high ) {
-    idx = (Int)( 0.5 * ( low + high ) ) ;
-    Double t = timeList[idx] ;
-    if ( t < target ) 
-      low = idx + 1 ;
-    else if ( t > target )
-      high = idx - 1 ;
-    else {
-      return idx ;
-    }
-  }
-
-  idx = max( 0, min( low, high ) ) ;
-
-  return idx ;
 }
 
@@ -1603 +2051 @@
 }
 
-void MSFiller::reshapeSpectraAndFlagtra( Cube<Float> &sp,
-                                         Cube<Bool> &fl,
-                                         Table &tab,
-                                         Int &npol,
-                                         Int &nchan,
-                                         Int &nrow,
-                                         Vector<Int> &corrtype )
-{
-  //double startSec = mathutil::gettimeofday_sec() ;
-  //os_ << "start MSFiller::reshapeSpectraAndFlagtra() startSec=" << startSec << LogIO::POST ;  
-  if ( isFloatData_ ) {
-    ROArrayColumn<Bool> mFlagCol( tab, "FLAG" ) ;
-    ROArrayColumn<Float> mFloatDataCol( tab, "FLOAT_DATA" ) ;
-    mFloatDataCol.getColumn( sp ) ;
-    mFlagCol.getColumn( fl ) ;
-  }
-  else if ( isData_ ) {
-    sp.resize( npol, nchan, nrow ) ;
-    fl.resize( npol, nchan, nrow ) ;
-    ROArrayColumn<Bool> mFlagCol( tab, "FLAG" ) ;
-    ROArrayColumn<Complex> mDataCol( tab, "DATA" ) ;
-    if ( npol < 3 ) {
-      Cube<Float> tmp = ComplexToReal( mDataCol.getColumn() ) ;
-      IPosition start( 3, 0, 0, 0 ) ;
-      IPosition end( 3, 2*npol-1, nchan-1, nrow-1 ) ;
-      IPosition inc( 3, 2, 1, 1 ) ;
-      sp = tmp( start, end, inc ) ;
-      fl = mFlagCol.getColumn() ;
-    }
-    else {
-      for ( Int irow = 0 ; irow < nrow ; irow++ ) {
-        Bool crossOK = False ;
-        Matrix<Complex> mSp = mDataCol( irow ) ;
-        Matrix<Bool> mFl = mFlagCol( irow ) ;
-        Matrix<Float> spxy = sp.xyPlane( irow ) ;
-        Matrix<Bool> flxy = fl.xyPlane( 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 ) {
-              Vector<Float> tmp = ComplexToReal( mSp.row( ipol ) ) ;
-              IPosition start( 1, 0 ) ;
-              IPosition end( 1, 2*nchan-1 ) ;
-              IPosition inc( 1, 2 ) ;
-              spxy.row( ipol ) = tmp( start, end, inc ) ;
-              flxy.row( ipol ) = mFl.row( ipol ) ;
-              start = IPosition( 1, 1 ) ;
-              spxy.row( ipol+1 ) = tmp( start, end, inc ) ;
-              flxy.row( ipol+1 ) = mFl.row( ipol ) ;
-              if ( corrtype[ipol] == Stokes::YX || corrtype[ipol] == Stokes::LR ) {
-                spxy.row( ipol+1 ) = spxy.row( ipol+1 ) * (Float)-1.0 ;
-              }
-              crossOK = True ;
-            }
-          }
-          else {
-            Vector<Float> tmp = ComplexToReal( mSp.row( ipol ) ) ;
-            IPosition start( 1, 0 ) ;
-            IPosition end( 1, 2*nchan-1 ) ;
-            IPosition inc( 1, 2 ) ;
-            spxy.row( ipol ) = tmp( start, end, inc ) ;
-            flxy.row( ipol ) = mFl.row( ipol ) ;
-          }
-        }
-      }
-    }
-  }
-  //double endSec = mathutil::gettimeofday_sec() ;
-  //os_ << "end MSFiller::reshapeSpectraAndFlagtra() endSec=" << endSec << " (" << endSec-startSec << "sec)" << LogIO::POST ;
-}
-
-uInt MSFiller::getDirection( uInt idx,
-                             Vector<Double> &dir,
-                             Vector<Double> &azel,
-                             Vector<Double> &srate,
-                             Vector<Double> &ptcol,
-                             ROArrayColumn<Double> &pdcol,
-                             MEpoch &t,
-                             MPosition &antpos )
-{
-  //double startSec = mathutil::gettimeofday_sec() ;
-  //os_ << "start MSFiller::getDirection2() startSec=" << startSec << LogIO::POST ;  
-  String refString ;
-  MDirection::Types dirType ;
-  uInt diridx = getDirection( idx, dir, srate, refString, ptcol, pdcol, t.get("s").getValue() ) ;
-  MDirection::getType( dirType, refString ) ;
-  MeasFrame mf( t, antpos ) ;
-  if ( refString == "J2000" ) {
-    MDirection::Convert toazel( dirType, MDirection::Ref( MDirection::AZEL, mf ) ) ;
-    azel = toazel( dir ).getAngle("rad").getValue() ;
-  }
-  else if ( refString(0,4) == "AZEL" ) {
-    azel = dir.copy() ;
-    MDirection::Convert toj2000( dirType, MDirection::Ref( MDirection::J2000, mf ) ) ;
-    dir = toj2000( dir ).getAngle("rad").getValue() ;
-  }
-  else {
-    MDirection::Convert toazel( dirType, MDirection::Ref( MDirection::AZEL, mf ) ) ;
-    azel = toazel( dir ).getAngle("rad").getValue() ;
-    MDirection::Convert toj2000( dirType, MDirection::Ref( MDirection::J2000, mf ) ) ;
-    dir = toj2000( dir ).getAngle("rad").getValue() ;
-  }
-  if ( srate.size() == 0 ) {
-    srate.resize( 2 ) ;
-    srate = 0.0 ;
-  }
-  //double endSec = mathutil::gettimeofday_sec() ;
-  //os_ << "end MSFiller::getDirection2() endSec=" << endSec << " (" << endSec-startSec << "sec)" << LogIO::POST ;
-  return diridx ;
-}
-
-void MSFiller::getSourceDirection( Vector<Double> &dir, 
-                                   Vector<Double> &azel, 
-                                   Vector<Double> &srate, 
-                                   MEpoch &t, 
-                                   MPosition &antpos, 
-                                   Vector<MDirection> &srcdir ) 
-{
-  //double startSec = mathutil::gettimeofday_sec() ;
-  //os_ << "start MSFiller::getSourceDirection() startSec=" << startSec << LogIO::POST ; 
-  Vector<Double> defaultDir = srcdir[0].getAngle( "rad" ).getValue() ;
-  if ( srcdir.nelements() > 1 ) 
-    srate = srcdir[1].getAngle( "rad" ).getValue() ;
-  String ref = srcdir[0].getRefString() ;
-  MDirection::Types dirType ;
-  MDirection::getType( dirType, ref ) ;
-  MeasFrame mf( t, antpos ) ;
-  if ( ref != "J2000" ) {
-    MDirection::Convert toj2000( dirType, MDirection::Ref( MDirection::J2000, mf ) ) ;
-    dir = toj2000( defaultDir ).getAngle("rad").getValue() ;
-  }
-  else 
-    dir = defaultDir ;
-  MDirection::Convert toazel( dirType, MDirection::Ref( MDirection::AZELGEO, mf ) ) ;
-  azel = toazel( defaultDir ).getAngle("rad").getValue() ;
-  //double endSec = mathutil::gettimeofday_sec() ;
-  //os_ << "end MSFiller::getSourceDirection() endSec=" << endSec << " (" << endSec-startSec << "sec)" << LogIO::POST ;
-}
-
 void MSFiller::initHeader( STHeader &header )
 {
@@ -1752 +2061 @@
   header.obstype = "" ;
   header.antennaname = "" ;
-  header.antennaposition.resize( 0 ) ;
+  header.antennaposition.resize( 3 ) ;
   header.equinox = 0.0 ;
   header.freqref = "" ;
@@ -1763 +2072 @@
 }
 
-String MSFiller::asString( String name,
-                           uInt idx,
-                           Table tab,
-                           boost::object_pool<ROTableColumn> *pool )
-{
-  ROTableColumn *col = pool->construct( tab, name ) ;
-  String v = col->asString( idx ) ;
-  pool->destroy( col ) ;
-  return v ;
-}
-
-Bool MSFiller::asBool( String name,
-                         uInt idx,
-                         Table &tab,
-                         boost::object_pool<ROTableColumn> *pool )
-{
-  ROTableColumn *col = pool->construct( tab, name ) ;
-  Bool v = col->asBool( idx ) ;
-  pool->destroy( col ) ;
-  return v ;
-}
-
-uInt MSFiller::asuInt( String name,
-                         uInt idx,
-                         Table &tab,
-                         boost::object_pool<ROTableColumn> *pool )
-{
-  ROTableColumn *col = pool->construct( tab, name ) ;
-  uInt v = col->asuInt( idx ) ;
-  pool->destroy( col ) ;
-  return v ;
-}
-
-Int MSFiller::asInt( String name,
-                        uInt idx,
-                        Table &tab,
-                        boost::object_pool<ROTableColumn> *pool )
-{
-  ROTableColumn *col = pool->construct( tab, name ) ;
-  Int v = col->asInt( idx ) ;
-  pool->destroy( col ) ;
-  return v ;
-}
-
-Float MSFiller::asFloat( String name,
-                          uInt idx,
-                          Table &tab,
-                          boost::object_pool<ROTableColumn> *pool )
-{
-  ROTableColumn *col = pool->construct( tab, name ) ;
-  Float v = col->asfloat( idx ) ;
-  pool->destroy( col ) ;
-  return v ;
-}
-
-Double MSFiller::asDouble( String name,
-                           uInt idx,
-                           Table &tab,
-                           boost::object_pool<ROTableColumn> *pool )
-{
-  ROTableColumn *col = pool->construct( tab, name ) ;
-  Double v = col->asdouble( idx ) ;
-  pool->destroy( col ) ;
-  return v ;
-}
-
-void MSFiller::sourceInfo( Int sourceId,
-                           Int spwId,
-                           String &name, 
-                           MDirection &direction,
-                           Vector<casa::Double> &properMotion,
-                           Vector<casa::Double> &restFreqs,
-                           Vector<casa::String> &transitions,
-                           Vector<casa::Double> &sysVels,
-                           boost::object_pool<ROTableColumn> *tpoolr ) 
-{
-  //double startSec = mathutil::gettimeofday_sec() ;
-  //os_ << "start MSFiller::sourceInfo() startSec=" << startSec << LogIO::POST ; 
-
-  MSSource srctab = mstable_.source() ;
-  MSSource srctabSel = srctab( srctab.col("SOURCE_ID") == sourceId && srctab.col("SPECTRAL_WINDOW_ID") == spwId ) ;
-  if ( srctabSel.nrow() == 0 ) {
-    srctabSel = srctab( srctab.col("SOURCE_ID") == sourceId && srctab.col("SPECTRAL_WINDOW_ID") == -1 ) ;
-  }
-  Int numLines = 0 ;
-  if ( srctabSel.nrow() > 0 ) {
-    // source name
-    name = asString( "NAME", 0, srctabSel, tpoolr ) ;
-    
-    // source proper motion
-    ROArrayColumn<Double> roArrDCol( srctabSel, "PROPER_MOTION" ) ;
-    properMotion = roArrDCol( 0 ) ;
-    
-    // source direction as MDirection object
-    ROScalarMeasColumn<MDirection> tmpMeasCol( srctabSel, "DIRECTION" ) ;
-    direction = tmpMeasCol( 0 ) ;
-    
-    // number of lines
-    numLines = asInt( "NUM_LINES", 0, srctabSel, tpoolr ) ;
-  }
-  else {
-    name = "" ;
-    properMotion = Vector<Double>( 2, 0.0 ) ;
-    direction = MDirection( Quantum<Double>(0.0,Unit("rad")), Quantum<Double>(0.0,Unit("rad")) ) ;
-  }
-
-  restFreqs.resize( numLines ) ;
-  transitions.resize( numLines ) ;
-  sysVels.resize( numLines ) ;
-  if ( numLines > 0 ) {
-    if ( srctabSel.tableDesc().isColumn( "REST_FREQUENCY" ) ) {
-      ROArrayQuantColumn<Double> quantArrCol( srctabSel, "REST_FREQUENCY" ) ;
-      Array< Quantum<Double> > qRestFreqs = quantArrCol( 0 ) ;
-      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" ) ) {
-      ROArrayColumn<String> transitionCol( srctabSel, "TRANSITION" ) ;
-      if ( transitionCol.isDefined( 0 ) )
-        transitions = transitionCol( 0 ) ;
-      //os_ << "transitionNameCol.nrow() = " << transitionCol.nrow() << LogIO::POST ;
-    }
-    if ( srctabSel.tableDesc().isColumn( "SYSVEL" ) ) {
-      ROArrayColumn<Double> roArrDCol( srctabSel, "SYSVEL" ) ;
-      sysVels = roArrDCol( 0 ) ;
-    }
-  }
-  
-  //double endSec = mathutil::gettimeofday_sec() ;
-  //os_ << "end MSFiller::sourceInfo() endSec=" << endSec << " (" << endSec-startSec << "sec)" << LogIO::POST ;
-}
-
-void MSFiller::spectralSetup( Int spwId,
-                              MEpoch &me,
-                              MPosition &mp,
-                              MDirection &md,
-                              Double &refpix,
-                              Double &refval,
-                              Double &increment,
-                              Int &nchan,
-                              String &freqref,
-                              Double &reffreq,
-                              Double &bandwidth,
-                              boost::object_pool<ROTableColumn> *tpoolr ) 
-{
-  //double startSec = mathutil::gettimeofday_sec() ;
-  //os_ << "start MSFiller::spectralSetup() startSec=" << startSec << LogIO::POST ; 
-
-  MSSpectralWindow spwtab = mstable_.spectralWindow() ;
-  MeasFrame mf( me, mp, md ) ;
-  MFrequency::Types freqRef = MFrequency::castType( (uInt)asInt( "MEAS_FREQ_REF", spwId, spwtab, tpoolr ) ) ;
-  Bool even = False ;
-  if ( (nchan/2)*2 == nchan ) even = True ;
-  ROScalarQuantColumn<Double> tmpQuantCol( spwtab, "TOTAL_BANDWIDTH" ) ;
-  Double totbw = tmpQuantCol( spwId ).getValue( "Hz" ) ;
-  if ( nchan != 4 )
-    bandwidth = max( bandwidth, totbw ) ;
-  if ( freqref == "" && nchan != 4) 
-    //sdh.freqref = MFrequency::showType( freqRef ) ;
-    freqref = "LSRK" ;
-  if ( reffreq == -1.0 && nchan != 4 ) {
-    tmpQuantCol.attach( spwtab, "REF_FREQUENCY" ) ;
-    Quantum<Double> qreffreq = tmpQuantCol( spwId ) ;
-    if ( freqRef == MFrequency::LSRK ) {
-      reffreq = qreffreq.getValue("Hz") ;
-    }
-    else {
-      MFrequency::Convert tolsr( freqRef, MFrequency::Ref( MFrequency::LSRK, mf ) ) ;
-      reffreq = tolsr( qreffreq ).get("Hz").getValue() ; 
-    }
-  }
-  Int refchan = nchan / 2 ;
-  IPosition refip( 1, refchan ) ;
-  refpix = 0.5*(nchan-1) ;
-  refval = 0.0 ;
-  ROArrayQuantColumn<Double> sharedQDArrCol( spwtab, "CHAN_WIDTH" ) ;
-  ROTableColumn netSidebandCol( spwtab, "NET_SIDEBAND" ) ;
-  Int netSideband = netSidebandCol.asInt( spwId ) ;
-  increment = sharedQDArrCol( spwId )( refip ).getValue( "Hz" ) ;
-  //           os_ << "nchan = " << nchan << " refchan = " << refchan << "(even=" << even << ") refpix = " << refpix << LogIO::POST ;
-  sharedQDArrCol.attach( spwtab, "CHAN_FREQ" ) ;
-  Vector< Quantum<Double> > chanFreqs = sharedQDArrCol( spwId ) ;
-  if ( ( nchan > 1 && 
-         chanFreqs[0].getValue("Hz") > chanFreqs[1].getValue("Hz")  ) 
-       || ( nchan == 1 && netSideband == 1 ) )  
-    increment *= -1.0 ;
-  if ( freqRef == MFrequency::LSRK ) {
-    if ( even ) {
-      IPosition refip0( 1, refchan-1 ) ;
-      Double refval0 = chanFreqs(refip0).getValue("Hz") ;
-      Double refval1 = chanFreqs(refip).getValue("Hz") ;
-      refval = 0.5 * ( refval0 + refval1 ) ;
-    }
-    else {
-      refval = chanFreqs(refip).getValue("Hz") ;
-    }
-  }
-  else {
-    MFrequency::Convert tolsr( freqRef, MFrequency::Ref( MFrequency::LSRK, mf ) ) ;
-    if ( even ) {
-      IPosition refip0( 1, refchan-1 ) ;
-      Double refval0 = chanFreqs(refip0).getValue("Hz") ;
-      Double refval1 = chanFreqs(refip).getValue("Hz") ;
-      refval = 0.5 * ( refval0 + refval1 ) ;
-      refval = tolsr( refval ).get("Hz").getValue() ;
-    }
-    else {
-      refval = tolsr( chanFreqs(refip) ).get("Hz").getValue() ;
-    }
-  }
-  
-  //double endSec = mathutil::gettimeofday_sec() ;
-  //os_ << "end MSFiller::spectralSetup() endSec=" << endSec << " (" << endSec-startSec << "sec)" << LogIO::POST ;
-}
-
-} ;
-
+};

trunk/src/MSFiller.h

@@ -16 +16 @@
 // STL
 #include <string>
-
-// Boost
-#include <boost/pool/object_pool.hpp>
 
 // AIPS++
@@ -27 +24 @@
 #include <casa/Arrays/Cube.h>
 #include <casa/Logging/LogIO.h>
-
+#include <casa/Containers/RecordField.h>
 #include <casa/Containers/Record.h>
 #include <casa/Containers/Block.h>
+#include <casa/Quanta/MVTime.h>
 
 #include <ms/MeasurementSets/MeasurementSet.h>
 #include <ms/MeasurementSets/MSPointing.h>
 
+#include <tables/Tables/ScalarColumn.h>
+#include <tables/Tables/ArrayColumn.h>
+#include <tables/Tables/TableRow.h>
+
+#include <measures/TableMeasures/ScalarMeasColumn.h>
+#include <measures/TableMeasures/ArrayMeasColumn.h>
+#include <measures/TableMeasures/ScalarQuantColumn.h>
+#include <measures/TableMeasures/ArrayQuantColumn.h>
+
+#include "TableTraverse.h"
 #include "Scantable.h"
+#include "MathUtils.h"
+
+using namespace casa;
 
 namespace asap
 {
+
+class MSFillerUtils {
+protected:
+  template<class T> void getScalar( const String &name, 
+                                    const uInt &idx, 
+                                    const Table &tab, 
+                                    T &val )
+  {
+    ROScalarColumn<T> col( tab, name ) ;
+    val = col( idx ) ;
+  }
+  template<class T> void getArray( const String &name, 
+                                   const uInt &idx, 
+                                   const Table &tab, 
+                                   Array<T> &val )
+  {
+    ROArrayColumn<T> col( tab, name ) ;
+    val = col( idx ) ;
+  }
+  template<class T> void getScalarMeas( const String &name, 
+                                        const uInt &idx, 
+                                        const Table &tab, 
+                                        T &val )
+  {
+    ROScalarMeasColumn<T> measCol( tab, name ) ;
+    val = measCol( idx ) ;
+  }
+  template<class T> void getArrayMeas( const String &name, 
+                                       const uInt &idx, 
+                                       const Table &tab, 
+                                       Array<T> &val )
+  {
+    ROArrayMeasColumn<T> measCol( tab, name ) ;
+    val = measCol( idx ) ;
+  }
+  template<class T> void getScalarQuant( const String &name, 
+                                         const uInt &idx, 
+                                         const Table &tab, 
+                                         Quantum<T> &val )
+  {
+    ROScalarQuantColumn<T> quantCol( tab, name ) ;
+    val = quantCol( idx ) ;
+  }
+  template<class T> void getArrayQuant( const String &name, 
+                                        const uInt &idx, 
+                                        const Table &tab, 
+                                        Array< Quantum<T> > &val )
+  {
+    ROArrayQuantColumn<T> quantCol( tab, name ) ;
+    val = quantCol( idx ) ;
+  }
+//   template<class T> void putField( const String &name, 
+//                                    TableRecord &rec, 
+//                                    T &val )
+//   {
+//     RecordFieldPtr<T> rf( rec, name ) ;
+//     *rf = val ;
+//   }
+//   template<class T> void defineField( const String &name, 
+//                                       TableRecord &rec, 
+//                                       T &val )
+//   {
+//     RecordFieldPtr<T> rf( rec, name ) ;
+//     rf.define( val ) ;
+//   }
+  template<class T> T interp( Double x0, Double x1, Double x, T y0, T y1 )
+  {
+    Double dx0 = x - x0 ;
+    Double dx1 = x1 - x ;
+    return ( y0 * dx1 + y1 * dx0 ) / ( x1 - x0 ) ;
+  }
+  String keyTcal( const Int &feedid, const Int &spwid, const Double &time )
+  {
+    String stime = MVTime( Quantity(time,Unit("s")) ).string( MVTime::YMD ) ;
+    String sfeed = "FEED" + String::toString( feedid ) ;
+    String sspw = "SPW" + String::toString( spwid ) ;
+    return sfeed+":"+sspw+":"+stime ;
+  }
+  String keyTcal( const Int &feedid, const Int &spwid, const String &stime )
+  {
+    String sfeed = "FEED" + String::toString( feedid ) ;
+    String sspw = "SPW" + String::toString( spwid ) ;
+    return sfeed+":"+sspw+":"+stime ;
+  }
+};
 
 class MSFiller
 {
 public:
-  explicit MSFiller(casa::CountedPtr<Scantable> stable) ;
+  explicit MSFiller(CountedPtr<Scantable> stable) ;
   virtual ~MSFiller() ;
   
-  virtual bool open(const std::string& filename, const casa::Record& rec) ;
+  virtual bool open(const std::string& filename, const Record& rec) ;
   virtual void fill() ;
   virtual void close() ;
@@ -65 +161 @@
   //void fillHistory() ;
   //void fillFit() ;
-  void fillTcal( boost::object_pool<casa::ROTableColumn> *poolr ) ;
-
-  // get SRCTYPE from STATE_ID
-  casa::Int getSrcType( casa::Int stateId, boost::object_pool<casa::ROTableColumn> *pool ) ;
-
-  // get POLNO from CORR_TYPE
-  casa::Block<casa::uInt> getPolNo( casa::Int corrType ) ;
-
-  // get poltype from CORR_TYPE 
-  casa::String getPolType( casa::Int corrType ) ;
-
-  // get WEATHER_ID 
-  casa::uInt getWeatherId( casa::uInt idx, casa::Double wtime ) ;
-
-  // get time stamp in SYSCAL table
-  // assume that tab is selected by ANTENNA_ID, FEED_ID, SPECTRAL_WINDOW_ID 
-  // and sorted by TIME
-  void getSysCalTime( casa::Vector<casa::MEpoch> &scTimeIn, casa::Vector<casa::Double> &scInterval, casa::Block<casa::MEpoch> &tcol, casa::Block<casa::Int> &tidx ) ;
-
-  // get TCAL_ID 
-  casa::Block<casa::uInt> getTcalId( casa::Int feedId, casa::Int spwId, casa::MEpoch &t ) ;
-
-  // 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::Vector<casa::Double> &ptcol, 
-                           casa::ROArrayColumn<casa::Double> &pdcol, 
-                           casa::Double t ) ;
-  casa::uInt getDirection( casa::uInt idx, 
-                           casa::Vector<casa::Double> &dir, 
-                           casa::Vector<casa::Double> &azel, 
-                           casa::Vector<casa::Double> &srate, 
-                           casa::Vector<casa::Double> &ptcol, 
-                           casa::ROArrayColumn<casa::Double> &pdcol,
-                           casa::MEpoch &t, casa::MPosition &antpos ) ;
-  void getSourceDirection( casa::Vector<casa::Double> &dir, 
-                           casa::Vector<casa::Double> &azel, 
-                           casa::Vector<casa::Double> &srate, 
-                           casa::MEpoch &t, 
-                           casa::MPosition &antpos, 
-                           casa::Vector<casa::MDirection> &srcdir ) ;
+  void fillTcal() ;
 
   // create key for TCAL table
-  casa::String keyTcal( casa::Int feedid, casa::Int spwid, casa::String stime ) ; 
-
-  // binary search
-  casa::uInt binarySearch( casa::Vector<casa::MEpoch> &timeList, casa::Double target ) ; 
-  casa::uInt binarySearch( casa::Vector<casa::Double> &timeList, casa::Double target ) ; 
-
-  // tool for HPC
-//   double gettimeofday_sec() ;
+  String keyTcal( Int feedid, Int spwid, String stime ) ; 
 
   // get frequency frame
   std::string getFrame() ;
 
-  // reshape SPECTRA and FLAGTRA
-  void reshapeSpectraAndFlagtra( casa::Cube<casa::Float> &sp, 
-                                 casa::Cube<casa::Bool> &fl,
-                                 casa::Table &tab,
-                                 casa::Int &npol,
-                                 casa::Int &nchan,
-                                 casa::Int &nrow,
-                                 casa::Vector<casa::Int> &corrtype ) ;
-
   // initialize header
   void initHeader( STHeader &header ) ;
 
-  // get value from table column using object pool
-  casa::String asString( casa::String name,
-                         casa::uInt idx,
-                         casa::Table tab, 
-                         boost::object_pool<casa::ROTableColumn> *pool ) ;
-  casa::Bool asBool( casa::String name,
-                     casa::uInt idx,
-                     casa::Table &tab, 
-                     boost::object_pool<casa::ROTableColumn> *pool ) ;
-  casa::Int asInt( casa::String name,
-                   casa::uInt idx,
-                   casa::Table &tab, 
-                   boost::object_pool<casa::ROTableColumn> *pool ) ;
-  casa::uInt asuInt( casa::String name,
-                     casa::uInt idx,
-                     casa::Table &tab, 
-                     boost::object_pool<casa::ROTableColumn> *pool ) ;
-  casa::Float asFloat( casa::String name,
-                       casa::uInt idx,
-                       casa::Table &tab, 
-                       boost::object_pool<casa::ROTableColumn> *pool ) ;
-  casa::Double asDouble( casa::String name,
-                         casa::uInt idx,
-                         casa::Table &tab, 
-                         boost::object_pool<casa::ROTableColumn> *pool ) ;
-
-  void sourceInfo( casa::Int sourceId,
-                   casa::Int spwId,
-                   casa::String &name, 
-                   casa::MDirection &direction,
-                   casa::Vector<casa::Double> &properMotion,
-                   casa::Vector<casa::Double> &restFreqs,
-                   casa::Vector<casa::String> &transitions,
-                   casa::Vector<casa::Double> &sysVels,
-                   boost::object_pool<casa::ROTableColumn> *pool ) ;
-
-  void spectralSetup( casa::Int spwId,
-                      casa::MEpoch &me,
-                      casa::MPosition &mp,
-                      casa::MDirection &md,
-                      casa::Double &refpix,
-                      casa::Double &refval,
-                      casa::Double &increment,
-                      casa::Int &nchan,
-                      casa::String &freqref,
-                      casa::Double &reffreq,
-                      casa::Double &bandwidth,
-                      boost::object_pool<casa::ROTableColumn> *pool ) ;
-
-  casa::CountedPtr<Scantable> table_ ;
-  casa::MeasurementSet mstable_ ;
-  casa::String tablename_ ;
-  casa::Int antenna_ ;
-  casa::String antennaStr_ ;
-  casa::Bool getPt_ ;
-
-  casa::Bool isFloatData_ ;
-  casa::Bool isData_ ;
-
-  casa::Bool isDoppler_ ;
-  casa::Bool isFlagCmd_ ;
-  casa::Bool isFreqOffset_ ;
-  casa::Bool isHistory_ ;
-  casa::Bool isProcessor_ ;
-  casa::Bool isSysCal_ ;
-  casa::Bool isWeather_ ;
-
-  casa::String colTsys_ ;
-  casa::String colTcal_ ;
-
-  casa::LogIO os_ ;
-  
-  casa::Vector<casa::Double> mwTime_ ;
-  casa::Vector<casa::Double> mwInterval_ ;
-  casa::Vector<casa::uInt> mwIndex_ ;
+  CountedPtr<Scantable> table_ ;
+  MeasurementSet mstable_ ;
+  String tablename_ ;
+  Int antenna_ ;
+  String antennaStr_ ;
+  Bool getPt_ ;
+
+  Bool isFloatData_ ;
+  Bool isData_ ;
+
+  Bool isDoppler_ ;
+  Bool isFlagCmd_ ;
+  Bool isFreqOffset_ ;
+  Bool isHistory_ ;
+  Bool isProcessor_ ;
+  Bool isSysCal_ ;
+  Bool isWeather_ ;
+
+  String colTsys_ ;
+  String colTcal_ ;
+
+  LogIO os_ ;
+  
+  Vector<Double> mwTime_ ;
+  Vector<Double> mwInterval_ ;
+  Vector<uInt> mwIndex_ ;
 
   // Record for TCAL_ID
@@ -214 +203 @@
   //           "SPW1": Vector<uInt>
   //  ...
-  casa::Record tcalrec_ ;
-
-  //casa::ROTableColumn *scCol_ ;
+  Record tcalrec_ ;
+  //map< String,Vector<uInt> > tcalrec_ ;
 };
 

trunk/src/MSWriter.cpp

@@ -11 +11 @@
 //
 //
+#include <assert.h>
 
 #include <casa/OS/File.h>
@@ -17 +18 @@
 #include <casa/OS/SymLink.h>
 #include <casa/BasicSL/String.h>
-#include <casa/Containers/RecordField.h>
 #include <casa/Arrays/Cube.h>
 
@@ -39 +39 @@
 #include "STTcal.h" 
 #include "MathUtils.h"
-
-// #include <ctime>
-// #include <sys/time.h>
-
+#include "TableTraverse.h"
 
 using namespace casa ;
@@ -48 +45 @@
 
 namespace asap {
-// double MSWriter::gettimeofday_sec()
-// {
-//   struct timeval tv ;
-//   gettimeofday( &tv, NULL ) ;
-//   return tv.tv_sec + (double)tv.tv_usec*1.0e-6 ;
-// }
+
+class PolarizedComponentHolder {
+public:
+  PolarizedComponentHolder()
+    : nchan(0),
+      maxnpol(4)
+  {
+    reset() ;
+  }
+  PolarizedComponentHolder( uInt n )
+    : nchan(n),
+      maxnpol(4)
+  {
+    reset() ;
+  }
+
+  void reset()
+  {
+    npol = 0 ;
+    data.clear() ;
+    flag.clear() ;
+    flagrow = False ;
+    polnos.resize() ;
+  }
+
+  void accumulate( uInt id, Vector<Float> sp, Vector<Bool> fl, Bool flr )
+  {
+    map< uInt,Vector<Float> >::iterator itr = data.find( id ) ;
+    if ( id < maxnpol && itr == data.end() ) {
+      addPol( id ) ;
+      accumulateData( id, sp ) ;
+      accumulateFlag( id, fl ) ;
+      accumulateFlagRow( flr ) ;
+      npol++ ;
+    }
+  } 
+
+  void setNchan( uInt n ) { nchan = n ; } 
+  uInt nPol() { return npol ; } 
+  uInt nChan() { return nchan ; }
+  Vector<uInt> polNos() { return polnos ; }
+  Vector<Float> getWeight() { return Vector<Float>( npol, 1.0 ) ; }
+  Vector<Float> getSigma() { return Vector<Float>( npol, 1.0 ) ; }
+  Bool getFlagRow() { return flagrow ; }
+  Cube<Bool> getFlagCategory() { return Cube<Bool>( npol, nchan, 1, False ) ; }
+  Matrix<Float> getData() 
+  {
+    Matrix<Float> v( npol, nchan ) ;
+    for ( map< uInt,Vector<Float> >::iterator i = data.begin() ; i != data.end() ; i++ ) {
+      v.row( i->first ) =  i->second ;
+    }
+    return v ;
+  }
+  Matrix<Bool> getFlag() 
+  { 
+    Matrix<Bool> v( npol, nchan ) ;
+    for ( map< uInt,Vector<Bool> >::iterator i = flag.begin() ; i != flag.end() ; i++ ) {
+      v.row( i->first ) = i->second ;
+    }
+    return v ;
+  }
+  Matrix<Complex> getComplexData()
+  {
+    Matrix<Complex> v( npol, nchan ) ;
+    Matrix<Float> dummy( 2, nchan, 0.0 ) ;
+    map< uInt,Vector<Float> >::iterator itr0 = data.find( 0 ) ;
+    map< uInt,Vector<Float> >::iterator itr1 = data.find( 1 ) ;
+    if ( itr0 != data.end() ) {
+      dummy.row( 0 ) = itr0->second ;
+      v.row( 0 ) = RealToComplex( dummy ) ;
+    }
+    if ( itr1 != data.end() ) {
+      dummy.row( 0 ) = itr1->second ;
+      v.row( npol-1 ) = RealToComplex( dummy ) ;
+    }
+    itr0 = data.find( 2 ) ;
+    itr1 = data.find( 3 ) ;
+    if ( itr0 != data.end() && itr1 != data.end() ) {
+      dummy.row( 0 ) = itr0->second ;
+      dummy.row( 1 ) = itr1->second ;
+      v.row( 1 ) = RealToComplex( dummy ) ;
+      v.row( 2 ) = conj( v.row( 1 ) ) ;
+    }
+    return v ;
+  }
+
+  Matrix<Bool> getComplexFlag()
+  {
+    Matrix<Bool> tmp = getFlag() ;
+    Matrix<Bool> v( npol, nchan ) ;
+    v.row( 0 ) = tmp.row( 0 ) ;
+    if ( npol == 2 ) {
+      v.row( npol-1 ) = tmp.row( 1 ) ;
+    }
+    else if ( npol > 2 ) {
+      v.row( npol-1 ) = tmp.row( 1 ) ;
+      v.row( 1 ) = tmp.row( 2 ) || tmp.row( 3 ) ;
+      v.row( 2 ) = v.row( 1 ) ;
+    }
+    return v ;
+  }
+  
+private:
+  void accumulateData( uInt &id, Vector<Float> &v ) 
+  {
+    data.insert( pair< uInt,Vector<Float> >( id, v ) ) ;
+  }
+    void accumulateFlag( uInt &id, Vector<Bool> &v )
+  {
+    flag.insert( pair< uInt,Vector<Bool> >( id, v ) ) ;
+  }
+  void accumulateFlagRow( Bool &v )
+  {
+    flagrow |= v ;
+  }
+  void addPol( uInt id ) 
+  {
+    uInt i = polnos.nelements() ;
+    polnos.resize( i+1, True ) ;
+    polnos[i] = id ;
+  }
+
+  uInt nchan;
+  const uInt maxnpol;
+  uInt npol;
+  Vector<uInt> polnos;
+
+  map< uInt,Vector<Float> > data;
+  map< uInt,Vector<Bool> > flag;
+  Bool flagrow;
+};
+
+class BaseMSWriterVisitor: public TableVisitor {
+  const String *lastFieldName;
+  uInt lastRecordNo;
+  uInt lastBeamNo, lastScanNo, lastIfNo;
+  Int lastSrcType;
+  uInt lastCycleNo;
+  Double lastTime;
+  Int lastPolNo;
+protected:
+  const Table &table;
+  uInt count;
+public:
+  BaseMSWriterVisitor(const Table &table)
+    : table(table)
+  {
+    static const String dummy;
+    lastFieldName = &dummy;
+    count = 0;
+  }
+  
+  virtual void enterFieldName(const uInt recordNo, const String &columnValue) {
+  }
+  virtual void leaveFieldName(const uInt recordNo, const String &columnValue) {
+  }
+  virtual void enterBeamNo(const uInt recordNo, uInt columnValue) { }
+  virtual void leaveBeamNo(const uInt recordNo, uInt columnValue) { }
+  virtual void enterScanNo(const uInt recordNo, uInt columnValue) { }
+  virtual void leaveScanNo(const uInt recordNo, uInt columnValue) { }
+  virtual void enterIfNo(const uInt recordNo, uInt columnValue) { }
+  virtual void leaveIfNo(const uInt recordNo, uInt columnValue) { }
+  virtual void enterSrcType(const uInt recordNo, Int columnValue) { }
+  virtual void leaveSrcType(const uInt recordNo, Int columnValue) { }
+  virtual void enterCycleNo(const uInt recordNo, uInt columnValue) { }
+  virtual void leaveCycleNo(const uInt recordNo, uInt columnValue) { }
+  virtual void enterTime(const uInt recordNo, Double columnValue) { }
+  virtual void leaveTime(const uInt recordNo, Double columnValue) { }
+  virtual void enterPolNo(const uInt recordNo, uInt columnValue) { }
+  virtual void leavePolNo(const uInt recordNo, uInt columnValue) { }
+
+  virtual Bool visitRecord(const uInt recordNo,
+                           const String &fieldName,
+                           const uInt beamNo,
+                           const uInt scanNo,
+                           const uInt ifNo,
+                           const Int srcType,
+                           const uInt cycleNo,
+                           const Double time,
+                           const uInt polNo) { return True ;}
+
+  virtual Bool visit(Bool isFirst, const uInt recordNo,
+                     const uInt nCols, void const *const colValues[]) {
+    const String *fieldName = NULL;
+    uInt beamNo, scanNo, ifNo;
+    Int srcType;
+    uInt cycleNo;
+    Double time;
+    Int polNo;
+    { // prologue
+      uInt i = 0;
+      {
+        const String *col = (const String*)colValues[i++];
+        fieldName = &col[recordNo];
+      }
+      {
+        const uInt *col = (const uInt *)colValues[i++];
+        beamNo = col[recordNo];
+      }
+      {
+        const uInt *col = (const uInt *)colValues[i++];
+        scanNo = col[recordNo];
+      }
+      {
+        const uInt *col = (const uInt *)colValues[i++];
+        ifNo = col[recordNo];
+      }
+      {
+        const Int *col = (const Int *)colValues[i++];
+        srcType = col[recordNo];
+      }
+      {
+        const uInt *col = (const uInt *)colValues[i++];
+        cycleNo = col[recordNo];
+      }
+      {
+        const Double *col = (const Double *)colValues[i++];
+        time = col[recordNo];
+      }
+      {
+        const Int *col = (const Int *)colValues[i++];
+        polNo = col[recordNo];
+      }
+      assert(nCols == i);
+    }
+
+    if (isFirst) {
+      enterFieldName(recordNo, *fieldName);
+      enterBeamNo(recordNo, beamNo);
+      enterScanNo(recordNo, scanNo);
+      enterIfNo(recordNo, ifNo);
+      enterSrcType(recordNo, srcType);
+      enterCycleNo(recordNo, cycleNo);
+      enterTime(recordNo, time);
+      enterPolNo(recordNo, polNo);
+    } else {
+      if (lastFieldName->compare(*fieldName) != 0) {
+        leavePolNo(lastRecordNo, lastPolNo);
+        leaveTime(lastRecordNo, lastTime);
+        leaveCycleNo(lastRecordNo, lastCycleNo);
+        leaveSrcType(lastRecordNo, lastSrcType);
+        leaveIfNo(lastRecordNo, lastIfNo);
+        leaveScanNo(lastRecordNo, lastScanNo);
+        leaveBeamNo(lastRecordNo, lastBeamNo);
+        leaveFieldName(lastRecordNo, *lastFieldName);
+
+        enterFieldName(recordNo, *fieldName);
+        enterBeamNo(recordNo, beamNo);
+        enterScanNo(recordNo, scanNo);
+        enterIfNo(recordNo, ifNo);
+        enterSrcType(recordNo, srcType);
+        enterCycleNo(recordNo, cycleNo);
+        enterTime(recordNo, time);
+        enterPolNo(recordNo, polNo);
+      } else if (lastBeamNo != beamNo) {
+        leavePolNo(lastRecordNo, lastPolNo);
+        leaveTime(lastRecordNo, lastTime);
+        leaveCycleNo(lastRecordNo, lastCycleNo);
+        leaveSrcType(lastRecordNo, lastSrcType);
+        leaveIfNo(lastRecordNo, lastIfNo);
+        leaveScanNo(lastRecordNo, lastScanNo);
+        leaveBeamNo(lastRecordNo, lastBeamNo);
+
+        enterBeamNo(recordNo, beamNo);
+        enterScanNo(recordNo, scanNo);
+        enterIfNo(recordNo, ifNo);
+        enterSrcType(recordNo, srcType);
+        enterCycleNo(recordNo, cycleNo);
+        enterTime(recordNo, time);
+        enterPolNo(recordNo, polNo);
+      } else if (lastScanNo != scanNo) {
+        leavePolNo(lastRecordNo, lastPolNo);
+        leaveTime(lastRecordNo, lastTime);
+        leaveCycleNo(lastRecordNo, lastCycleNo);
+        leaveSrcType(lastRecordNo, lastSrcType);
+        leaveIfNo(lastRecordNo, lastIfNo);
+        leaveScanNo(lastRecordNo, lastScanNo);
+
+        enterScanNo(recordNo, scanNo);
+        enterIfNo(recordNo, ifNo);
+        enterSrcType(recordNo, srcType);
+        enterCycleNo(recordNo, cycleNo);
+        enterTime(recordNo, time);
+        enterPolNo(recordNo, polNo);
+      } else if (lastIfNo != ifNo) {
+        leavePolNo(lastRecordNo, lastPolNo);
+        leaveTime(lastRecordNo, lastTime);
+        leaveCycleNo(lastRecordNo, lastCycleNo);
+        leaveSrcType(lastRecordNo, lastSrcType);
+        leaveIfNo(lastRecordNo, lastIfNo);
+
+        enterIfNo(recordNo, ifNo);
+        enterSrcType(recordNo, srcType);
+        enterCycleNo(recordNo, cycleNo);
+        enterTime(recordNo, time);
+        enterPolNo(recordNo, polNo);
+      } else if (lastSrcType != srcType) {
+        leavePolNo(lastRecordNo, lastPolNo);
+        leaveTime(lastRecordNo, lastTime);
+        leaveCycleNo(lastRecordNo, lastCycleNo);
+        leaveSrcType(lastRecordNo, lastSrcType);
+
+        enterSrcType(recordNo, srcType);
+        enterCycleNo(recordNo, cycleNo);
+        enterTime(recordNo, time);
+        enterPolNo(recordNo, polNo);
+      } else if (lastCycleNo != cycleNo) {
+        leavePolNo(lastRecordNo, lastPolNo);
+        leaveTime(lastRecordNo, lastTime);
+        leaveCycleNo(lastRecordNo, lastCycleNo);
+
+        enterCycleNo(recordNo, cycleNo);
+        enterTime(recordNo, time);
+        enterPolNo(recordNo, polNo);
+      } else if (lastTime != time) {
+        leavePolNo(lastRecordNo, lastPolNo);
+        leaveTime(lastRecordNo, lastTime);
+
+        enterTime(recordNo, time);
+        enterPolNo(recordNo, polNo);
+      } else if (lastPolNo != polNo) {
+        leavePolNo(lastRecordNo, lastPolNo);
+        enterPolNo(recordNo, polNo);
+      }
+    }
+    count++;
+    Bool result = visitRecord(recordNo, *fieldName, beamNo, scanNo, ifNo, srcType,
+                              cycleNo, time, polNo);
+
+    { // epilogue
+      lastRecordNo = recordNo;
+
+      lastFieldName = fieldName;
+      lastBeamNo = beamNo;
+      lastScanNo = scanNo;
+      lastIfNo = ifNo;
+      lastSrcType = srcType;
+      lastCycleNo = cycleNo;
+      lastTime = time;
+      lastPolNo = polNo;
+    }
+    return result ;
+  }
+
+  virtual void finish() {
+    if (count > 0) {
+      leavePolNo(lastRecordNo, lastPolNo);
+      leaveTime(lastRecordNo, lastTime);
+      leaveCycleNo(lastRecordNo, lastCycleNo);
+      leaveSrcType(lastRecordNo, lastSrcType);
+      leaveIfNo(lastRecordNo, lastIfNo);
+      leaveScanNo(lastRecordNo, lastScanNo);
+      leaveBeamNo(lastRecordNo, lastBeamNo);
+      leaveFieldName(lastRecordNo, *lastFieldName);
+    }
+  }
+};
+
+class MSWriterVisitor: public BaseMSWriterVisitor, public MSWriterUtils {
+public:
+  MSWriterVisitor(const Table &table, Table &mstable)
+    : BaseMSWriterVisitor(table),
+      ms(mstable)
+  { 
+    rowidx = 0 ;
+    fieldName = "" ;
+    defaultFieldId = 0 ;
+    spwId = -1 ;
+    subscan = 1 ;
+    ptName = "" ;
+    srcId = 0 ;
+    
+    row = TableRow( ms ) ;
+
+    holder.reset() ;
+
+    makePolMap() ;
+    initFrequencies() ;
+    initTcal() ;
+
+    //
+    // add rows to MS
+    //
+    uInt addrow = table.nrow() ;
+    ms.addRow( addrow ) ;
+
+    // attach to Scantable columns
+    spectraCol.attach( table, "SPECTRA" ) ;
+    flagtraCol.attach( table, "FLAGTRA" ) ;
+    flagRowCol.attach( table, "FLAGROW" ) ;
+    tcalIdCol.attach( table, "TCAL_ID" ) ;
+    intervalCol.attach( table, "INTERVAL" ) ;
+    directionCol.attach( table, "DIRECTION" ) ;
+    scanRateCol.attach( table, "SCANRATE" ) ;
+    timeCol.attach( table, "TIME" ) ;
+    freqIdCol.attach( table, "FREQ_ID" ) ;
+    sourceNameCol.attach( table, "SRCNAME" ) ;
+    sourceDirectionCol.attach( table, "SRCDIRECTION" ) ;
+    fieldNameCol.attach( table, "FIELDNAME" ) ;
+
+    // MS subtables
+    attachSubtables() ;
+
+    // attach to MS columns
+    attachMain() ;
+    attachPointing() ;
+  }
+  
+  virtual void enterFieldName(const uInt recordNo, const String &columnValue) {
+    //printf("%u: FieldName: %s\n", recordNo, columnValue.c_str());
+    fieldName = fieldNameCol.asString( recordNo ) ;
+    String::size_type pos = fieldName.find( "__" ) ;
+    if ( pos != String::npos ) {
+      fieldId = String::toInt( fieldName.substr( pos+2 ) ) ;
+      fieldName = fieldName.substr( 0, pos ) ;
+    }
+    else {
+      fieldId = defaultFieldId ;
+      defaultFieldId++ ;
+    }
+    Double tSec = timeCol.asdouble( recordNo ) * 86400.0 ;
+    Vector<Double> srcDir = sourceDirectionCol( recordNo ) ;
+    Vector<Double> srate = scanRateCol( recordNo ) ;
+    String srcName = sourceNameCol.asString( recordNo ) ;
+
+    addField( fieldId, fieldName, srcName, srcDir, srate, tSec ) ;
+
+    // put value
+    *fieldIdRF = fieldId ;
+  }
+  virtual void leaveFieldName(const uInt recordNo, const String &columnValue) {
+  }
+  virtual void enterBeamNo(const uInt recordNo, uInt columnValue) {
+    //printf("%u: BeamNo: %u\n", recordNo, columnValue);
+    
+    feedId = (Int)columnValue ;
+
+    // put value
+    *feed1RF = feedId ;
+    *feed2RF = feedId ;
+  }
+  virtual void leaveBeamNo(const uInt recordNo, uInt columnValue) {
+  }
+  virtual void enterScanNo(const uInt recordNo, uInt columnValue) {
+    //printf("%u: ScanNo: %u\n", recordNo, columnValue);
+
+    // put value 
+    // SCAN_NUMBER is 0-based in Scantable while 1-based in MS
+    *scanNumberRF = (Int)columnValue + 1 ;
+  }
+  virtual void leaveScanNo(const uInt recordNo, uInt columnValue) {
+    subscan = 1 ;
+  }
+  virtual void enterIfNo(const uInt recordNo, uInt columnValue) {
+    //printf("%u: IfNo: %u\n", recordNo, columnValue);
+
+    spwId = (Int)columnValue ;
+    uInt freqId = freqIdCol.asuInt( recordNo ) ;
+
+    Vector<Float> sp = spectraCol( recordNo ) ;
+    uInt nchan = sp.nelements() ;
+    holder.setNchan( nchan ) ;
+
+    addSpectralWindow( spwId, freqId ) ;
+
+    addFeed( feedId, spwId ) ;
+  }
+  virtual void leaveIfNo(const uInt recordNo, uInt columnValue) {
+  }
+  virtual void enterSrcType(const uInt recordNo, Int columnValue) {
+    //printf("%u: SrcType: %d\n", recordNo, columnValue);
+
+    Int stateId = addState( columnValue ) ;
+
+    // put value
+    *stateIdRF = stateId ;
+  }
+  virtual void leaveSrcType(const uInt recordNo, Int columnValue) {
+  }
+  virtual void enterCycleNo(const uInt recordNo, uInt columnValue) {
+    //printf("%u: CycleNo: %u\n", recordNo, columnValue);
+  }
+  virtual void leaveCycleNo(const uInt recordNo, uInt columnValue) {
+  }
+  virtual void enterTime(const uInt recordNo, Double columnValue) {
+    //printf("%u: Time: %f\n", recordNo, columnValue);
+
+    Double timeSec = columnValue * 86400.0 ;
+    Double interval = intervalCol.asdouble( recordNo ) ;
+
+    if ( ptName.empty() ) {
+      Vector<Double> dir = directionCol( recordNo ) ;
+      Vector<Double> rate = scanRateCol( recordNo ) ;
+      if ( anyNE( rate, 0.0 ) ) {
+        Matrix<Double> msdir( 2, 2 ) ;
+        msdir.column( 0 ) = dir ;
+        msdir.column( 1 ) = rate ;
+        addPointing( timeSec, interval, msdir ) ;
+      }
+      else {
+        Matrix<Double> msdir( 2, 1 ) ;
+        msdir.column( 0 ) = dir ;
+        addPointing( timeSec, interval, msdir ) ;
+      }
+    }
+
+    // put value
+    *timeRF = timeSec ;
+    *timeCentroidRF = timeSec ;
+    *intervalRF = interval ;
+    *exposureRF = interval ;
+  }
+  virtual void leaveTime(const uInt recordNo, Double columnValue) {
+    if ( holder.nPol() > 0 ) {
+      Vector<Float> w = holder.getWeight() ;
+      Cube<Bool> c = holder.getFlagCategory() ;
+      Bool flr = holder.getFlagRow() ;
+      Matrix<Bool> fl = holder.getFlag() ;
+      Vector<uInt> polnos = holder.polNos() ;
+      Int polId = addPolarization( polnos ) ;
+      Int ddId = addDataDescription( polId, spwId ) ;
+       
+      // put field
+      *dataDescIdRF = ddId ;
+      *flagRowRF = flr ;
+      weightRF.define( w ) ;
+      sigmaRF.define( w ) ;
+      flagCategoryRF.define( c ) ;
+      flagRF.define( fl ) ;
+      if ( useFloat ) {
+        Matrix<Float> sp = holder.getData() ;
+        floatDataRF.define( sp ) ;
+      }
+      else {
+        Matrix<Complex> sp = holder.getComplexData() ;
+        dataRF.define( sp ) ;
+      }
+      
+      // commit row
+      row.put( rowidx ) ;
+      rowidx++ ;
+
+      // reset holder
+      holder.reset() ;
+    }
+    if ( tcalKey != -1 ) {
+      tcalNotYet[tcalKey] = False ;
+      tcalKey = -1 ;
+    }
+  }
+  virtual void enterPolNo(const uInt recordNo, uInt columnValue) {
+    //printf("%u: PolNo: %d\n", recordNo, columnValue);
+    uInt tcalId = tcalIdCol.asuInt( recordNo ) ;
+    if ( tcalKey == -1 ) {
+      tcalKey = tcalId ;
+    }
+    if ( tcalNotYet[tcalKey] ) {
+      map< Int,Vector<uInt> >::iterator itr = tcalIdRec.find( tcalKey ) ;
+      if ( itr != tcalIdRec.end() ) {
+        Vector<uInt> ids = itr->second ;
+        uInt nrow = ids.nelements() ;
+        ids.resize( nrow+1, True ) ;
+        ids[nrow] = tcalId ;
+        tcalIdRec.erase( tcalKey ) ;
+        tcalIdRec[tcalKey] = ids ;
+      }
+      else {
+        Vector<uInt> rows( 1, tcalId ) ;
+        tcalIdRec[tcalKey] = rows ;
+      }
+    }
+    map< Int,Vector<uInt> >::iterator itr = tcalRowRec.find( tcalKey ) ;
+    if ( itr != tcalRowRec.end() ) {
+      Vector<uInt> rows = itr->second ;
+      uInt nrow = rows.nelements() ;
+      rows.resize( nrow+1, True ) ;
+      rows[nrow] = recordNo ;
+      tcalRowRec.erase( tcalKey ) ;
+      tcalRowRec[tcalKey] = rows ;
+    }
+    else {
+      Vector<uInt> rows( 1, recordNo ) ;
+      tcalRowRec[tcalKey] = rows ;
+    }
+  }
+  virtual void leavePolNo(const uInt recordNo, uInt columnValue) {
+  }
+
+  virtual Bool visitRecord(const uInt recordNo,
+                           const String &fieldName,
+                           const uInt beamNo,
+                           const uInt scanNo,
+                           const uInt ifNo,
+                           const Int srcType,
+                           const uInt cycleNo,
+                           const Double time,
+                           const uInt polNo) {
+    //printf("%u: %s, %u, %u, %u, %d, %u, %f, %d\n", recordNo,
+    //       fieldName.c_str(), beamNo, scanNo, ifNo, srcType, cycleNo, time, polNo);
+
+    Vector<Float> sp = spectraCol( recordNo ) ;
+    Vector<uChar> tmp = flagtraCol( recordNo ) ;
+    Vector<Bool> fl( tmp.shape() ) ;
+    convertArray( fl, tmp ) ;
+    Bool flr = (Bool)flagRowCol.asuInt( recordNo ) ;
+    holder.accumulate( polNo, sp, fl, flr ) ;
+
+    return True ;
+  }
+
+  virtual void finish() {
+    BaseMSWriterVisitor::finish();
+    //printf("Total: %u\n", count);
+
+    // remove rows
+    if ( ms.nrow() > rowidx ) {
+      uInt numRemove = ms.nrow() - rowidx ;
+      //cout << "numRemove = " << numRemove << endl ;
+      Vector<uInt> rows( numRemove ) ;
+      indgen( rows, rowidx ) ;
+      ms.removeRow( rows ) ;
+    }
+
+    // fill empty SPECTRAL_WINDOW rows
+    infillSpectralWindow() ;
+  }
+
+  void dataColumnName( String name ) 
+  {
+    TableRecord &r = row.record() ;
+    if ( name == "DATA" ) {
+      useFloat = False ;
+      dataRF.attachToRecord( r, name ) ;
+    }
+    else if ( name == "FLOAT_DATA" ) {
+      useFloat = True ;
+      floatDataRF.attachToRecord( r, name ) ;
+    }
+  }
+  void pointingTableName( String name ) {
+    ptName = name ;
+  }
+  void setSourceRecord( Record &r ) {
+    srcRec = r ;
+  }
+  map< Int,Vector<uInt> > &getTcalIdRecord() { return tcalIdRec ; }
+  map< Int,Vector<uInt> > &getTcalRowRecord() { return tcalRowRec ; }
+private:
+  void addField( Int &fid, String &fname, String &srcName,
+                 Vector<Double> &sdir, Vector<Double> &srate, 
+                 Double &tSec ) 
+  {
+    uInt nrow = fieldtab.nrow() ;
+    while( (Int)nrow <= fid ) {
+      fieldtab.addRow( 1, True ) ;
+      nrow++ ;
+    }
+
+    Matrix<Double> dir ;
+    Int numPoly = 0 ;
+    if ( anyNE( srate, 0.0 ) ) {
+      dir.resize( 2, 2 ) ;
+      dir.column( 0 ) = sdir ;
+      dir.column( 1 ) = srate ;
+      numPoly = 1 ;
+    }
+    else {
+      dir.resize( 2, 1 ) ;
+      dir.column( 0 ) = sdir ;
+    }
+    srcId = srcRec.asInt( srcName ) ;
+
+    TableRow tr( fieldtab ) ;
+    TableRecord &r = tr.record() ;
+    putField( "NAME", r, fname ) ;
+    putField( "NUM_POLY", r, numPoly ) ;
+    putField( "TIME", r, tSec ) ;
+    putField( "SOURCE_ID", r, srcId ) ;
+    defineField( "DELAY_DIR", r, dir ) ;
+    defineField( "REFERENCE_DIR", r, dir ) ;
+    defineField( "PHASE_DIR", r, dir ) ;
+    tr.put( fid ) ;
+
+    // for POINTING table
+    *poNameRF = fname ;
+  }
+  Int addState( Int &id ) 
+  {
+    String obsMode ;
+    Bool isSignal ;
+    Double tnoise ;
+    Double tload ;
+    queryType( id, obsMode, isSignal, tnoise, tload ) ;
+
+    String key = obsMode+"_"+String::toString( subscan ) ;
+    Int idx = -1 ;
+    uInt nEntry = stateEntry.nelements() ;
+    for ( uInt i = 0 ; i < nEntry ; i++ ) {
+      if ( stateEntry[i] == key ) {
+        idx = i ;
+        break ;
+      }
+    }
+    if ( idx == -1 ) {
+      uInt nrow = statetab.nrow() ;
+      statetab.addRow( 1, True ) ;
+      TableRow tr( statetab ) ;
+      TableRecord &r = tr.record() ;
+      putField( "OBS_MODE", r, obsMode ) ;
+      putField( "SIG", r, isSignal ) ;
+      isSignal = !isSignal ;
+      putField( "REF", r, isSignal ) ;
+      putField( "CAL", r, tnoise ) ;
+      putField( "LOAD", r, tload ) ;
+      tr.put( nrow ) ;
+      idx = nrow ;
+
+      stateEntry.resize( nEntry+1, True ) ;
+      stateEntry[nEntry] = key ;
+    }
+    subscan++ ;
+
+    return idx ;
+  }
+  void addPointing( Double &tSec, Double &interval, Matrix<Double> &dir ) 
+  {
+    uInt nrow = potab.nrow() ;
+    potab.addRow( 1, True ) ;
+
+    *poNumPolyRF = dir.ncolumn() - 1 ;
+    *poTimeRF = tSec ;
+    *poTimeOriginRF = tSec ;
+    *poIntervalRF = interval ;
+    poDirectionRF.define( dir ) ;
+    poTargetRF.define( dir ) ;
+    porow.put( nrow ) ;
+  }
+  Int addPolarization( Vector<uInt> &nos )
+  {
+    Int idx = -1 ;
+    uInt nEntry = polEntry.size() ;
+    for ( uInt i = 0 ; i < nEntry ; i++ ) {
+      if ( polEntry[i].conform( nos ) && allEQ( polEntry[i], nos ) ) {
+        idx = i ;
+        break ;
+      }
+    }
+    
+    Int numCorr ;
+    Vector<Int> corrType ;
+    Matrix<Int> corrProduct ;
+    polProperty( nos, numCorr, corrType, corrProduct ) ;
+
+    if ( idx == -1 ) {
+      uInt nrow = poltab.nrow() ;
+      poltab.addRow( 1, True ) ;
+      TableRow tr( poltab ) ;
+      TableRecord &r = tr.record() ;
+      putField( "NUM_CORR", r, numCorr ) ;
+      defineField( "CORR_TYPE", r, corrType ) ;
+      defineField( "CORR_PRODUCT", r, corrProduct ) ;
+      tr.put( nrow ) ;
+      idx = nrow ;
+
+      polEntry.resize( nEntry+1 ) ;
+      polEntry[nEntry] = nos ;
+    }
+
+    return idx ;
+  }
+  Int addDataDescription( Int pid, Int sid ) 
+  {
+    Int idx = -1 ;
+    uInt nEntry = ddEntry.nrow() ;
+    Vector<Int> key( 2 ) ;
+    key[0] = pid ;
+    key[1] = sid ;
+    for ( uInt i = 0 ; i < nEntry ; i++ ) {
+      if ( allEQ( ddEntry.row(i), key ) ) {
+        idx = i ;
+        break ;
+      }
+    }
+
+    if ( idx == -1 ) {
+      uInt nrow = ddtab.nrow() ;
+      ddtab.addRow( 1, True ) ;
+      TableRow tr( ddtab ) ;
+      TableRecord &r = tr.record() ;
+      putField( "POLARIZATION_ID", r, pid ) ;
+      putField( "SPECTRAL_WINDOW_ID", r, sid ) ;
+      tr.put( nrow ) ;
+      idx = nrow ;
+
+      ddEntry.resize( nEntry+1, 2, True ) ;
+      ddEntry.row(nEntry) = key ;
+    }
+
+    return idx ;
+  }
+  void infillSpectralWindow()
+  {
+    ROScalarColumn<Int> nchanCol( spwtab, "NUM_CHAN" ) ;
+    Vector<Int> nchan = nchanCol.getColumn() ;
+    TableRow tr( spwtab ) ;
+    TableRecord &r = tr.record() ;
+    Int mfr = 1 ;
+    Vector<Double> dummy( 1, 0.0 ) ;
+    putField( "MEAS_FREQ_REF", r, mfr ) ;
+    defineField( "CHAN_FREQ", r, dummy ) ;
+    defineField( "CHAN_WIDTH", r, dummy ) ;
+    defineField( "EFFECTIVE_BW", r, dummy ) ;
+    defineField( "RESOLUTION", r, dummy ) ;
+
+    for ( uInt i = 0 ; i < spwtab.nrow() ; i++ ) {
+      if ( nchan[i] == 0 )
+        tr.put( i ) ;
+    }
+  }
+  void addSpectralWindow( Int sid, uInt fid )
+  {
+    if ( !processedFreqId[fid] ) {
+      uInt nrow = spwtab.nrow() ;
+      while( (Int)nrow <= sid ) {
+        spwtab.addRow( 1, True ) ;
+        nrow++ ;
+      }
+      processedFreqId[fid] = True ;
+    }
+
+    Double rp = refpix[fid] ;
+    Double rv = refval[fid] ;
+    Double ic = increment[fid] ;
+
+    Int mfrInt = (Int)freqframe ;
+    Int nchan = holder.nChan() ;
+    Double bw = nchan * abs( ic ) ;
+    Double reffreq = rv - rp * ic ;
+    Int netsb = 0 ; // USB->0, LSB->1
+    if ( ic < 0 )
+      netsb = 1 ;
+    Vector<Double> res( nchan, abs(ic) ) ;
+    Vector<Double> chanf( nchan ) ;
+    indgen( chanf, reffreq, ic ) ;
+
+    TableRow tr( spwtab ) ;
+    TableRecord &r = tr.record() ;
+    putField( "MEAS_FREQ_REF", r, mfrInt ) ;
+    putField( "NUM_CHAN", r, nchan ) ;
+    putField( "TOTAL_BANDWIDTH", r, bw ) ;
+    putField( "REF_FREQUENCY", r, reffreq ) ;
+    putField( "NET_SIDEBAND", r, netsb ) ;
+    defineField( "RESOLUTION", r, res ) ;
+    defineField( "CHAN_WIDTH", r, res ) ;
+    defineField( "EFFECTIVE_BW", r, res ) ;
+    defineField( "CHAN_FREQ", r, chanf ) ;
+    tr.put( sid ) ;
+  }
+  void addFeed( Int fid, Int sid )
+  {
+    Int idx = -1 ;
+    uInt nEntry = feedEntry.nrow() ;
+    Vector<Int> key( 2 ) ;
+    key[0] = fid ;
+    key[1] = sid ;
+    for ( uInt i = 0 ; i < nEntry ; i++ ) {
+      if ( allEQ( feedEntry.row(i), key ) ) {
+        idx = i ;
+        break ;
+      }
+    }
+
+    if ( idx == -1 ) {
+      uInt nrow = feedtab.nrow() ;
+      feedtab.addRow( 1, True ) ;
+      Int numReceptors = 2 ;
+      Vector<String> polType( numReceptors ) ;
+      Matrix<Double> beamOffset( 2, numReceptors, 0.0 ) ;
+      Vector<Double> receptorAngle( numReceptors, 0.0 ) ;
+      if ( poltype == "linear" ) {
+        polType[0] = "X" ;
+        polType[1] = "Y" ;
+      }
+      else if ( poltype == "circular" ) {
+        polType[0] = "R" ;
+        polType[1] = "L" ;
+      }
+      else {
+        polType[0] = "X" ;
+        polType[1] = "Y" ;
+      }
+      Matrix<Complex> polResponse( numReceptors, numReceptors, 0.0 ) ;
+      
+      TableRow tr( feedtab ) ;
+      TableRecord &r = tr.record() ;
+      putField( "FEED_ID", r, fid ) ;
+      putField( "BEAM_ID", r, fid ) ;
+      Int tmp = 0 ;
+      putField( "ANTENNA_ID", r, tmp ) ;
+      putField( "SPECTRAL_WINDOW_ID", r, sid ) ;
+      putField( "NUM_RECEPTORS", r, numReceptors ) ;
+      defineField( "POLARIZATION_TYPE", r, polType ) ;
+      defineField( "BEAM_OFFSET", r, beamOffset ) ;
+      defineField( "RECEPTOR_ANGLE", r, receptorAngle ) ;
+      defineField( "POL_RESPONSE", r, polResponse ) ;
+      tr.put( nrow ) ;
+
+      feedEntry.resize( nEntry+1, 2, True ) ;
+      feedEntry.row( nEntry ) = key ;
+    }
+  }
+  void makePolMap() 
+  {
+    const TableRecord &keys = table.keywordSet() ;
+    poltype = keys.asString( "POLTYPE" ) ;
+
+    if ( poltype == "stokes" ) {
+      polmap.resize( 4 ) ;
+      polmap[0] = Stokes::I ;
+      polmap[1] = Stokes::Q ;
+      polmap[2] = Stokes::U ;
+      polmap[3] = Stokes::V ;
+    }
+    else if ( poltype == "linear" ) {
+      polmap.resize( 4 ) ;
+      polmap[0] = Stokes::XX ;
+      polmap[1] = Stokes::YY ;
+      polmap[2] = Stokes::XY ;
+      polmap[3] = Stokes::YX ;
+    }
+    else if ( poltype == "circular" ) {
+      polmap.resize( 4 ) ;
+      polmap[0] = Stokes::RR ;
+      polmap[1] = Stokes::LL ;
+      polmap[2] = Stokes::RL ;
+      polmap[3] = Stokes::LR ;
+    }
+    else if ( poltype == "linpol" ) {
+      polmap.resize( 2 ) ;
+      polmap[0] = Stokes::Plinear ;
+      polmap[1] = Stokes::Pangle ;
+    }
+    else {
+      polmap.resize( 0 ) ;
+    }
+  }
+  void initFrequencies()
+  {
+    const TableRecord &keys = table.keywordSet() ;
+    Table tab = keys.asTable( "FREQUENCIES" ) ;
+    ROScalarColumn<uInt> idcol( tab, "ID" ) ;
+    ROScalarColumn<Double> rpcol( tab, "REFPIX" ) ;
+    ROScalarColumn<Double> rvcol( tab, "REFVAL" ) ;
+    ROScalarColumn<Double> iccol( tab, "INCREMENT" ) ;
+    Vector<uInt> id = idcol.getColumn() ;
+    Vector<Double> rp = rpcol.getColumn() ;
+    Vector<Double> rv = rvcol.getColumn() ;
+    Vector<Double> ic = iccol.getColumn() ;
+    for ( uInt i = 0 ; i < id.nelements() ; i++ ) {
+      processedFreqId.insert( pair<uInt,Bool>( id[i], False ) ) ;
+      refpix.insert( pair<uInt,Double>( id[i], rp[i] ) ) ;
+      refval.insert( pair<uInt,Double>( id[i], rv[i] ) ) ;
+      increment.insert( pair<uInt,Double>( id[i], ic[i] ) ) ;
+    }
+    String frameStr = tab.keywordSet().asString( "BASEFRAME" ) ;
+    MFrequency::getType( freqframe, frameStr ) ;
+  }
+  void attachSubtables()
+  {
+    const TableRecord &keys = table.keywordSet() ;
+    TableRecord &mskeys = ms.rwKeywordSet() ;
+
+    // FIELD table
+    fieldtab = mskeys.asTable( "FIELD" ) ;
+
+    // SPECTRAL_WINDOW table
+    spwtab = mskeys.asTable( "SPECTRAL_WINDOW" ) ;
+
+    // POINTING table
+    potab = mskeys.asTable( "POINTING" ) ;
+
+    // POLARIZATION table
+    poltab = mskeys.asTable( "POLARIZATION" ) ;
+
+    // DATA_DESCRIPTION table
+    ddtab = mskeys.asTable( "DATA_DESCRIPTION" ) ;
+
+    // STATE table 
+    statetab = mskeys.asTable( "STATE" ) ;
+
+    // FEED table
+    feedtab = mskeys.asTable( "FEED" ) ;
+  }
+  void attachMain()
+  {
+    TableRecord &r = row.record() ;
+    dataDescIdRF.attachToRecord( r, "DATA_DESC_ID" ) ;
+    flagRowRF.attachToRecord( r, "FLAG_ROW" ) ;
+    weightRF.attachToRecord( r, "WEIGHT" ) ;
+    sigmaRF.attachToRecord( r, "SIGMA" ) ;
+    flagCategoryRF.attachToRecord( r, "FLAG_CATEGORY" ) ;
+    flagRF.attachToRecord( r, "FLAG" ) ;
+    timeRF.attachToRecord( r, "TIME" ) ;
+    timeCentroidRF.attachToRecord( r, "TIME_CENTROID" ) ;
+    intervalRF.attachToRecord( r, "INTERVAL" ) ;
+    exposureRF.attachToRecord( r, "EXPOSURE" ) ;
+    fieldIdRF.attachToRecord( r, "FIELD_ID" ) ;
+    feed1RF.attachToRecord( r, "FEED1" ) ;
+    feed2RF.attachToRecord( r, "FEED2" ) ;
+    scanNumberRF.attachToRecord( r, "SCAN_NUMBER" ) ;
+    stateIdRF.attachToRecord( r, "STATE_ID" ) ;
+
+    // constant values
+    Int id = 0 ;
+    RecordFieldPtr<Int> intRF( r, "OBSERVATION_ID" ) ;
+    *intRF = 0 ;
+    intRF.attachToRecord( r, "ANTENNA1" ) ;
+    *intRF = 0 ;
+    intRF.attachToRecord( r, "ANTENNA2" ) ;
+    *intRF = 0 ;
+    intRF.attachToRecord( r, "ARRAY_ID" ) ;
+    *intRF = 0 ;
+    intRF.attachToRecord( r, "PROCESSOR_ID" ) ;
+    *intRF = 0 ;
+    RecordFieldPtr< Vector<Double> > arrayRF( r, "UVW" ) ; 
+    arrayRF.define( Vector<Double>( 3, 0.0 ) ) ;
+  }
+  void attachPointing()
+  {
+    porow = TableRow( potab ) ;
+    TableRecord &r = porow.record() ;
+    poNumPolyRF.attachToRecord( r, "NUM_POLY" ) ;
+    poTimeRF.attachToRecord( r, "TIME" ) ;
+    poTimeOriginRF.attachToRecord( r, "TIME_ORIGIN" ) ;
+    poIntervalRF.attachToRecord( r, "INTERVAL" ) ;
+    poNameRF.attachToRecord( r, "NAME" ) ;
+    poDirectionRF.attachToRecord( r, "DIRECTION" ) ;
+    poTargetRF.attachToRecord( r, "TARGET" ) ;
+    
+    // constant values
+    RecordFieldPtr<Int> antIdRF( r, "ANTENNA_ID" ) ;
+    *antIdRF = 0 ;
+    RecordFieldPtr<Bool> trackingRF( r, "TRACKING" ) ;
+    *trackingRF = True ;
+  }
+  void queryType( Int type, String &stype, Bool &b, Double &t, Double &l )
+  {
+    t = 0.0 ;
+    l = 0.0 ;
+
+    String sep1="#" ;
+    String sep2="," ;
+    String target="OBSERVE_TARGET" ;
+    String atmcal="CALIBRATE_TEMPERATURE" ;
+    String onstr="ON_SOURCE" ;
+    String offstr="OFF_SOURCE" ;
+    String pswitch="POSITION_SWITCH" ;
+    String nod="NOD" ;
+    String fswitch="FREQUENCY_SWITCH" ;
+    String sigstr="SIG" ;
+    String refstr="REF" ;
+    String unspecified="UNSPECIFIED" ;
+    String ftlow="LOWER" ;
+    String fthigh="HIGHER" ;
+    switch ( type ) {
+    case SrcType::PSON:
+      stype = target+sep1+onstr+sep2+pswitch ;
+      b = True ;
+      break ;
+    case SrcType::PSOFF:
+      stype = target+sep1+offstr+sep2+pswitch ;
+      b = False ;
+      break ;
+    case SrcType::NOD:
+      stype = target+sep1+onstr+sep2+nod ;
+      b = True ;
+      break ;
+    case SrcType::FSON:
+      stype = target+sep1+onstr+sep2+fswitch+sep1+sigstr ;
+      b = True ;
+      break ;
+    case SrcType::FSOFF:
+      stype = target+sep1+onstr+sep2+fswitch+sep1+refstr ;
+      b = False ;
+      break ;
+    case SrcType::SKY:
+      stype = atmcal+sep1+offstr+sep2+unspecified ;
+      b = False ;
+      break ;
+    case SrcType::HOT:
+      stype = atmcal+sep1+offstr+sep2+unspecified ;
+      b = False ;
+      break ;
+    case SrcType::WARM:
+      stype = atmcal+sep1+offstr+sep2+unspecified ;
+      b = False ;
+      break ;
+    case SrcType::COLD:
+      stype = atmcal+sep1+offstr+sep2+unspecified ;
+      b = False ;
+      break ;
+    case SrcType::PONCAL:
+      stype = atmcal+sep1+onstr+sep2+pswitch ;
+      b = True ;
+      break ;
+    case SrcType::POFFCAL:
+      stype = atmcal+sep1+offstr+sep2+pswitch ;
+      b = False ;
+      break ;
+    case SrcType::NODCAL:
+      stype = atmcal+sep1+onstr+sep2+nod ;
+      b = True ;
+      break ;
+    case SrcType::FONCAL:
+      stype = atmcal+sep1+onstr+sep2+fswitch+sep1+sigstr ;
+      b = True ;
+      break ;
+    case SrcType::FOFFCAL:
+      stype = atmcal+sep1+offstr+sep2+fswitch+sep1+refstr ;
+      b = False ;
+      break ;
+    case SrcType::FSLO:
+      stype = target+sep1+onstr+sep2+fswitch+sep1+ftlow ;
+      b = True ;
+      break ;
+    case SrcType::FLOOFF:
+      stype = target+sep1+offstr+sep2+fswitch+sep1+ftlow ;
+      b = False ;
+      break ;
+    case SrcType::FLOSKY:
+      stype = atmcal+sep1+offstr+sep2+fswitch+sep1+ftlow ;
+      b = False ;
+      break ;
+    case SrcType::FLOHOT:
+      stype = atmcal+sep1+offstr+sep2+fswitch+sep1+ftlow ;
+      b = False ;
+      break ;
+    case SrcType::FLOWARM:
+      stype = atmcal+sep1+offstr+sep2+fswitch+sep1+ftlow ;
+      b = False ;
+      break ;
+    case SrcType::FLOCOLD:
+      stype = atmcal+sep1+offstr+sep2+fswitch+sep1+ftlow ;
+      b = False ;
+      break ;
+    case SrcType::FSHI:
+      stype = target+sep1+onstr+sep2+fswitch+sep1+fthigh ;
+      b = True ;
+      break ;
+    case SrcType::FHIOFF:
+      stype = target+sep1+offstr+sep2+fswitch+sep1+fthigh ;
+      b = False ;
+      break ;
+    case SrcType::FHISKY:
+      stype = atmcal+sep1+offstr+sep2+fswitch+sep1+fthigh ;
+      b = False ;
+      break ;
+    case SrcType::FHIHOT:
+      stype = atmcal+sep1+offstr+sep2+fswitch+sep1+fthigh ;
+      b = False ;
+      break ;
+    case SrcType::FHIWARM:
+      stype = atmcal+sep1+offstr+sep2+fswitch+sep1+fthigh ;
+      b = False ;
+      break ;
+    case SrcType::FHICOLD:
+      stype = atmcal+sep1+offstr+sep2+fswitch+sep1+fthigh ;
+      b = False ;
+      break ;
+    case SrcType::SIG:
+      stype = target+sep1+onstr+sep2+unspecified ;
+      b = True ;
+      break ;
+    case SrcType::REF:
+      stype = target+sep1+offstr+sep2+unspecified ;
+      b = False ;
+      break ;
+    default:
+      stype = unspecified ;
+      b = True ;
+      break ;
+    }
+  }
+  void polProperty( Vector<uInt> &nos, Int &n, Vector<Int> &c, Matrix<Int> &cp ) 
+  {
+    n = nos.nelements() ;
+    c.resize( n ) ;
+    for ( Int i = 0 ; i < n ; i++ )
+      c[i] = (Int)polmap[nos[i]] ;
+    cp.resize( 2, n ) ;
+    if ( n == 1 )
+      cp = 0 ;
+    else if ( n == 2 ) {
+      cp.column( 0 ) = 0 ;
+      cp.column( 1 ) = 1 ;
+    }
+    else {
+      cp.column( 0 ) = 0 ;
+      cp.column( 1 ) = 1 ;
+      cp( 0, 1 ) = 0 ;
+      cp( 1, 1 ) = 1 ;
+      cp( 0, 2 ) = 1 ;
+      cp( 1, 2 ) = 0 ;
+    }
+  }
+  void initTcal()
+  {
+    const TableRecord &rec = table.keywordSet() ;
+    Table tcalTable = rec.asTable( "TCAL" ) ;
+    ROScalarColumn<uInt> idCol( tcalTable, "ID" ) ;
+    Vector<uInt> id = idCol.getColumn() ;
+    uInt maxId = max( id ) ;
+    tcalNotYet.resize( maxId+1 ) ;
+    tcalNotYet = True ;
+    tcalKey = -1 ;
+  }
+
+  Table &ms;
+  TableRow row;
+  uInt rowidx;
+  String fieldName;
+  Int fieldId;
+  Int srcId;
+  Int defaultFieldId;
+  Int spwId;
+  Int feedId;
+  Int subscan;
+  PolarizedComponentHolder holder;
+  String ptName;
+  Bool useFloat;
+  String poltype;
+  Vector<Stokes::StokesTypes> polmap;
+
+  // MS subtables
+  Table spwtab;
+  Table statetab;
+  Table ddtab;
+  Table poltab;
+  Table fieldtab;
+  Table feedtab;
+  Table potab;
+
+  // Scantable MAIN columns
+  ROArrayColumn<Float> spectraCol;
+  ROArrayColumn<Double> directionCol,scanRateCol,sourceDirectionCol;
+  ROArrayColumn<uChar> flagtraCol;
+  ROTableColumn tcalIdCol,intervalCol,flagRowCol,timeCol,freqIdCol,
+    sourceNameCol,fieldNameCol;
+
+  // MS MAIN columns
+  RecordFieldPtr<Int> dataDescIdRF,fieldIdRF,feed1RF,feed2RF,
+    scanNumberRF,stateIdRF;
+  RecordFieldPtr<Bool> flagRowRF;
+  RecordFieldPtr<Double> timeRF,timeCentroidRF,intervalRF,exposureRF;
+  RecordFieldPtr< Vector<Float> > weightRF,sigmaRF;
+  RecordFieldPtr< Cube<Bool> > flagCategoryRF;
+  RecordFieldPtr< Matrix<Bool> > flagRF;
+  RecordFieldPtr< Matrix<Float> > floatDataRF;
+  RecordFieldPtr< Matrix<Complex> > dataRF;
+
+  // MS POINTING columns
+  TableRow porow;
+  RecordFieldPtr<Int> poNumPolyRF ;
+  RecordFieldPtr<Double> poTimeRF,
+    poTimeOriginRF,
+    poIntervalRF ;
+  RecordFieldPtr<String> poNameRF ;
+  RecordFieldPtr< Matrix<Double> > poDirectionRF,
+    poTargetRF ;
+
+  Vector<String> stateEntry;
+  Matrix<Int> ddEntry;
+  Matrix<Int> feedEntry;
+  vector< Vector<uInt> > polEntry;
+  map<uInt,Bool> processedFreqId;
+  map<uInt,Double> refpix;
+  map<uInt,Double> refval;
+  map<uInt,Double> increment;
+  MFrequency::Types freqframe;
+  Record srcRec;
+  map< Int,Vector<uInt> > tcalIdRec;
+  map< Int,Vector<uInt> > tcalRowRec;
+  Int tcalKey;
+  Vector<Bool> tcalNotYet;
+};
 
 MSWriter::MSWriter(CountedPtr<Scantable> stable) 
@@ -79 +1355 @@
     delete mstable_ ;
 }
-  
+
 bool MSWriter::write(const string& filename, const Record& rec) 
 {
   os_.origin( LogOrigin( "MSWriter", "write()", WHERE ) ) ;
-//   double startSec = mathutil::gettimeofday_sec() ;
-//   os_ << "start MSWriter::write() startSec=" << startSec << LogIO::POST ;
+  //double startSec = mathutil::gettimeofday_sec() ;
+  //os_ << "start MSWriter::write() startSec=" << startSec << LogIO::POST ;
 
   filename_ = filename ;
@@ -134 +1410 @@
     fillWeather() ;
 
-  // MAIN
-  // Iterate over several ids
-  Vector<uInt> processedFreqId( 0 ) ;
-  Int defaultFieldId = 0 ;
-
-  // row based
-  TableRow row( *mstable_ ) ;
-  TableRecord &trec = row.record() ;
-  NoticeTarget *dataRF = 0 ;
-  if ( useFloatData_ ) 
-    dataRF = new RecordFieldPtr< Array<Float> >( trec, "FLOAT_DATA" ) ;
-  else if ( useData_ )
-    dataRF = new RecordFieldPtr< Array<Complex> >( trec, "DATA" ) ;
-  RecordFieldPtr< Array<Bool> > flagRF( trec, "FLAG" ) ;
-  RecordFieldPtr<Bool> flagrowRF( trec, "FLAG_ROW" ) ;
-  RecordFieldPtr<Double> timeRF( trec, "TIME" ) ;
-  RecordFieldPtr<Double> timecRF( trec, "TIME_CENTROID" ) ;
-  RecordFieldPtr<Double> intervalRF( trec, "INTERVAL" ) ;
-  RecordFieldPtr<Double> exposureRF( trec, "EXPOSURE" ) ;
-  RecordFieldPtr< Array<Float> > weightRF( trec, "WEIGHT" ) ;
-  RecordFieldPtr< Array<Float> > sigmaRF( trec, "SIGMA" ) ;
-  RecordFieldPtr<Int> ddidRF( trec, "DATA_DESC_ID" ) ;
-  RecordFieldPtr<Int> stateidRF( trec, "STATE_ID" ) ;
-  RecordFieldPtr< Array<Bool> > flagcatRF( trec, "FLAG_CATEGORY" ) ;
-
-  // OBSERVATION_ID is always 0
-  RecordFieldPtr<Int> intRF( trec, "OBSERVATION_ID" ) ;
-  *intRF = 0 ;
-  
-  // ANTENNA1 and ANTENNA2 are always 0
-  intRF.attachToRecord( trec, "ANTENNA1" ) ;
-  *intRF = 0 ;
-  intRF.attachToRecord( trec, "ANTENNA2" ) ;
-  *intRF = 0 ;
-  
-  // ARRAY_ID is tentatively set to 0
-  intRF.attachToRecord( trec, "ARRAY_ID" ) ;
-  *intRF = 0 ;
-
-  // PROCESSOR_ID is tentatively set to 0
-  intRF.attachToRecord( trec, "PROCESSOR_ID" ) ;
-  *intRF = 0 ;
-
-  // UVW is always [0,0,0]
-  RecordFieldPtr< Array<Double> > uvwRF( trec, "UVW" ) ;
-  *uvwRF = Vector<Double>( 3, 0.0 ) ;
-
-  //
-  // ITERATION: FIELDNAME
-  // 
-  TableIterator iter0( table_->table(), "FIELDNAME" ) ;
-  while( !iter0.pastEnd() ) {
-    //Table t0( iter0.table() ) ;
-    Table t0 = iter0.table() ;
-    ROTableColumn sharedCol( t0, "FIELDNAME" ) ;
-    String fieldName = sharedCol.asString( 0 ) ;
-    sharedCol.attach( t0, "SRCNAME" ) ;
-    String srcName = sharedCol.asString( 0 ) ;
-    sharedCol.attach( t0, "TIME" ) ;
-    Double minTime = (Double)sharedCol.asdouble( 0 ) * 86400.0 ; // day->sec
-    ROArrayColumn<Double> scanRateCol( t0, "SCANRATE" ) ;
-    Vector<Double> scanRate = scanRateCol( 0 ) ;
-    String::size_type pos = fieldName.find( "__" ) ;
-    Int fieldId = -1 ;
-    if ( pos != String::npos ) {
-//       os_ << "fieldName.substr( pos+2 )=" << fieldName.substr( pos+2 ) << LogIO::POST ;
-      fieldId = String::toInt( fieldName.substr( pos+2 ) ) ;
-      fieldName = fieldName.substr( 0, pos ) ;
-    }
-    else {
-//       os_ << "use default field id" << LogIO::POST ;
-      fieldId = defaultFieldId ;
-      defaultFieldId++ ;
-    }
-//     os_ << "fieldId" << fieldId << ": " << fieldName << LogIO::POST ;
-
-    // FIELD_ID
-    intRF.attachToRecord( trec, "FIELD_ID" ) ;
-    *intRF = fieldId ;
-
-    //
-    // ITERATION: BEAMNO
-    //
-    TableIterator iter1( t0, "BEAMNO" ) ;
-    while( !iter1.pastEnd() ) {
-      Table t1 = iter1.table() ;
-      sharedCol.attach( t1, "BEAMNO" ) ;
-      uInt beamNo = sharedCol.asuInt( 0 ) ;
-//       os_ << "beamNo = " << beamNo << LogIO::POST ;
-
-      // FEED1 and FEED2
-      intRF.attachToRecord( trec, "FEED1" ) ;
-      *intRF = beamNo ;
-      intRF.attachToRecord( trec, "FEED2" ) ;
-      *intRF = beamNo ;
-
-      // 
-      // ITERATION: SCANNO
-      //
-      TableIterator iter2( t1, "SCANNO" ) ;
-      while( !iter2.pastEnd() ) {
-        Table t2 = iter2.table() ;
-        sharedCol.attach( t2, "SCANNO" ) ;
-        uInt scanNo = sharedCol.asuInt( 0 ) ;
-//         os_ << "scanNo = " << scanNo << LogIO::POST ;
-
-        // SCAN_NUMBER
-        // MS: 1-based
-        // Scantable: 0-based
-        intRF.attachToRecord( trec, "SCAN_NUMBER" ) ;
-        *intRF = scanNo + 1 ;
-
-        // 
-        // ITERATION: IFNO
-        //
-        TableIterator iter3( t2, "IFNO" ) ;
-        while( !iter3.pastEnd() ) {
-          Table t3 = iter3.table() ;
-          sharedCol.attach( t3, "IFNO" ) ;
-          uInt ifNo = sharedCol.asuInt( 0 ) ;
-//           os_ << "ifNo = " << ifNo << LogIO::POST ;
-          sharedCol.attach( t3, "FREQ_ID" ) ;
-          uInt freqId = sharedCol.asuInt( 0 ) ;
-//           os_ << "freqId = " << freqId << LogIO::POST ;
-          Int subscan = 1 ; // 1-base
-          // 
-          // ITERATION: SRCTYPE
-          //
-          TableIterator iter4( t3, "SRCTYPE" ) ;
-          while( !iter4.pastEnd() ) {
-            Table t4 = iter4.table() ;
-            sharedCol.attach( t4, "SRCTYPE" ) ;
-            Int srcType = sharedCol.asInt( 0 ) ;
-            Int stateId = addState( srcType, subscan ) ;
-            *stateidRF = stateId ;
-            // 
-            // ITERATION: CYCLENO and TIME
-            //
-            Block<String> cols( 2 ) ;
-            cols[0] = "CYCLENO" ;
-            cols[1] = "TIME" ;
-            TableIterator iter5( t4, cols ) ;
-            while( !iter5.pastEnd() ) {
-              Table t5 =  iter5.table().sort("POLNO") ;
-              //sharedCol.attach( t5, "CYCLENO" ) ;
-              //uInt cycleNo = sharedCol.asuInt( 0 ) ;
-              Int nrow = t5.nrow() ;
-//               os_ << "nrow = " << nrow << LogIO::POST ;
-              
-              Vector<Int> polnos( nrow ) ;
-              indgen( polnos, 0 ) ;
-              Int polid = addPolarization( polnos ) ;
-//               os_ << "polid = " << polid << LogIO::POST ;
-              
-              // DATA/FLOAT_DATA
-              ROArrayColumn<Float> specCol( t5, "SPECTRA" ) ;
-              ROArrayColumn<uChar> flagCol( t5, "FLAGTRA" ) ;
-              uInt nchan = specCol( 0 ).size() ;
-              IPosition cellshape( 2, nrow, nchan ) ;
-              if ( useFloatData_ ) {
-                // FLOAT_DATA
-                Matrix<Float> dataArr( cellshape ) ;
-                Matrix<Bool> flagArr( cellshape ) ;
-                Vector<Bool> tmpB ;
-                for ( Int ipol = 0 ; ipol < nrow ; ipol++ ) {
-                  dataArr.row( ipol ) = specCol( ipol ) ;
-                  tmpB.reference( flagArr.row( ipol ) ) ;
-                  convertArray( tmpB, flagCol( ipol ) ) ;
-                }
-                ((RecordFieldPtr< Array<Float> > *)dataRF)->define( dataArr ) ; 
-                
-                // FLAG
-                flagRF.define( flagArr ) ;
-              }
-              else if ( useData_ ) {
-                // DATA
-                // assume nrow = 4
-                Matrix<Complex> dataArr( cellshape ) ;
-                Vector<Float> zeroIm( nchan, 0 ) ;
-                Matrix<Float> dummy( IPosition( 2, 2, nchan ) ) ;
-                dummy.row( 0 ) = specCol( 0 ) ;
-                dummy.row( 1 ) = zeroIm ;
-                dataArr.row( 0 ) = RealToComplex( dummy ) ;
-                dummy.row( 0 ) = specCol( 1 ) ;
-                dataArr.row( 3 ) = RealToComplex( dummy ) ;
-                dummy.row( 0 ) = specCol( 2 ) ;
-                dummy.row( 1 ) = specCol( 3 ) ;
-                dataArr.row( 1 ) = RealToComplex( dummy ) ;
-                dataArr.row( 2 ) = conj( dataArr.row( 1 ) ) ;
-                ((RecordFieldPtr< Array<Complex> > *)dataRF)->define( dataArr ) ; 
-                
-                
-                // FLAG
-                Matrix<Bool> flagArr( cellshape ) ;
-                Vector<Bool> tmpB ;
-                tmpB.reference( flagArr.row( 0 ) ) ;
-                convertArray( tmpB, flagCol( 0 ) ) ;
-                tmpB.reference( flagArr.row( 3 ) ) ;
-                convertArray( tmpB, flagCol( 3 ) ) ;
-                tmpB.reference( flagArr.row( 1 ) ) ;
-                convertArray( tmpB, ( flagCol( 2 ) | flagCol( 3 ) ) ) ;
-                flagArr.row( 2 ) = flagArr.row( 1 ) ;
-                flagRF.define( flagArr ) ;
-              }
-
-              // FLAG_ROW
-              sharedCol.attach( t5, "FLAGROW" ) ;
-              Vector<uInt> flagRowArr( nrow ) ;
-              for ( Int irow = 0 ; irow < nrow ; irow++ ) 
-                flagRowArr[irow] = sharedCol.asuInt( irow ) ;
-              *flagrowRF = anyNE( flagRowArr, (uInt)0 ) ;
-
-              // TIME and TIME_CENTROID
-              sharedCol.attach( t5, "TIME" ) ;
-              Double mTimeV = (Double)sharedCol.asdouble( 0 ) * 86400.0 ; // day -> sec 
-              *timeRF = mTimeV ;
-              *timecRF = mTimeV ;
-
-              // INTERVAL and EXPOSURE
-              sharedCol.attach( t5, "INTERVAL" ) ;
-              Double interval = (Double)sharedCol.asdouble( 0 ) ;
-              *intervalRF = interval ;
-              *exposureRF = interval ;
-              
-              // WEIGHT and SIGMA
-              // always 1 at the moment
-              Vector<Float> wArr( nrow, 1.0 ) ;
-              weightRF.define( wArr ) ;
-              sigmaRF.define( wArr ) ;
-              
-              // add DATA_DESCRIPTION row
-              Int ddid = addDataDescription( polid, ifNo ) ;
-//               os_ << "ddid = " << ddid << LogIO::POST ;
-              *ddidRF = ddid ;
-              
-              // for SYSCAL table
-              sharedCol.attach( t5, "TCAL_ID" ) ;
-              Vector<uInt> tcalIdArr( nrow ) ;
-              for ( Int irow = 0 ; irow < nrow ; irow++ )
-                tcalIdArr[irow] = sharedCol.asuInt( irow ) ;
-//               os_ << "tcalIdArr = " << tcalIdArr << LogIO::POST ;
-              String key = String::toString( tcalIdArr[0] ) ;
-              if ( !tcalIdRec_.isDefined( key ) ) {
-                tcalIdRec_.define( key, tcalIdArr ) ;
-                tcalRowRec_.define( key, t5.rowNumbers() ) ;
-              }
-              else {
-                Vector<uInt> pastrows = tcalRowRec_.asArrayuInt( key ) ;
-                tcalRowRec_.define( key, concatenateArray( pastrows, t5.rowNumbers() ) ) ;
-              }
-                            
-              // for POINTING table
-              if ( ptTabName_ == "" ) {
-                ROArrayColumn<Double> dirCol( t5, "DIRECTION" ) ;
-                Vector<Double> dir = dirCol( 0 ) ;
-                dirCol.attach( t5, "SCANRATE" ) ;
-                Vector<Double> rate = dirCol( 0 ) ;
-                Matrix<Double> msDir( 2, 1 ) ;
-                msDir.column( 0 ) = dir ;
-                if ( anyNE( rate, 0.0 ) ) {
-                  msDir.resize( 2, 2, True ) ;
-                  msDir.column( 1 ) = rate ;
-                }
-                addPointing( fieldName, mTimeV, interval, msDir ) ;
-              }
-              
-              // FLAG_CATEGORY is tentatively set
-              flagcatRF.define( Cube<Bool>( nrow, nchan, 1, False ) ) ; 
-              
-              // add row
-              mstable_->addRow( 1, True ) ;
-              row.put( mstable_->nrow()-1 ) ;
-              
-              iter5.next() ;
-            }
-            
-            iter4.next() ;
-          }
-
-          // add SPECTRAL_WINDOW row
-          if ( allNE( processedFreqId, freqId ) ) {
-            uInt vsize = processedFreqId.size() ;
-            processedFreqId.resize( vsize+1, True ) ;
-            processedFreqId[vsize] = freqId ;
-            addSpectralWindow( ifNo, freqId ) ;
-          }
-          
-          iter3.next() ;
-        }
-        
-        iter2.next() ;
-      }
-      
-      // add FEED row
-      addFeed( beamNo ) ;
-      
-      iter1.next() ;
-    }
-    
-    // add FIELD row
-    addField( fieldId, fieldName, srcName, minTime, scanRate ) ;
-
-    iter0.next() ;
-  }
-
-//   delete tpoolr ;
-  delete dataRF ;
-
-  // SYSCAL
-  if ( isTcal_ ) 
-    fillSysCal() ;
-
-  // fill empty SPECTRAL_WINDOW rows
-  infillSpectralWindow() ;
+  /***
+   * Start iteration using TableVisitor
+   ***/
+  {
+    static const char *cols[] = {
+      "FIELDNAME", "BEAMNO", "SCANNO", "IFNO", "SRCTYPE", "CYCLENO", "TIME",
+      "POLNO",
+      NULL
+    };
+    static const TypeManagerImpl<uInt> tmUInt;
+    static const TypeManagerImpl<Int> tmInt;
+    static const TypeManagerImpl<Double> tmDouble;
+    static const TypeManagerImpl<String> tmString;
+    static const TypeManager *const tms[] = {
+      &tmString, &tmUInt, &tmUInt, &tmUInt, &tmInt, &tmUInt, &tmDouble, &tmInt, NULL
+    };
+    //double t0 = mathutil::gettimeofday_sec() ;
+    MSWriterVisitor myVisitor(table_->table(),*mstable_);
+    //double t1 = mathutil::gettimeofday_sec() ;
+    //cout << "MSWriterVisitor(): elapsed time " << t1-t0 << " sec" << endl ;
+    String dataColName = "FLOAT_DATA" ;
+    if ( useData_ )
+      dataColName = "DATA" ;
+    myVisitor.dataColumnName( dataColName ) ;
+    myVisitor.pointingTableName( ptTabName_ ) ;
+    myVisitor.setSourceRecord( srcRec_ ) ;
+    //double t2 = mathutil::gettimeofday_sec() ;
+    traverseTable(table_->table(), cols, tms, &myVisitor);
+    //double t3 = mathutil::gettimeofday_sec() ;
+    //cout << "traverseTable(): elapsed time " << t3-t2 << " sec" << endl ;
+    map< Int,Vector<uInt> > &idRec = myVisitor.getTcalIdRecord() ;
+    map< Int,Vector<uInt> > &rowRec = myVisitor.getTcalRowRecord() ;
+
+    // SYSCAL
+    if ( isTcal_ ) 
+      fillSysCal( idRec, rowRec ) ;
+  }
+  /***
+   * End iteration using TableVisitor
+   ***/
 
   // ASDM tables 
@@ -475 +1477 @@
   }
 
-//   double endSec = mathutil::gettimeofday_sec() ;
-//   os_ << "end MSWriter::write() endSec=" << endSec << " (" << endSec-startSec << "sec)" << LogIO::POST ;
+  //double endSec = mathutil::gettimeofday_sec() ;
+  //os_ << "end MSWriter::write() endSec=" << endSec << " (" << endSec-startSec << "sec)" << LogIO::POST ;
 
   return True ;
 }
-  
+
 void MSWriter::init()
 {
@@ -697 +1699 @@
 void MSWriter::fillObservation() 
 {
-//   double startSec = mathutil::gettimeofday_sec() ;
-//   os_ << "start MSWriter::fillObservation() startSec=" << startSec << LogIO::POST ;
+  //double startSec = mathutil::gettimeofday_sec() ;
+  //os_ << "start MSWriter::fillObservation() startSec=" << startSec << LogIO::POST ;
 
   // only 1 row
@@ -726 +1728 @@
   msObsCols.timeRangeMeas().put( 0, trange ) ;
 
-//   double endSec = mathutil::gettimeofday_sec() ;
-//   os_ << "end MSWriter::fillObservation() endSec=" << endSec << " (" << endSec-startSec << "sec)" << LogIO::POST ;
+  //double endSec = mathutil::gettimeofday_sec() ;
+  //os_ << "end MSWriter::fillObservation() endSec=" << endSec << " (" << endSec-startSec << "sec)" << LogIO::POST ;
 }
+
+void MSWriter::antennaProperty( String &name, String &m, String &t, Double &d )
+{
+  name.upcase() ;
+  
+  m = "ALT-AZ" ;
+  t = "GROUND-BASED" ;
+  if ( name.matches( Regex( "DV[0-9]+$" ) ) 
+       || name.matches( Regex( "DA[0-9]+$" ) )
+       || name.matches( Regex( "PM[0-9]+$" ) ) )
+    d = 12.0 ;
+  else if ( name.matches( Regex( "CM[0-9]+$" ) ) )
+    d = 7.0 ;
+  else if ( name.contains( "GBT" ) ) 
+    d = 104.9 ;
+  else if ( name.contains( "MOPRA" ) )
+    d = 22.0 ;
+  else if ( name.contains( "PKS" ) || name.contains( "PARKS" ) )
+    d = 64.0 ;
+  else if ( name.contains( "TIDBINBILLA" ) ) 
+    d = 70.0 ;
+  else if ( name.contains( "CEDUNA" ) )
+    d = 30.0 ;
+  else if ( name.contains( "HOBART" ) ) 
+    d = 26.0 ;
+  else if ( name.contains( "APEX" ) ) 
+    d = 12.0 ;
+  else if ( name.contains( "ASTE" ) ) 
+    d = 10.0 ;
+  else if ( name.contains( "NRO" ) ) 
+    d = 45.0 ;
+  else 
+    d = 1.0 ;
+} 
 
 void MSWriter::fillAntenna() 
 {
-//   double startSec = mathutil::gettimeofday_sec() ;
-//   os_ << "start MSWriter::fillAntenna() startSec=" << startSec << LogIO::POST ;
+  //double startSec = mathutil::gettimeofday_sec() ;
+  //os_ << "start MSWriter::fillAntenna() startSec=" << startSec << LogIO::POST ;
 
   // only 1 row
-  mstable_->antenna().addRow( 1, True ) ;
-  MSAntennaColumns msAntCols( mstable_->antenna() ) ;
-
-  String hAntennaName = header_.antennaname ;
-  String::size_type pos = hAntennaName.find( "//" ) ;
+  Table anttab = mstable_->antenna() ;
+  anttab.addRow( 1, True ) ;
+  
+  Table &table = table_->table() ;
+  const TableRecord &keys = table.keywordSet() ;
+  String hAntName = keys.asString( "AntennaName" ) ;
+  String::size_type pos = hAntName.find( "//" ) ;
   String antennaName ;
   String stationName ;
   if ( pos != String::npos ) {
-    hAntennaName = hAntennaName.substr( pos+2 ) ;
-  }
-  pos = hAntennaName.find( "@" ) ;
+    stationName = hAntName.substr( 0, pos ) ;
+    hAntName = hAntName.substr( pos+2 ) ;
+  }
+  pos = hAntName.find( "@" ) ;
   if ( pos != String::npos ) {
-    antennaName = hAntennaName.substr( 0, pos ) ;
-    stationName = hAntennaName.substr( pos+1 ) ;
+    antennaName = hAntName.substr( 0, pos ) ;
+    stationName = hAntName.substr( pos+1 ) ;
   }
   else {
-    antennaName = hAntennaName ;
-    stationName = hAntennaName ;
-  }
-//   os_ << "antennaName = " << antennaName << LogIO::POST ;
-//   os_ << "stationName = " << stationName << LogIO::POST ;
+    antennaName = hAntName ;
+  }
+  Vector<Double> antpos = keys.asArrayDouble( "AntennaPosition" ) ;
   
-  msAntCols.name().put( 0, antennaName ) ;
-  msAntCols.station().put( 0, stationName ) ;
-
-//   os_ << "antennaPosition = " << header_.antennaposition << LogIO::POST ;
+  String mount, atype ;
+  Double diameter ;
+  antennaProperty( antennaName, mount, atype, diameter ) ;
   
-  msAntCols.position().put( 0, header_.antennaposition ) ;
-
-  // MOUNT is set to "ALT-AZ"
-  msAntCols.mount().put( 0, "ALT-AZ" ) ;
-
-  Double diameter = getDishDiameter( antennaName ) ;
-  msAntCols.dishDiameterQuant().put( 0, Quantity( diameter, "m" ) ) ;
-
-//   double endSec = mathutil::gettimeofday_sec() ;
-//   os_ << "end MSWriter::fillAntenna() endSec=" << endSec << " (" << endSec-startSec << "sec)" << LogIO::POST ;
+  TableRow tr( anttab ) ;
+  TableRecord &r = tr.record() ;
+  RecordFieldPtr<String> nameRF( r, "NAME" ) ;
+  RecordFieldPtr<String> stationRF( r, "STATION" ) ;
+  RecordFieldPtr<String> mountRF( r, "NAME" ) ;
+  RecordFieldPtr<String> typeRF( r, "TYPE" ) ;
+  RecordFieldPtr<Double> dishDiameterRF( r, "DISH_DIAMETER" ) ;
+  RecordFieldPtr< Vector<Double> > positionRF( r, "POSITION" ) ;
+  *nameRF = antennaName ;
+  *mountRF = mount ;
+  *typeRF = atype ;
+  *dishDiameterRF = diameter ;
+  *positionRF = antpos ;
+  
+  tr.put( 0 ) ;
+
+  //double endSec = mathutil::gettimeofday_sec() ;
+  //os_ << "end MSWriter::fillAntenna() endSec=" << endSec << " (" << endSec-startSec << "sec)" << LogIO::POST ;
 }
+  
+// void MSWriter::fillAntenna() 
+// {
+// //   double startSec = mathutil::gettimeofday_sec() ;
+// //   os_ << "start MSWriter::fillAntenna() startSec=" << startSec << LogIO::POST ;
+
+//   // only 1 row
+//   mstable_->antenna().addRow( 1, True ) ;
+//   MSAntennaColumns msAntCols( mstable_->antenna() ) ;
+
+//   String hAntennaName = header_.antennaname ;
+//   String::size_type pos = hAntennaName.find( "//" ) ;
+//   String antennaName ;
+//   String stationName ;
+//   if ( pos != String::npos ) {
+//     hAntennaName = hAntennaName.substr( pos+2 ) ;
+//   }
+//   pos = hAntennaName.find( "@" ) ;
+//   if ( pos != String::npos ) {
+//     antennaName = hAntennaName.substr( 0, pos ) ;
+//     stationName = hAntennaName.substr( pos+1 ) ;
+//   }
+//   else {
+//     antennaName = hAntennaName ;
+//     stationName = hAntennaName ;
+//   }
+// //   os_ << "antennaName = " << antennaName << LogIO::POST ;
+// //   os_ << "stationName = " << stationName << LogIO::POST ;
+  
+//   msAntCols.name().put( 0, antennaName ) ;
+//   msAntCols.station().put( 0, stationName ) ;
+
+// //   os_ << "antennaPosition = " << header_.antennaposition << LogIO::POST ;
+  
+//   msAntCols.position().put( 0, header_.antennaposition ) ;
+
+//   // MOUNT is set to "ALT-AZ"
+//   msAntCols.mount().put( 0, "ALT-AZ" ) ;
+
+//   Double diameter = getDishDiameter( antennaName ) ;
+//   msAntCols.dishDiameterQuant().put( 0, Quantity( diameter, "m" ) ) ;
+
+// //   double endSec = mathutil::gettimeofday_sec() ;
+// //   os_ << "end MSWriter::fillAntenna() endSec=" << endSec << " (" << endSec-startSec << "sec)" << LogIO::POST ;
+// }
 
 void MSWriter::fillProcessor() 
@@ -836 +1925 @@
     ROScalarColumn<Double> srcVelCol( t0, "SRCVELOCITY" ) ;
     Double srcVel = srcVelCol( 0 ) ;
+    srcRec_.define( srcName, srcId ) ;
 
     // NAME
@@ -990 +2080 @@
 }
 
-void MSWriter::fillSysCal()
+void MSWriter::fillSysCal( map< Int,Vector<uInt> > &idRec, 
+                           map< Int,Vector<uInt> > &rowRec )
 {
-//   double startSec = mathutil::gettimeofday_sec() ;
-//   os_ << "start MSWriter::fillSysCal() startSec=" << startSec << LogIO::POST ;
-
-  //tcalIdRec_.print( cout ) ;
+  //double startSec = mathutil::gettimeofday_sec() ;
+  //os_ << "start MSWriter::fillSysCal() startSec=" << startSec << LogIO::POST ;
+
+  //idRec.print( cout ) ;
 
   // access to MS SYSCAL subtable
@@ -1017 +2108 @@
     return ;
 
-  nrow = tcalIdRec_.nfields() ;
+  //nrow = idRec.nfields() ;
+  nrow = idRec.size() ;
 
   Double midTime ;
@@ -1052 +2144 @@
   ROTableColumn beamnoCol( tab, "BEAMNO" ) ;
   ROTableColumn ifnoCol( tab, "IFNO" ) ;
+  map< Int,Vector<uInt> >::iterator itr0 = idRec.begin() ;
+  map< Int,Vector<uInt> >::iterator itr1 = rowRec.begin() ;
   for ( uInt irow = 0 ; irow < nrow ; irow++ ) {
 //     double t1 = mathutil::gettimeofday_sec() ;
-    Vector<uInt> ids = tcalIdRec_.asArrayuInt( irow ) ;
+    Vector<uInt> ids = itr0->second ;
+    itr0++ ;
 //     os_ << "ids = " << ids << LogIO::POST ;
     uInt npol = ids.size() ;
-    Vector<uInt> rows = tcalRowRec_.asArrayuInt( irow ) ;
+    Vector<uInt> rows = itr1->second ;
+    itr1++ ;
 //     os_ << "rows = " << rows << LogIO::POST ;
     Vector<Double> atime( rows.nelements() ) ;
@@ -1153 +2249 @@
     if ( tcalSpec_ ) {
       // put TCAL_SPECTRUM 
-      //*tcalspRF = tcal ;
       tcalspRF.define( tcal ) ;
       // set TCAL (mean of TCAL_SPECTRUM)
@@ -1161 +2256 @@
       }
       // put TCAL
-      *tcalRF = tcalMean ;
+      tcalRF.define( tcalMean ) ;
     }
     else {
       // put TCAL
-      *tcalRF = tcal ;
+      tcalRF.define( tcal ) ;
     }
     
     if ( tsysSpec_ ) {
       // put TSYS_SPECTRUM
-      //*tsysspRF = tsys ;
       tsysspRF.define( tsys ) ;
       // set TSYS (mean of TSYS_SPECTRUM)
@@ -1178 +2272 @@
       }
       // put TSYS
-      *tsysRF = tsysMean ;
+      tsysRF.define( tsysMean ) ;
     }
     else {
       // put TSYS
-      *tsysRF = tsys ;
+      tsysRF.define( tsys ) ;
     }
 
@@ -1193 +2287 @@
   }
   
-//   double endSec = mathutil::gettimeofday_sec() ;
-//   os_ << "end MSWriter::fillSysCal() endSec=" << endSec << " (" << endSec-startSec << "sec)" << LogIO::POST ;
+  //double endSec = mathutil::gettimeofday_sec() ;
+  //os_ << "end MSWriter::fillSysCal() endSec=" << endSec << " (" << endSec-startSec << "sec)" << LogIO::POST ;
 }
 

trunk/src/MSWriter.h

@@ -23 +23 @@
 #include <casa/Logging/LogIO.h>
 #include <casa/Containers/Record.h>
+#include <casa/Containers/RecordField.h>
 
 #include <tables/Tables/Table.h>
@@ -39 +40 @@
 namespace asap
 {
+class MSWriterUtils
+{
+protected:
+  template<class T> void putField( const String &name, 
+                                   TableRecord &r, 
+                                   T &val )
+  {
+    RecordFieldPtr<T> rf( r, name ) ;
+    *rf = val ;
+  }
+  template<class T> void defineField( const String &name, 
+                                      TableRecord &r, 
+                                      T &val )
+  {
+    RecordFieldPtr<T> rf( r, name ) ;
+    rf.define( val ) ;
+  }
+};
 
 class MSWriter
@@ -65 +84 @@
   void fillSource() ;
   void fillWeather() ;
-  void fillSysCal() ;
+  void fillSysCal( std::map< casa::Int,casa::Vector<casa::uInt> > &idrec, 
+                   std::map< casa::Int,casa::Vector<casa::uInt> > &rowrec ) ;
+//   void fillSysCal( Record &idrec, Record &rowrec ) ;
+//   void fillSysCal() ;
 
   // fill empty rows
@@ -86 +108 @@
   void queryType( casa::Int type, casa::String &stype, casa::Bool &b, casa::Double &t, Double &l ) ; 
   casa::Double getDishDiameter( casa::String antname ) ;
+  void antennaProperty( casa::String &name, casa::String &mount, casa::String &type, casa::Double &diameter ) ;
 
   // tool for HPC
@@ -111 +134 @@
   casa::LogIO os_ ;
 
-  casa::Record tcalIdRec_ ;
-  casa::Record tcalRowRec_ ;
+//   casa::Record tcalIdRec_ ;
+//   casa::Record tcalRowRec_ ;
+  casa::Record srcRec_ ;
   
   MSWriter();

trunk/src/TableTraverse.cpp

@@ -251 +251 @@
       sizes[i] = typeManagers[i]->sizeOf();
       BaseColumn *baseCol = ROTableColumnBackDoor::baseColumnPtr(cols[i]);
-      PlainColumn *col = dynamic_cast <PlainColumn *>(baseCol);
-      if (col) {
-        const uInt gotRows = col->dataManagerColumn()->
-          getBlockV(0, nRows, colValues[i]);
-        DebugAssert(gotRows == nRows, AipsError);
-      } else {
-        copyColumnData(colValues[i], typeManagers[i]->sizeOf(), nRows, baseCol);
-      }
+      copyColumnData(colValues[i], typeManagers[i]->sizeOf(), nRows, baseCol);
+//       PlainColumn *col = dynamic_cast <PlainColumn *>(baseCol);
+//       if (col) {
+//      const uInt gotRows = col->dataManagerColumn()->
+//        getBlockV(0, nRows, colValues[i]);
+//      DebugAssert(gotRows == nRows, AipsError);
+//       } else {
+//      copyColumnData(colValues[i], typeManagers[i]->sizeOf(), nRows, baseCol);
+//       }
     }