Changeset 1427 for trunk/external/atnf/PKSIO

Timestamp:

07/04/08 13:23:49 (16 years ago)

Author:

Malte Marquarding

Message:

sync with livedata/implement/atnf

Location:

trunk/external/atnf/PKSIO

Files:

• MBFITSreader.cc (modified) (12 diffs)
• MBFITSreader.h (modified) (2 diffs)
• PKSFITSreader.cc (modified) (8 diffs)
• PKSFITSreader.h (modified) (4 diffs)
• PKSMBrecord.cc (modified) (5 diffs)
• PKSMBrecord.h (modified) (3 diffs)
• PKSMS2reader.cc (modified) (14 diffs)
• PKSMS2reader.h (modified) (3 diffs)
• PKSreader.cc (modified) (4 diffs)
• PKSreader.h (modified) (7 diffs)
• SDFITSreader.cc (modified) (3 diffs)

trunk/external/atnf/PKSIO/MBFITSreader.cc

@@ -2 +2 @@
 //# MBFITSreader.cc: ATNF single-dish RPFITS reader.
 //#---------------------------------------------------------------------------
-//# Copyright (C) 2000-2007
+//# Copyright (C) 2000-2008
 //# Mark Calabretta, ATNF
 //#
@@ -27 +27 @@
 //#                        AUSTRALIA
 //#
-//# $Id: MBFITSreader.cc,v 19.36 2007/11/12 03:37:56 cal103 Exp $
+//# $Id: MBFITSreader.cc,v 19.38 2008-06-26 02:24:22 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# The MBFITSreader class reads single dish RPFITS files (such as Parkes
@@ -52 +52 @@
 const double PI = 3.141592653589793238462643;
 const double TWOPI = 2.0 * PI;
+const double R2D = 180.0 / PI;
 
 //------------------------------------------------- MBFITSreader::MBFITSreader
@@ -501 +502 @@
 
 #ifdef PKSIO_DEBUG
-        printf("End-of-file detected, flushing last scan.\n");
+        printf("\nEnd-of-file detected, flushing last scan.\n");
 #endif
 
@@ -609 +610 @@
           cCycleNo = 0;
           cPrevUTC = 0.0;
-          cStaleness = new int[cNBeamSel];
-          for (int iBeamSel = 0; iBeamSel < cNBeamSel; iBeamSel++) {
-            cStaleness[iBeamSel] = 0;
-          }
         }
 
@@ -670 +667 @@
 
 #ifdef PKSIO_DEBUG
-        printf(" In:%4d%4d%3d%3d\n", cScanNo, cCycleNo, beamNo, cIFno);
+        printf("\n In:%4d%4d%3d%3d\n", cScanNo, cCycleNo, beamNo, cIFno);
         if (cEOS) printf("Start of new scan, flushing previous scan.\n");
 #endif
@@ -730 +727 @@
 
     if (cFlushing && cFlushBin == 0 && cFlushIF == 0 && cInterp) {
-      // Interpolate the beam position at the start of the flush cycle.
-#ifdef PKSIO_DEBUG
-      printf("Doing position interpolation for beam %d.\n", iMBuff->beamNo);
-#endif
-
-      double prevRA  = iMBuff->ra;
-      double prevDec = iMBuff->dec;
-      double prevUTC = cPosUTC[iBeamSel];
-
-      if (!cEOF && !cEOS) {
-        // The position is measured by the control system at a time returned
-        // by RPFITSIN as the 'w' visibility coordinate.  The ra and dec,
-        // returned as the 'u' and 'v' visibility coordinates, must be
-        // interpolated to the integration time which RPFITSIN returns as
-        // 'cUTC', this usually being a second or two later.
-        //
+      // Start of flush cycle, interpolate the beam position.
+      //
+      // The position is measured by the control system at a time returned by
+      // RPFITSIN as the 'w' visibility coordinate.  The ra and dec, returned
+      // as the 'u' and 'v' visibility coordinates, must be interpolated to
+      // the integration time which RPFITSIN returns as 'cUTC', this usually
+      // being a second or two later.
+      //
+      // "This" RA, Dec, and UTC refers to the position currently stored in
+      // the buffer marked for output (iMBuff).  This position will be
+      // interpolated to the midpoint of that integration using the position
+      // recorded in the "next" integration which is currently sitting in the
+      // RPFITS commons.  The interpolation method used here is based on the
+      // scan rate.  At the end of a scan, or if the next position has not
+      // been updated, the most recent determination of the scan rate will be
+      // used for extrapolation.
+      //
+      // The rate "age" is the offset from "this" integration (in iMBuff) of
+      // the earliest integration in the pair used to compute the rate.  A
+      // rate "age" of 0 thus refers to the normal situation where the rate
+      // is determined from "this" integration and the "next" one.  An age
+      // of 1 cycle means that it is determined from "this" integration and
+      // the one preceding it, which should be equally reliable.  An age
+      // of 2 cycles means that the rate is determined from the previous
+      // integration and the one before that, so the extrapolation spans one
+      // integration cycle.  Thus it has a "staleness" of 1.
+
+      double thisRA  = iMBuff->ra;
+      double thisDec = iMBuff->dec;
+      double thisUTC = cPosUTC[iBeamSel];
+
+      if (cEOF || cEOS) {
+        iMBuff->rateAge++;
+        iMBuff->rateson = 0;
+        
+      } else {
         // Note that the time recorded as the 'w' visibility coordinate
         // cycles through 86400 back to 0 at midnight, whereas that in 'cUTC'
         // continues to increase past 86400.
 
-        double thisRA  = cU;
-        double thisDec = cV;
-        double thisUTC = cW;
-
-        if (thisUTC < prevUTC) {
+        double nextRA  = cU;
+        double nextDec = cV;
+        double nextUTC = cW;
+
+        if (nextUTC < thisUTC) {
           // Must have cycled through midnight.
-          thisUTC += 86400.0;
+          nextUTC += 86400.0;
         }
 
         // Guard against RA cycling through 24h in either direction.
-        if (fabs(thisRA - prevRA) > PI) {
-          if (thisRA < prevRA) {
-            thisRA += TWOPI;
+        if (fabs(nextRA - thisRA) > PI) {
+          if (nextRA < thisRA) {
+            nextRA += TWOPI;
           } else {
-            thisRA -= TWOPI;
+            nextRA -= TWOPI;
           }
         }
+
+#ifdef PKSIO_DEBUG
+        printf("Previous ra, dec, UTC:  %8.4f  %8.4f  %7.1f\n", thisRA*R2D,
+          thisDec*R2D, thisUTC);
+        printf("Current  ra, dec, UTC:  %8.4f  %8.4f  %7.1f\n", nextRA*R2D,
+          nextDec*R2D, nextUTC);
+#endif
 
         // The control system at Mopra typically does not update the
@@ -774 +798 @@
         // likely to be a better guess than anything else.
 
-        double dUTC = thisUTC - prevUTC;
+        double dUTC = nextUTC - thisUTC;
 
         // Scan rate for this beam.
         if (dUTC > 0.0) {
-          iMBuff->raRate  = (thisRA  - prevRA)  / dUTC;
-          iMBuff->decRate = (thisDec - prevDec) / dUTC;
+          iMBuff->raRate  = (nextRA  - thisRA)  / dUTC;
+          iMBuff->decRate = (nextDec - thisDec) / dUTC;
+          iMBuff->rateAge = 0;
+          iMBuff->rateson = 0;
 
           if (cInterp == 2) {
             // Use the same interpolation scheme as the original pksmbfits
-            // client.  This incorrectly assumed that (thisUTC - prevUTC) is
+            // client.  This incorrectly assumed that (nextUTC - thisUTC) is
             // equal to the integration time and interpolated by computing a
             // weighted sum of the positions before and after the required
@@ -789 +815 @@
 
             double utc = iMBuff->utc;
-            if (utc - prevUTC > 100.0) {
+            if (utc - thisUTC > 100.0) {
               // Must have cycled through midnight.
               utc -= 86400.0;
             }
 
-            double tw1 = 1.0 - (utc - prevUTC) / iMBuff->exposure;
-            double tw2 = 1.0 - (thisUTC - utc) / iMBuff->exposure;
-            double gamma = (tw2 / (tw1 + tw2)) * dUTC / (utc - prevUTC);
+            double tw1 = 1.0 - (utc - thisUTC) / iMBuff->exposure;
+            double tw2 = 1.0 - (nextUTC - utc) / iMBuff->exposure;
+            double gamma = (tw2 / (tw1 + tw2)) * dUTC / (utc - thisUTC);
 
             iMBuff->raRate  *= gamma;
@@ -802 +828 @@
           }
 
-          cStaleness[iBeamSel] = 0;
-
         } else {
-          // Issue warnings.
-          int nch = 0;
-          fprintf(stderr, "WARNING, scan %d,%n cycle %d: Position ",
-            iMBuff->scanNo, &nch, iMBuff->cycleNo);
-
+          iMBuff->rateAge++;
+
+          // Staleness codes.
           if (dUTC < 0.0) {
-            fprintf(stderr, "timestamp went backwards!\n");
+            iMBuff->rateson = 3;
           } else {
-            if (thisRA != prevRA || thisDec != prevDec) {
-              fprintf(stderr, "changed but timestamp unchanged!\n");
+            if (nextRA != thisRA || nextDec != thisDec) {
+              iMBuff->rateson = 2;
             } else {
-              fprintf(stderr, "and timestamp unchanged!\n");
+              iMBuff->rateson = 1;
             }
           }
-
-          cStaleness[iBeamSel]++;
-          fprintf(stderr, "%-*s Using stale scan rate, staleness = %d "
-            "cycle%s.\n", nch, "WARNING,", cStaleness[iBeamSel],
-            (cStaleness[iBeamSel] == 1) ? "" : "s");
-
-          if (thisRA != prevRA || thisDec != prevDec) {
-            if (iMBuff->raRate == 0.0 && iMBuff->decRate == 0.0) {
-              fprintf(stderr, "%-*s But the previous rate was zero!  "
-                "Position will be inaccurate.\n", nch, "WARNING,");
-            }
-          }
-        }
-      }
+        }
+      }
+
+#ifdef PKSIO_DEBUG
+      printf("Doing position interpolation for beam %d.\n", iMBuff->beamNo);
+      printf("RA and Dec rates and age: %7.4f  %7.4f  %d\n",
+        iMBuff->raRate*R2D, iMBuff->decRate*R2D, iMBuff->rateAge);
+#endif
 
       // Compute the position of this beam for all bins.
@@ -841 +857 @@
         cBuffer[jbuff].decRate = iMBuff->decRate;
 
-        double dutc = cBuffer[jbuff].utc - prevUTC;
+        double dutc = cBuffer[jbuff].utc - thisUTC;
         if (dutc > 100.0) {
           // Must have cycled through midnight.
@@ -847 +863 @@
         }
 
-        cBuffer[jbuff].ra  = prevRA  + cBuffer[jbuff].raRate  * dutc;
-        cBuffer[jbuff].dec = prevDec + cBuffer[jbuff].decRate * dutc;
+        cBuffer[jbuff].ra  = thisRA  + cBuffer[jbuff].raRate  * dutc;
+        cBuffer[jbuff].dec = thisDec + cBuffer[jbuff].decRate * dutc;
         if (cBuffer[jbuff].ra < 0.0) {
           cBuffer[jbuff].ra += TWOPI;

trunk/external/atnf/PKSIO/MBFITSreader.h

@@ -27 +27 @@
 //#                        AUSTRALIA
 //#
-//# $Id: MBFITSreader.h,v 19.14 2007/11/12 03:37:56 cal103 Exp $
+//# $Id: MBFITSreader.h,v 19.15 2008-06-26 02:14:36 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# The MBFITSreader class reads single dish RPFITS files (such as Parkes
@@ -114 +114 @@
     char   cDateObs[10];
     int    *cBeamSel, *cChanOff, cFirst, *cIFSel, cInterp, cIntTime, cMBopen,
-           cMopra, cNBeamSel, cNBin, cRetry, *cStaleness, cSUpos, *cXpolOff;
+           cMopra, cNBeamSel, cNBin, cRetry, cSUpos, *cXpolOff;
 
     // The data has to be bufferred to allow positions to be interpolated.

trunk/external/atnf/PKSIO/PKSFITSreader.cc

@@ -1 +1 @@
 //# PKSFITSreader.cc: Class to read Parkes multibeam data from a FITS file.
 //#---------------------------------------------------------------------------
-//# Copyright (C) 2000-2007
+//# Copyright (C) 2000-2008
 //# Associated Universities, Inc. Washington DC, USA.
 //#
@@ -25 +25 @@
 //#                        Charlottesville, VA 22903-2475 USA
 //#
-//# $Id: PKSFITSreader.cc,v 19.13 2007/11/12 03:37:56 cal103 Exp $
+//# $Id: PKSFITSreader.cc,v 19.14 2008-06-26 02:07:21 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# Original: 2000/08/02, Mark Calabretta, ATNF
@@ -50 +50 @@
         const Bool   interpolate)
 {
-  cMBrec.setNIFs(1);
+  cFITSMBrec.setNIFs(1);
 
   if (fitsType == "SDFITS") {
@@ -321 +321 @@
 // Read the next data record.
 
-Int PKSFITSreader::read(
-        Int             &scanNo,
-        Int             &cycleNo,
-        Double          &mjd,
-        Double          &interval,
-        String          &fieldName,
-        String          &srcName,
-        Vector<Double>  &srcDir,
-        Vector<Double>  &srcPM,
-        Double          &srcVel,
-        String          &obsType,
-        Int             &IFno,
-        Double          &refFreq,
-        Double          &bandwidth,
-        Double          &freqInc,
-        Double          &restFreq,
-        Vector<Float>   &tcal,
-        String          &tcalTime,
-        Float           &azimuth,
-        Float           &elevation,
-        Float           &parAngle,
-        Float           &focusAxi,
-        Float           &focusTan,
-        Float           &focusRot,
-        Float           &temperature,
-        Float           &pressure,
-        Float           &humidity,
-        Float           &windSpeed,
-        Float           &windAz,
-        Int             &refBeam,
-        Int             &beamNo,
-        Vector<Double>  &direction,
-        Vector<Double>  &scanRate,
-        Vector<Float>   &tsys,
-        Vector<Float>   &sigma,
-        Vector<Float>   &calFctr,
-        Matrix<Float>   &baseLin,
-        Matrix<Float>   &baseSub,
-        Matrix<Float>   &spectra,
-        Matrix<uChar>   &flagged,
-        Complex         &xCalFctr,
-        Vector<Complex> &xPol)
+Int PKSFITSreader::read(MBrecord &MBrec)
 {
   Int status;
 
-  if ((status = cReader->read(cMBrec))) {
+  if ((status = cReader->read(cFITSMBrec))) {
     if (status != -1) {
       status = 1;
@@ -375 +334 @@
 
 
-  uInt nChan = cMBrec.nChan[0];
-  uInt nPol  = cMBrec.nPol[0];
-
-  scanNo  = cMBrec.scanNo;
-  cycleNo = cMBrec.cycleNo;
+  uInt nChan = cFITSMBrec.nChan[0];
+  uInt nPol  = cFITSMBrec.nPol[0];
+
+  MBrec.scanNo  = cFITSMBrec.scanNo;
+  MBrec.cycleNo = cFITSMBrec.cycleNo;
 
   // Extract MJD.
   Int day, month, year;
-  sscanf(cMBrec.datobs, "%4d-%2d-%2d", &year, &month, &day);
-  mjd = MVTime(year, month, Double(day)).day() + cMBrec.utc/86400.0;
-
-  interval  = cMBrec.exposure;
-
-  fieldName = trim(cMBrec.srcName);
-  srcName   = fieldName;
-  srcDir(0) = cMBrec.srcRA;
-  srcDir(1) = cMBrec.srcDec;
-  srcPM(0)  = 0.0;
-  srcPM(1)  = 0.0;
-  srcVel    = 0.0;
-  obsType   = trim(cMBrec.obsType);
-
-  IFno = cMBrec.IFno[0];
-  Double chanWidth = fabs(cMBrec.fqDelt[0]);
-  refFreq   = cMBrec.fqRefVal[0];
-  bandwidth = chanWidth * nChan;
-  freqInc   = cMBrec.fqDelt[0];
-  restFreq  = cMBrec.restFreq;
-
-  tcal.resize(nPol);
+  sscanf(cFITSMBrec.datobs, "%4d-%2d-%2d", &year, &month, &day);
+  MBrec.mjd = MVTime(year, month, Double(day)).day() + cFITSMBrec.utc/86400.0;
+
+  MBrec.interval  = cFITSMBrec.exposure;
+
+  MBrec.fieldName = trim(cFITSMBrec.srcName);
+  MBrec.srcName   = MBrec.fieldName;
+
+  MBrec.srcDir.resize(2);
+  MBrec.srcDir(0) = cFITSMBrec.srcRA;
+  MBrec.srcDir(1) = cFITSMBrec.srcDec;
+
+  MBrec.srcPM.resize(2);
+  MBrec.srcPM(0)  = 0.0;
+  MBrec.srcPM(1)  = 0.0;
+  MBrec.srcVel    = 0.0;
+  MBrec.obsType   = trim(cFITSMBrec.obsType);
+
+  MBrec.IFno = cFITSMBrec.IFno[0];
+  Double chanWidth = fabs(cFITSMBrec.fqDelt[0]);
+  MBrec.refFreq   = cFITSMBrec.fqRefVal[0];
+  MBrec.bandwidth = chanWidth * nChan;
+  MBrec.freqInc   = cFITSMBrec.fqDelt[0];
+  MBrec.restFreq  = cFITSMBrec.restFreq;
+
+  MBrec.tcal.resize(nPol);
   for (uInt ipol = 0; ipol < nPol; ipol++) {
-    tcal(ipol) = cMBrec.tcal[0][ipol];
-  }
-  tcalTime  = trim(cMBrec.tcalTime);
-  azimuth   = cMBrec.azimuth;
-  elevation = cMBrec.elevation;
-  parAngle  = cMBrec.parAngle;
-  focusAxi  = cMBrec.focusAxi;
-  focusTan  = cMBrec.focusTan;
-  focusRot  = cMBrec.focusRot;
-
-  temperature = cMBrec.temp;
-  pressure    = cMBrec.pressure;
-  humidity    = cMBrec.humidity;
-  windSpeed   = cMBrec.windSpeed;
-  windAz      = cMBrec.windAz;
-
-  refBeam = cMBrec.refBeam;
-  beamNo  = cMBrec.beamNo;
-
-  direction(0) = cMBrec.ra;
-  direction(1) = cMBrec.dec;
-  scanRate(0)  = cMBrec.raRate;
-  scanRate(1)  = cMBrec.decRate;
-
-  tsys.resize(nPol);
-  sigma.resize(nPol);
-  calFctr.resize(nPol);
+    MBrec.tcal(ipol) = cFITSMBrec.tcal[0][ipol];
+  }
+  MBrec.tcalTime  = trim(cFITSMBrec.tcalTime);
+  MBrec.azimuth   = cFITSMBrec.azimuth;
+  MBrec.elevation = cFITSMBrec.elevation;
+  MBrec.parAngle  = cFITSMBrec.parAngle;
+  MBrec.focusAxi  = cFITSMBrec.focusAxi;
+  MBrec.focusTan  = cFITSMBrec.focusTan;
+  MBrec.focusRot  = cFITSMBrec.focusRot;
+
+  MBrec.temperature = cFITSMBrec.temp;
+  MBrec.pressure    = cFITSMBrec.pressure;
+  MBrec.humidity    = cFITSMBrec.humidity;
+  MBrec.windSpeed   = cFITSMBrec.windSpeed;
+  MBrec.windAz      = cFITSMBrec.windAz;
+
+  MBrec.refBeam = cFITSMBrec.refBeam;
+  MBrec.beamNo  = cFITSMBrec.beamNo;
+
+  MBrec.direction.resize(2);
+  MBrec.direction(0) = cFITSMBrec.ra;
+  MBrec.direction(1) = cFITSMBrec.dec;
+
+  MBrec.scanRate.resize(2);
+  MBrec.scanRate(0)  = cFITSMBrec.raRate;
+  MBrec.scanRate(1)  = cFITSMBrec.decRate;
+  MBrec.rateAge      = cFITSMBrec.rateAge;
+  MBrec.rateson      = cFITSMBrec.rateson;
+
+  MBrec.tsys.resize(nPol);
+  MBrec.sigma.resize(nPol);
+  MBrec.calFctr.resize(nPol);
   for (uInt ipol = 0; ipol < nPol; ipol++) {
-    tsys(ipol)  = cMBrec.tsys[0][ipol];
-    sigma(ipol) = tsys(ipol) / 0.81 / sqrt(interval * chanWidth);
-    calFctr(ipol) = cMBrec.calfctr[0][ipol];
-  }
-
-  if (cMBrec.haveBase) {
-    baseLin.resize(2,nPol);
-    baseSub.resize(9,nPol);
+    MBrec.tsys(ipol)  = cFITSMBrec.tsys[0][ipol];
+    MBrec.sigma(ipol) = (MBrec.tsys(ipol) / 0.81) /
+                         sqrt(MBrec.interval * chanWidth);
+    MBrec.calFctr(ipol) = cFITSMBrec.calfctr[0][ipol];
+  }
+
+  if (cFITSMBrec.haveBase) {
+    MBrec.baseLin.resize(2,nPol);
+    MBrec.baseSub.resize(9,nPol);
 
     for (uInt ipol = 0; ipol < nPol; ipol++) {
-      baseLin(0,ipol) = cMBrec.baseLin[0][ipol][0];
-      baseLin(1,ipol) = cMBrec.baseLin[0][ipol][1];
+      MBrec.baseLin(0,ipol) = cFITSMBrec.baseLin[0][ipol][0];
+      MBrec.baseLin(1,ipol) = cFITSMBrec.baseLin[0][ipol][1];
 
       for (uInt j = 0; j < 9; j++) {
-        baseSub(j,ipol) = cMBrec.baseSub[0][ipol][j];
+        MBrec.baseSub(j,ipol) = cFITSMBrec.baseSub[0][ipol][j];
       }
     }
 
   } else {
-    baseLin.resize(0,0);
-    baseSub.resize(0,0);
-  }
-
-  if (cGetSpectra && cMBrec.haveSpectra) {
-    spectra.resize(nChan,nPol);
-    spectra.takeStorage(IPosition(2,nChan,nPol), cMBrec.spectra[0], SHARE);
-
-    flagged.resize(nChan,nPol);
-    flagged.takeStorage(IPosition(2,nChan,nPol), cMBrec.flagged[0], SHARE);
+    MBrec.baseLin.resize(0,0);
+    MBrec.baseSub.resize(0,0);
+  }
+
+  if (cGetSpectra && cFITSMBrec.haveSpectra) {
+    MBrec.spectra.resize(nChan,nPol);
+    MBrec.spectra.takeStorage(IPosition(2,nChan,nPol), cFITSMBrec.spectra[0],
+      SHARE);
+
+    MBrec.flagged.resize(nChan,nPol);
+    MBrec.flagged.takeStorage(IPosition(2,nChan,nPol), cFITSMBrec.flagged[0],
+      SHARE);
 
   } else {
-    spectra.resize(0,0);
-    flagged.resize(0,0);
+    MBrec.spectra.resize(0,0);
+    MBrec.flagged.resize(0,0);
   }
 
   if (cGetXPol) {
-    xCalFctr = Complex(cMBrec.xcalfctr[0][0], cMBrec.xcalfctr[0][1]);
-    xPol.resize(nChan);
-    xPol.takeStorage(IPosition(1,nChan), (Complex *)cMBrec.xpol[0], SHARE);
+    MBrec.xCalFctr = Complex(cFITSMBrec.xcalfctr[0][0],
+                             cFITSMBrec.xcalfctr[0][1]);
+    MBrec.xPol.resize(nChan);
+    MBrec.xPol.takeStorage(IPosition(1,nChan), (Complex *)cFITSMBrec.xpol[0],
+      SHARE);
   }
 
@@ -493 +466 @@
   Int status;
 
-  if ((status = cReader->read(cMBrec))) {
+  if ((status = cReader->read(cFITSMBrec))) {
     if (status != -1) {
       status = 1;
@@ -501 +474 @@
   }
 
-  IFno = cMBrec.IFno[0];
-
-  uInt nChan = cMBrec.nChan[0];
-  uInt nPol  = cMBrec.nPol[0];
+  IFno = cFITSMBrec.IFno[0];
+
+  uInt nChan = cFITSMBrec.nChan[0];
+  uInt nPol  = cFITSMBrec.nPol[0];
 
   tsys.resize(nPol);
   calFctr.resize(nPol);
   for (uInt ipol = 0; ipol < nPol; ipol++) {
-    tsys(ipol) = cMBrec.tsys[0][ipol];
-    calFctr(ipol) = cMBrec.calfctr[0][ipol];
-  }
-
-  if (cMBrec.haveBase) {
+    tsys(ipol) = cFITSMBrec.tsys[0][ipol];
+    calFctr(ipol) = cFITSMBrec.calfctr[0][ipol];
+  }
+
+  if (cFITSMBrec.haveBase) {
     baseLin.resize(2,nPol);
     baseSub.resize(9,nPol);
 
     for (uInt ipol = 0; ipol < nPol; ipol++) {
-      baseLin(0,ipol) = cMBrec.baseLin[0][ipol][0];
-      baseLin(1,ipol) = cMBrec.baseLin[0][ipol][1];
+      baseLin(0,ipol) = cFITSMBrec.baseLin[0][ipol][0];
+      baseLin(1,ipol) = cFITSMBrec.baseLin[0][ipol][1];
 
       for (uInt j = 0; j < 9; j++) {
-        baseSub(j,ipol) = cMBrec.baseSub[0][ipol][j];
+        baseSub(j,ipol) = cFITSMBrec.baseSub[0][ipol][j];
       }
     }
@@ -531 +504 @@
   }
 
-  if (cGetSpectra && cMBrec.haveSpectra) {
+  if (cGetSpectra && cFITSMBrec.haveSpectra) {
     spectra.resize(nChan,nPol);
-    spectra.takeStorage(IPosition(2,nChan,nPol), cMBrec.spectra[0], SHARE);
+    spectra.takeStorage(IPosition(2,nChan,nPol), cFITSMBrec.spectra[0],
+      SHARE);
 
     flagged.resize(nChan,nPol);
-    flagged.takeStorage(IPosition(2,nChan,nPol), cMBrec.flagged[0], SHARE);
+    flagged.takeStorage(IPosition(2,nChan,nPol), cFITSMBrec.flagged[0],
+      SHARE);
 
   } else {

trunk/external/atnf/PKSIO/PKSFITSreader.h

@@ -2 +2 @@
 //# PKSFITSreader.h: Class to read Parkes Multibeam data from a FITS file.
 //#---------------------------------------------------------------------------
-//# Copyright (C) 2000-2007
+//# Copyright (C) 2000-2008
 //# Associated Universities, Inc. Washington DC, USA.
 //#
@@ -26 +26 @@
 //#                        Charlottesville, VA 22903-2475 USA
 //#
-//# $Id: PKSFITSreader.h,v 19.12 2007/11/12 03:37:56 cal103 Exp $
+//# $Id: PKSFITSreader.h,v 19.13 2008-06-26 02:02:43 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# This class is basically a wrapper class for reading data from either an
@@ -114 +114 @@
 
     // Read the next data record.
-    virtual Int read(
-        Int             &scanNo,
-        Int             &cycleNo,
-        Double          &mjd,
-        Double          &interval,
-        String          &fieldName,
-        String          &srcName,
-        Vector<Double>  &srcDir,
-        Vector<Double>  &srcPM,
-        Double          &srcVel,
-        String          &obsType,
-        Int             &IFno,
-        Double          &refFreq,
-        Double          &bandwidth,
-        Double          &freqInc,
-        Double          &restFreq,
-        Vector<Float>   &tcal,
-        String          &tcalTime,
-        Float           &azimuth,
-        Float           &elevation,
-        Float           &parAngle,
-        Float           &focusAxi,
-        Float           &focusTan,
-        Float           &focusRot,
-        Float           &temperature,
-        Float           &pressure,
-        Float           &humidity,
-        Float           &windSpeed,
-        Float           &windAz,
-        Int             &refBeam,
-        Int             &beamNo,
-        Vector<Double>  &direction,
-        Vector<Double>  &scanRate,
-        Vector<Float>   &tsys,
-        Vector<Float>   &sigma,
-        Vector<Float>   &calFctr,
-        Matrix<Float>   &baseLin,
-        Matrix<Float>   &baseSub,
-        Matrix<Float>   &spectra,
-        Matrix<uChar>   &flagged,
-        Complex         &xCalFctr,
-        Vector<Complex> &xPol);
+    virtual Int read(MBrecord &mbrec);
 
     // Read the next data record, just the basics.
@@ -173 +132 @@
     Int    *cBeams, *cIFs;
     uInt   cNBeam, cNIF;
-    PKSMBrecord cMBrec;
+    PKSMBrecord cFITSMBrec;
     FITSreader  *cReader;
 

trunk/external/atnf/PKSIO/PKSMBrecord.cc

@@ -2 +2 @@
 //# PKSMBrecord.cc: Class to store an MBFITS single-dish data record.
 //#---------------------------------------------------------------------------
-//# Copyright (C) 2000-2006
+//# Copyright (C) 2000-2008
 //# Mark Calabretta, ATNF
 //#
@@ -27 +27 @@
 //#                        AUSTRALIA
 //#
-//# $Id: PKSMBrecord.cc,v 19.6 2006/07/05 04:52:07 mcalabre Exp $
+//# $Id: PKSMBrecord.cc,v 19.7 2008-06-26 02:10:21 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# The PKSMBrecord class stores an MBFITS single-dish data record.
@@ -53 +53 @@
   raRate  = 0.0f;
   decRate = 0.0f;
+  rateAge = 0;
   nIF     = 0;
 }
@@ -226 +227 @@
   // Beam-dependent parameters.
   beamNo  = other.beamNo;
-  ra       = other.ra;
-  dec      = other.dec;
-  raRate   = other.raRate;
-  decRate  = other.decRate;
+  ra      = other.ra;
+  dec     = other.dec;
+  raRate  = other.raRate;
+  decRate = other.decRate;
+  rateAge = other.rateAge;
+  rateson = other.rateson;
 
   // IF-dependent parameters.
@@ -343 +346 @@
   // Beam-dependent parameters.
   beamNo  = other.beamNo;
-  ra       = other.ra;
-  dec      = other.dec;
-  raRate   = other.raRate;
-  decRate  = other.decRate;
+  ra      = other.ra;
+  dec     = other.dec;
+  raRate  = other.raRate;
+  decRate = other.decRate;
+  rateAge = other.rateAge;
+  rateson = other.rateson;
 
   // IF-dependent parameters.

trunk/external/atnf/PKSIO/PKSMBrecord.h

@@ -2 +2 @@
 //# PKSMBrecord.h: Class to store an MBFITS single-dish data record.
 //#---------------------------------------------------------------------------
-//# Copyright (C) 2000-2006
+//# Copyright (C) 2000-2008
 //# Mark Calabretta, ATNF
 //#
@@ -27 +27 @@
 //#                        AUSTRALIA
 //#
-//# $Id: PKSMBrecord.h,v 19.8 2006/07/05 04:52:07 mcalabre Exp $
+//# $Id: PKSMBrecord.h,v 19.9 2008-06-26 02:10:21 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# The PKSMBrecord class stores an MBFITS single-dish data record.
@@ -109 +109 @@
     float  raRate;              // Scan rate in right ascension, radian/s.
     float  decRate;             // Scan rate in declination, radian/s.
+    short  rateAge;             // Scan rate age (staleness), cycles.
+    short  rateson;             // Staleness reason code:
+                                //   1: position and timestamp unchanged,
+                                //   2: position changed but not timestamp,
+                                //   3: position timestamp went backwards.
 
     // IF-dependent parameters.

trunk/external/atnf/PKSIO/PKSMS2reader.cc

@@ -2 +2 @@
 //# PKSMS2reader.cc: Class to read Parkes Multibeam data from a v2 MS.
 //#---------------------------------------------------------------------------
-//# Copyright (C) 2000-2007
+//# Copyright (C) 2000-2008
 //# Associated Universities, Inc. Washington DC, USA.
 //#
@@ -26 +26 @@
 //#                        Charlottesville, VA 22903-2475 USA
 //#
-//# $Id: PKSMS2reader.cc,v 19.12 2007/11/12 03:37:56 cal103 Exp $
+//# $Id: PKSMS2reader.cc,v 19.13 2008-06-26 02:08:02 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# Original: 2000/08/03, Mark Calabretta, ATNF
@@ -248 +248 @@
         String &antName,
         Vector<Double> &antPosition,
-        String &obsMode,
+        String &obsType,
         String &bunit,
         Float  &equinox,
@@ -272 +272 @@
   // Observation type.
   if (cObsModeCol.nrow()) {
-    obsMode = cObsModeCol(0);
-    if (obsMode == "\0") obsMode = "RF";
-  } else {
-    obsMode = "RF";
+    obsType = cObsModeCol(0);
+    if (obsType == "\0") obsType = "RF";
+  } else {
+    obsType = "RF";
   }
 
@@ -486 +486 @@
 // Read the next data record.
 
-Int PKSMS2reader::read(
-        Int             &scanNo,
-        Int             &cycleNo,
-        Double          &mjd,
-        Double          &interval,
-        String          &fieldName,
-        String          &srcName,
-        Vector<Double>  &srcDir,
-        Vector<Double>  &srcPM,
-        Double          &srcVel,
-        String          &obsMode,
-        Int             &IFno,
-        Double          &refFreq,
-        Double          &bandwidth,
-        Double          &freqInc,
-        Double          &restFreq,
-        Vector<Float>   &tcal,
-        String          &tcalTime,
-        Float           &azimuth,
-        Float           &elevation,
-        Float           &parAngle,
-        Float           &focusAxi,
-        Float           &focusTan,
-        Float           &focusRot,
-        Float           &temperature,
-        Float           &pressure,
-        Float           &humidity,
-        Float           &windSpeed,
-        Float           &windAz,
-        Int             &refBeam,
-        Int             &beamNo,
-        Vector<Double>  &direction,
-        Vector<Double>  &scanRate,
-        Vector<Float>   &tsys,
-        Vector<Float>   &sigma,
-        Vector<Float>   &calFctr,
-        Matrix<Float>   &baseLin,
-        Matrix<Float>   &baseSub,
-        Matrix<Float>   &spectra,
-        Matrix<uChar>   &flagged,
-        Complex         &xCalFctr,
-        Vector<Complex> &xPol)
+Int PKSMS2reader::read(MBrecord &MBrec)
 {
   if (!cMSopen) {
@@ -555 +514 @@
 
   // Renumerate scan no. Here still is 1-based
-  scanNo = cScanNoCol(cIdx) - cScanNoCol(0) + 1;
-
-  if (scanNo != cScanNo) {
+  MBrec.scanNo = cScanNoCol(cIdx) - cScanNoCol(0) + 1;
+
+  if (MBrec.scanNo != cScanNo) {
     // Start of new scan.
-    cScanNo  = scanNo;
+    cScanNo  = MBrec.scanNo;
     cCycleNo = 1;
     cTime    = cTimeCol(cIdx);
@@ -565 +524 @@
 
   Double time = cTimeCol(cIdx);
-  mjd      = time/86400.0;
-  interval = cIntervalCol(cIdx);
+  MBrec.mjd      = time/86400.0;
+  MBrec.interval = cIntervalCol(cIdx);
 
   // Reconstruct the integration cycle number; due to small latencies the
   // integration time is usually slightly less than the time between cycles,
   // resetting cTime will prevent the difference from accumulating.
-  cCycleNo += nint((time - cTime)/interval);
-  cycleNo = cCycleNo;
+  cCycleNo += nint((time - cTime)/MBrec.interval);
+  MBrec.cycleNo = cCycleNo;
   cTime   = time;
 
   Int fieldId = cFieldIdCol(cIdx);
-  fieldName = cFieldNameCol(fieldId);
+  MBrec.fieldName = cFieldNameCol(fieldId);
 
   Int srcId = cSrcIdCol(fieldId);
-  srcName = cSrcNameCol(srcId);
-  srcDir  = cSrcDirCol(srcId);
-  srcPM   = cSrcPMCol(srcId);
+  MBrec.srcName = cSrcNameCol(srcId);
+  MBrec.srcDir  = cSrcDirCol(srcId);
+  MBrec.srcPM   = cSrcPMCol(srcId);
 
   // Systemic velocity.
   if (!cHaveSrcVel) {
-    srcVel = 0.0f;
-  } else {
-    srcVel  = cSrcVelCol(srcId)(IPosition(1,0));
+    MBrec.srcVel = 0.0f;
+  } else {
+    MBrec.srcVel  = cSrcVelCol(srcId)(IPosition(1,0));
   }
 
   // Observation type.
   Int stateId = cStateIdCol(cIdx);
-  obsMode = cObsModeCol(stateId);
-
-  IFno = iIF + 1;
+  MBrec.obsType = cObsModeCol(stateId);
+
+  MBrec.IFno = iIF + 1;
   Int nChan = abs(cEndChan(iIF) - cStartChan(iIF)) + 1;
 
@@ -601 +560 @@
   if (nChan == 1) {
     cout << "The input is continuum data. "<< endl;
-    freqInc  = chanFreq(0);
-    refFreq  = chanFreq(0);
-    restFreq = 0.0f;
+    MBrec.freqInc  = chanFreq(0);
+    MBrec.refFreq  = chanFreq(0);
+    MBrec.restFreq = 0.0f;
   } else {
     if (cStartChan(iIF) <= cEndChan(iIF)) {
-      freqInc = chanFreq(1) - chanFreq(0);
+      MBrec.freqInc = chanFreq(1) - chanFreq(0);
     } else {
-      freqInc = chanFreq(0) - chanFreq(1);
-    }
-
-    refFreq  = chanFreq(cRefChan(iIF)-1);
-    restFreq = cSrcRestFrqCol(srcId)(IPosition(1,0));
-  }
-  bandwidth = abs(freqInc * nChan);
-
-  tcal.resize(cNPol(iIF));
-  tcal      = 0.0f;
-  tcalTime  = "";
-  azimuth   = 0.0f;
-  elevation = 0.0f;
-  parAngle  = 0.0f;
-  focusAxi  = 0.0f;
-  focusTan  = 0.0f;
-  focusRot  = 0.0f;
+      MBrec.freqInc = chanFreq(0) - chanFreq(1);
+    }
+
+    MBrec.refFreq  = chanFreq(cRefChan(iIF)-1);
+    MBrec.restFreq = cSrcRestFrqCol(srcId)(IPosition(1,0));
+  }
+  MBrec.bandwidth = abs(MBrec.freqInc * nChan);
+
+  MBrec.tcal.resize(cNPol(iIF));
+  MBrec.tcal      = 0.0f;
+  MBrec.tcalTime  = "";
+  MBrec.azimuth   = 0.0f;
+  MBrec.elevation = 0.0f;
+  MBrec.parAngle  = 0.0f;
+  MBrec.focusAxi  = 0.0f;
+  MBrec.focusTan  = 0.0f;
+  MBrec.focusRot  = 0.0f;
 
   // Find the appropriate entry in the WEATHER subtable.
@@ -637 +596 @@
   if (weatherIdx < 0) {
     // No appropriate WEATHER entry.
-    pressure    = 0.0f;
-    humidity    = 0.0f;
-    temperature = 0.0f;
-  } else {
-    pressure    = cPressureCol(weatherIdx);
-    humidity    = cHumidityCol(weatherIdx);
-    temperature = cTemperatureCol(weatherIdx);
-  }
-
-  windSpeed = 0.0f;
-  windAz    = 0.0f;
-
-  refBeam = 0;
-  beamNo  = ibeam + 1;
+    MBrec.temperature = 0.0f;
+    MBrec.pressure    = 0.0f;
+    MBrec.humidity    = 0.0f;
+  } else {
+    MBrec.temperature = cTemperatureCol(weatherIdx);
+    MBrec.pressure    = cPressureCol(weatherIdx);
+    MBrec.humidity    = cHumidityCol(weatherIdx);
+  }
+
+  MBrec.windSpeed = 0.0f;
+  MBrec.windAz    = 0.0f;
+
+  MBrec.refBeam = 0;
+  MBrec.beamNo  = ibeam + 1;
 
   Matrix<Double> pointingDir = cPointingCol(fieldId);
-  direction = pointingDir.column(0);
+  MBrec.direction = pointingDir.column(0);
   uInt ncols = pointingDir.ncolumn();
   if (ncols == 1) {
-    scanRate = 0.0f;
-  } else {
-    scanRate  = pointingDir.column(1);
-  }
+    MBrec.scanRate = 0.0f;
+  } else {
+    MBrec.scanRate  = pointingDir.column(1);
+  }
+  MBrec.rateAge = 0;
+  MBrec.rateson = 0;
 
   // Get Tsys assuming that entries in the SYSCAL table match the main table.
@@ -669 +630 @@
   }
   if (cHaveTsys) {
-    cTsysCol.get(cIdx, tsys, True);
+    cTsysCol.get(cIdx, MBrec.tsys, True);
   } else {
     Int numReceptor;
     cNumReceptorCol.get(0, numReceptor);
-    tsys.resize(numReceptor);
-    tsys = 1.0f;
-  }
-  cSigmaCol.get(cIdx, sigma, True);
+    MBrec.tsys.resize(numReceptor);
+    MBrec.tsys = 1.0f;
+  }
+  cSigmaCol.get(cIdx, MBrec.sigma, True);
 
   // Calibration factors (if available).
-  calFctr.resize(cNPol(iIF));
+  MBrec.calFctr.resize(cNPol(iIF));
   if (cHaveCalFctr) {
-    cCalFctrCol.get(cIdx, calFctr);
-  } else {
-    calFctr = 0.0f;
+    cCalFctrCol.get(cIdx, MBrec.calFctr);
+  } else {
+    MBrec.calFctr = 0.0f;
   }
 
   // Baseline parameters (if available).
   if (cHaveBaseLin) {
-    baseLin.resize(2,cNPol(iIF));
-    cBaseLinCol.get(cIdx, baseLin);
-
-    baseSub.resize(9,cNPol(iIF));
-    cBaseSubCol.get(cIdx, baseSub);
-
-  } else {
-    baseLin.resize(0,0);
-    baseSub.resize(0,0);
+    MBrec.baseLin.resize(2,cNPol(iIF));
+    cBaseLinCol.get(cIdx, MBrec.baseLin);
+
+    MBrec.baseSub.resize(9,cNPol(iIF));
+    cBaseSubCol.get(cIdx, MBrec.baseSub);
+
+  } else {
+    MBrec.baseLin.resize(0,0);
+    MBrec.baseSub.resize(0,0);
   }
 
@@ -709 +670 @@
     // Transpose spectra.
     Int nPol = tmpData.nrow();
-    spectra.resize(nChan, nPol);
-    flagged.resize(nChan, nPol);
+    MBrec.spectra.resize(nChan, nPol);
+    MBrec.flagged.resize(nChan, nPol);
     if (cEndChan(iIF) >= cStartChan(iIF)) {
       // Simple transposition.
       for (Int ipol = 0; ipol < nPol; ipol++) {
         for (Int ichan = 0; ichan < nChan; ichan++) {
-          spectra(ichan,ipol) = tmpData(ipol,ichan);
-          flagged(ichan,ipol) = tmpFlag(ipol,ichan);
+          MBrec.spectra(ichan,ipol) = tmpData(ipol,ichan);
+          MBrec.flagged(ichan,ipol) = tmpFlag(ipol,ichan);
         }
       }
@@ -725 +686 @@
       for (Int ipol = 0; ipol < nPol; ipol++) {
         for (Int ichan = 0; ichan < nChan; ichan++, jchan--) {
-          spectra(ichan,ipol) = tmpData(ipol,jchan);
-          flagged(ichan,ipol) = tmpFlag(ipol,jchan);
+          MBrec.spectra(ichan,ipol) = tmpData(ipol,jchan);
+          MBrec.flagged(ichan,ipol) = tmpFlag(ipol,jchan);
         }
       }
@@ -735 +696 @@
   if (cGetXPol) {
     if (cHaveXCalFctr) {
-      cXCalFctrCol.get(cIdx, xCalFctr);
+      cXCalFctrCol.get(cIdx, MBrec.xCalFctr);
     } else {
-      xCalFctr = Complex(0.0f, 0.0f);
-    }
-
-    cDataCol.get(cIdx, xPol, True);
+      MBrec.xCalFctr = Complex(0.0f, 0.0f);
+    }
+
+    cDataCol.get(cIdx, MBrec.xPol, True);
 
     if (cEndChan(iIF) < cStartChan(iIF)) {
@@ -746 +707 @@
       Int jchan = nChan - 1;
       for (Int ichan = 0; ichan < nChan/2; ichan++, jchan--) {
-        ctmp = xPol(ichan);
-        xPol(ichan) = xPol(jchan);
-        xPol(jchan) = ctmp;
+        ctmp = MBrec.xPol(ichan);
+        MBrec.xPol(ichan) = MBrec.xPol(jchan);
+        MBrec.xPol(jchan) = ctmp;
       }
     }

trunk/external/atnf/PKSIO/PKSMS2reader.h

@@ -2 +2 @@
 //# PKSMS2reader.h: Class to read Parkes Multibeam data from a v2 MS.
 //#---------------------------------------------------------------------------
-//# Copyright (C) 2000-2007
+//# Copyright (C) 2000-2008
 //# Associated Universities, Inc. Washington DC, USA.
 //#
@@ -26 +26 @@
 //#                        Charlottesville, VA 22903-2475 USA
 //#
-//# $Id: PKSMS2reader.h,v 19.13 2007/11/12 03:37:56 cal103 Exp $
+//# $Id: PKSMS2reader.h,v 19.14 2008-06-26 02:03:51 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# Original: 2000/08/03, Mark Calabretta, ATNF
@@ -111 +111 @@
 
     // Read the next data record.
-    virtual Int read(
-        Int             &scanNo,
-        Int             &cycleNo,
-        Double          &mjd,
-        Double          &interval,
-        String          &fieldName,
-        String          &srcName,
-        Vector<Double>  &srcDir,
-        Vector<Double>  &srcPM,
-        Double          &srcVel,
-        String          &obsMode,
-        Int             &IFno,
-        Double          &refFreq,
-        Double          &bandwidth,
-        Double          &freqInc,
-        Double          &restFreq,
-        Vector<Float>   &tcal,
-        String          &tcalTime,
-        Float           &azimuth,
-        Float           &elevation,
-        Float           &parAngle,
-        Float           &focusAxi,
-        Float           &focusTan,
-        Float           &focusRot,
-        Float           &temperature,
-        Float           &pressure,
-        Float           &humidity,
-        Float           &windSpeed,
-        Float           &windAz,
-        Int             &refBeam,
-        Int             &beamNo,
-        Vector<Double>  &direction,
-        Vector<Double>  &scanRate,
-        Vector<Float>   &tsys,
-        Vector<Float>   &sigma,
-        Vector<Float>   &calFctr,
-        Matrix<Float>   &baseLin,
-        Matrix<Float>   &baseSub,
-        Matrix<Float>   &spectra,
-        Matrix<uChar>   &flagged,
-        Complex         &xCalFctr,
-        Vector<Complex> &xPol);
+    virtual Int read(MBrecord &mbrec);
 
     // Read the next data record, just the basics.

trunk/external/atnf/PKSIO/PKSreader.cc

@@ -2 +2 @@
 //# PKSreader.cc: Class to read Parkes multibeam data.
 //#---------------------------------------------------------------------------
-//# Copyright (C) 2000-2006
+//# Copyright (C) 2000-2008
 //# Associated Universities, Inc. Washington DC, USA.
 //#
@@ -26 +26 @@
 //#                        Charlottesville, VA 22903-2475 USA
 //#
-//# $Id: PKSreader.cc,v 19.4 2006/05/19 02:14:50 mcalabre Exp $
+//# $Id: PKSreader.cc,v 19.6 2008-06-26 01:54:08 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# Original: 2000/08/23, Mark Calabretta, ATNF
@@ -75 +75 @@
   if (inFile.isRegular()) {
     // Is it MBFITS or SDFITS?
-    RegularFileIO file(name);
-    char buf[32];
-    file.read(30, buf, False);
-    buf[30] = '\0';
-    if (String(buf) == "SIMPLE  =                    T") {
-      // Looks like SDFITS.
+    if (strstr(name.chars(), ".sdfits")) {
+      // Looks like SDFITS, possibly gzip'd.
       format = "SDFITS";
       reader = new PKSFITSreader("SDFITS");
 
     } else {
-      // Assume it's MBFITS.
-      format = "MBFITS";
-      reader = new PKSFITSreader("MBFITS", retry, interpolate);
+      RegularFileIO file(name);
+      char buf[32];
+      file.read(30, buf, False);
+      buf[30] = '\0';
+      if (String(buf) == "SIMPLE  =                    T") {
+        // Looks like SDFITS.
+        format = "SDFITS";
+        reader = new PKSFITSreader("SDFITS");
+
+      } else {
+        // Assume it's MBFITS.
+        format = "MBFITS";
+        reader = new PKSFITSreader("MBFITS", retry, interpolate);
+      }
     }
 
@@ -155 +162 @@
   return 0;
 }
+
+
+//-------------------------------------------------------- PKSFITSreader::read
+
+// Read the next data record.
+
+Int PKSreader::read(
+        Int             &scanNo,
+        Int             &cycleNo,
+        Double          &mjd,
+        Double          &interval,
+        String          &fieldName,
+        String          &srcName,
+        Vector<Double>  &srcDir,
+        Vector<Double>  &srcPM,
+        Double          &srcVel,
+        String          &obsType,
+        Int             &IFno,
+        Double          &refFreq,
+        Double          &bandwidth,
+        Double          &freqInc,
+        Double          &restFreq,
+        Vector<Float>   &tcal,
+        String          &tcalTime,
+        Float           &azimuth,
+        Float           &elevation,
+        Float           &parAngle,
+        Float           &focusAxi,
+        Float           &focusTan,
+        Float           &focusRot,
+        Float           &temperature,
+        Float           &pressure,
+        Float           &humidity,
+        Float           &windSpeed,
+        Float           &windAz,
+        Int             &refBeam,
+        Int             &beamNo,
+        Vector<Double>  &direction,
+        Vector<Double>  &scanRate,
+        Vector<Float>   &tsys,
+        Vector<Float>   &sigma,
+        Vector<Float>   &calFctr,
+        Matrix<Float>   &baseLin,
+        Matrix<Float>   &baseSub,
+        Matrix<Float>   &spectra,
+        Matrix<uChar>   &flagged,
+        Complex         &xCalFctr,
+        Vector<Complex> &xPol)
+{
+  Int status;
+  MBrecord MBrec;
+
+  if ((status = read(MBrec))) {
+    if (status != -1) {
+      status = 1;
+    }
+
+    return status;
+  }
+
+  scanNo      = MBrec.scanNo;
+  cycleNo     = MBrec.cycleNo;
+  mjd         = MBrec.mjd;
+  interval    = MBrec.interval;
+  fieldName   = MBrec.fieldName;
+  srcName     = MBrec.srcName;
+  srcDir      = MBrec.srcDir;
+  srcPM       = MBrec.srcPM;
+  srcVel      = MBrec.srcVel;
+  obsType     = MBrec.obsType;
+  IFno        = MBrec.IFno;
+  refFreq     = MBrec.refFreq;
+  bandwidth   = MBrec.bandwidth;
+  freqInc     = MBrec.freqInc;
+  restFreq    = MBrec.restFreq;
+  tcal        = MBrec.tcal;
+  tcalTime    = MBrec.tcalTime;
+  azimuth     = MBrec.azimuth;
+  elevation   = MBrec.elevation;
+  parAngle    = MBrec.parAngle;
+  focusAxi    = MBrec.focusAxi;
+  focusTan    = MBrec.focusTan;
+  focusRot    = MBrec.focusRot;
+  temperature = MBrec.temperature;
+  pressure    = MBrec.pressure;
+  humidity    = MBrec.humidity;
+  windSpeed   = MBrec.windSpeed;
+  windAz      = MBrec.windAz;
+  refBeam     = MBrec.refBeam;
+  beamNo      = MBrec.beamNo;
+  direction   = MBrec.direction;
+  scanRate    = MBrec.scanRate;
+  tsys        = MBrec.tsys;
+  sigma       = MBrec.sigma;
+  calFctr     = MBrec.calFctr;
+  baseLin     = MBrec.baseLin;
+  baseSub     = MBrec.baseSub;
+  spectra     = MBrec.spectra;
+  flagged     = MBrec.flagged;
+  xCalFctr    = MBrec.xCalFctr;
+  xPol        = MBrec.xPol;
+
+  return 0;
+}

trunk/external/atnf/PKSIO/PKSreader.h

@@ -2 +2 @@
 //# PKSreader.h: Class to read Parkes multibeam data.
 //#---------------------------------------------------------------------------
-//# Copyright (C) 2000-2007
+//# Copyright (C) 2000-2008
 //# Associated Universities, Inc. Washington DC, USA.
 //#
@@ -26 +26 @@
 //#                        Charlottesville, VA 22903-2475 USA
 //#
-//# $Id: PKSreader.h,v 19.12 2007/11/12 03:37:56 cal103 Exp $
+//# $Id: PKSreader.h,v 19.13 2008-06-26 01:50:24 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# Original: 2000/08/02, Mark Calabretta, ATNF
@@ -40 +40 @@
 #include <casa/BasicSL/String.h>
 
+#include <casa/namespace.h>
+
 // <summary>
 // Class to read Parkes multibeam data.
 // </summary>
-
-#include <casa/namespace.h>
 
 // Open an appropriate PKSreader for a Parkes Multibeam dataset.
@@ -76 +76 @@
         Bool   &haveSpectra);
 
+class MBrecord;
 
 class PKSreader
@@ -132 +133 @@
         Matrix<Double> &positions) = 0;
 
-    // Read the next data record.
+    // Read the next data record (MBrecord is defined below).
+    virtual Int read(MBrecord &mbrec) = 0;
+
+    // Read the next data record (for backwards compatibility, do not use).
     virtual Int read(
         Int             &scanNo,
@@ -174 +178 @@
         Matrix<uChar>   &flagged,
         Complex         &xCalFctr,
-        Vector<Complex> &xPol) = 0;
+        Vector<Complex> &xPol);
 
     // Read the next data record, just the basics.
@@ -196 +200 @@
 };
 
+
+// Essentially just a struct used as a function argument.
+class MBrecord
+{
+  public:
+    Int             scanNo;
+    Int             cycleNo;
+    Double          mjd;
+    Double          interval;
+    String          fieldName;
+    String          srcName;
+    Vector<Double>  srcDir;
+    Vector<Double>  srcPM;
+    Double          srcVel;
+    String          obsType;
+    Int             IFno;
+    Double          refFreq;
+    Double          bandwidth;
+    Double          freqInc;
+    Double          restFreq;
+    Vector<Float>   tcal;
+    String          tcalTime;
+    Float           azimuth;
+    Float           elevation;
+    Float           parAngle;
+    Float           focusAxi;
+    Float           focusTan;
+    Float           focusRot;
+    Float           temperature;
+    Float           pressure;
+    Float           humidity;
+    Float           windSpeed;
+    Float           windAz;
+    Int             refBeam;
+    Int             beamNo;
+    Vector<Double>  direction;
+    Vector<Double>  scanRate;
+    Int             rateAge;
+    Int             rateson;
+    Vector<Float>   tsys;
+    Vector<Float>   sigma;
+    Vector<Float>   calFctr;
+    Matrix<Float>   baseLin;
+    Matrix<Float>   baseSub;
+    Matrix<Float>   spectra;
+    Matrix<uChar>   flagged;
+    Complex         xCalFctr;
+    Vector<Complex> xPol;
+};
+
 #endif

trunk/external/atnf/PKSIO/SDFITSreader.cc

@@ -2 +2 @@
 //# SDFITSreader.cc: ATNF CFITSIO interface class for SDFITS input.
 //#---------------------------------------------------------------------------
-//# Copyright (C) 2000-2007
+//# Copyright (C) 2000-2008
 //# Associated Universities, Inc. Washington DC, USA.
 //#
@@ -26 +26 @@
 //#                        Charlottesville, VA 22903-2475 USA
 //#
-//# $Id: SDFITSreader.cc,v 19.23 2007/11/12 03:37:56 cal103 Exp $
+//# $Id: SDFITSreader.cc,v 19.24 2008-06-26 02:13:11 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# The SDFITSreader class reads single dish FITS files such as those written
@@ -1289 +1289 @@
     mbrec.decRate = scanrate[1] * D2R;
   }
+  mbrec.rateAge = 0;
+  mbrec.rateson = 0;
 
   // IF-dependent parameters.