Changeset 1757 for branches/alma/external/atnf/PKSIO

branches/alma

Property svn:ignore set to
.sconf_temp
.sconsign.dblite
Property svn:mergeinfo set to
/branches/asap-3.x merged eligible

branches/alma/external/atnf/PKSIO/FITSreader.cc

-              r1453
+              r1757
 //# FITSreader.cc: ATNF single-dish FITS reader.
 //#---------------------------------------------------------------------------
 //# Copyright (C) 2000-2006
 //# Mark Calabretta, ATNF
+//# livedata - processing pipeline for single-dish, multibeam spectral data.
+//# Copyright (C) 2000-2009, Australia Telescope National Facility, CSIRO
 //#
+//# This library is free software; you can redistribute it and/or modify it
+//# under the terms of the GNU Library General Public License as published by
+//# the Free Software Foundation; either version 2 of the License, or (at your
+//# option) any later version.
+//# This file is part of livedata.
 //#
+//# This library is distributed in the hope that it will be useful, but WITHOUT
+//# livedata is free software: you can redistribute it and/or modify it under
+//# the terms of the GNU General Public License as published by the Free
+//# Software Foundation, either version 3 of the License, or (at your option)
+//# any later version.
+//#
+//# livedata is distributed in the hope that it will be useful, but WITHOUT
 //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 //# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
 //# License for more details.
+//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+//# more details.
 //#
+//# You should have received a copy of the GNU Library General Public License
+//# along with this library; if not, write to the Free Software Foundation,
+//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
+//# You should have received a copy of the GNU General Public License along
+//# with livedata.  If not, see <http://www.gnu.org/licenses/>.
 //#
 //# Correspondence concerning this software should be addressed as follows:
 //#        Internet email: mcalabre@atnf.csiro.au.
 //#        Postal address: Dr. Mark Calabretta,
 //#                        Australia Telescope National Facility,
 //#                        P.O. Box 76,
 //#                        Epping, NSW, 2121,
+//# Correspondence concerning livedata may be directed to:
+//#        Internet email: mcalabre@atnf.csiro.au
+//#        Postal address: Dr. Mark Calabretta
+//#                        Australia Telescope National Facility, CSIRO
+//#                        PO Box 76
+//#                        Epping NSW 1710
 //#                        AUSTRALIA
 //#
+//# $Id$
+//# http://www.atnf.csiro.au/computing/software/livedata.html
+//# $Id: FITSreader.cc,v 19.4 2009-09-29 07:33:38 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# The FITSreader class is an abstract base class for the Parkes Multibeam
 …
         const int getSpectra,
         const int getXPol,
+        const int getFeedPos)
+        const int getFeedPos,
+        const int getPointing,
+        const int coordSys)
+{
   int maxNChan = 0;
 …
   cGetXPol    = getXPol    && cGetXPol;
   cGetFeedPos = getFeedPos;
+  cCoordSys   = coordSys;
   return maxNChan;

branches/alma/external/atnf/PKSIO/FITSreader.h

-              r1453
+              r1757
 //# FITSreader.h: ATNF single-dish FITS reader.
 //#---------------------------------------------------------------------------
 //# Copyright (C) 2000-2006
 //# Mark Calabretta, ATNF
+//# livedata - processing pipeline for single-dish, multibeam spectral data.
+//# Copyright (C) 2000-2009, Australia Telescope National Facility, CSIRO
 //#
+//# This library is free software; you can redistribute it and/or modify it
+//# under the terms of the GNU Library General Public License as published by
+//# the Free Software Foundation; either version 2 of the License, or (at your
+//# option) any later version.
+//# This file is part of livedata.
 //#
+//# This library is distributed in the hope that it will be useful, but WITHOUT
+//# livedata is free software: you can redistribute it and/or modify it under
+//# the terms of the GNU General Public License as published by the Free
+//# Software Foundation, either version 3 of the License, or (at your option)
+//# any later version.
+//#
+//# livedata is distributed in the hope that it will be useful, but WITHOUT
 //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 //# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
 //# License for more details.
+//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+//# more details.
 //#
+//# You should have received a copy of the GNU Library General Public License
+//# along with this library; if not, write to the Free Software Foundation,
+//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
+//# You should have received a copy of the GNU General Public License along
+//# with livedata.  If not, see <http://www.gnu.org/licenses/>.
 //#
 //# Correspondence concerning this software should be addressed as follows:
 //#        Internet email: mcalabre@atnf.csiro.au.
 //#        Postal address: Dr. Mark Calabretta,
 //#                        Australia Telescope National Facility,
 //#                        P.O. Box 76,
 //#                        Epping, NSW, 2121,
+//# Correspondence concerning livedata may be directed to:
+//#        Internet email: mcalabre@atnf.csiro.au
+//#        Postal address: Dr. Mark Calabretta
+//#                        Australia Telescope National Facility, CSIRO
+//#                        PO Box 76
+//#                        Epping NSW 1710
 //#                        AUSTRALIA
 //#
+//# $Id$
+//# http://www.atnf.csiro.au/computing/software/livedata.html
+//# $Id: FITSreader.h,v 19.11 2009-09-29 07:33:38 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# The FITSreader class is an abstract base class for the Parkes Multibeam
 …
 #define ATNF_FITSREADER_H
+#include <atnf/PKSIO/PKSMBrecord.h>
+#include <atnf/PKSIO/MBrecord.h>
+using namespace std;
 // <summary>
 …
 // </summary>
+//class FITSreader
 class FITSreader
+{
 …
         double antPos[3],
         char   obsType[32],
+        char   bunit[32],
         float  &equinox,
         char   radecsys[32],
 …
     // Set data selection criteria.  Channel numbering is 1-relative, zero or
     // negative channel numbers are taken to be offsets from the last channel.
+    // Coordinate systems are
+    //   0: equatorial (RA,Dec),
+    //   1: horizontal (Az,El),
+    //   2: feed-plane,
+    //   3: zenithal position angle of feed and elevation, (ZPA,El).
     int select(
         const int startChan[],
 …
         const int getSpectra = 1,
         const int getXPol = 0,
+        const int getFeedPos = 0);
+        const int getFeedPos = 0,
+        const int getPointing = 0,
+        const int coordSys = 0);
     // Find the range in time and position of the data selected.
 …
     // Read the next data record.
     virtual int read(
+        PKSMBrecord &record) = 0;
+//        PKSMBrecord &record) = 0;
+        MBrecord &record) = 0;
     // Close the RPFITS file.
 …
   protected:
+    int    *cBeams, *cEndChan, cGetFeedPos, cGetSpectra, cGetXPol, cHaveBase,
+           cHaveSpectra, *cHaveXPol, *cIFs, cNBeam, *cNChan, cNIF, *cNPol,
+           *cRefChan, *cStartChan;
+    int  *cBeams, *cEndChan, cGetFeedPos, cCoordSys, cGetSpectra, cGetXPol,
+           cHaveBase, cHaveSpectra, *cHaveXPol, *cIFs, cNBeam, *cNChan, cNIF,
+           *cNPol, *cRefChan, *cStartChan;
+    // For use in constructing messages.
+    char cMsg[256];
 };

branches/alma/external/atnf/PKSIO/MBFITSreader.cc

-              r1453
+              r1757
 //# MBFITSreader.cc: ATNF single-dish RPFITS reader.
 //#---------------------------------------------------------------------------
 //# Copyright (C) 2000-2006
 //# Mark Calabretta, ATNF
+//# livedata - processing pipeline for single-dish, multibeam spectral data.
+//# Copyright (C) 2000-2009, Australia Telescope National Facility, CSIRO
 //#
+//# This library is free software; you can redistribute it and/or modify it
+//# under the terms of the GNU Library General Public License as published by
+//# the Free Software Foundation; either version 2 of the License, or (at your
+//# option) any later version.
+//# This file is part of livedata.
 //#
+//# This library is distributed in the hope that it will be useful, but WITHOUT
+//# livedata is free software: you can redistribute it and/or modify it under
+//# the terms of the GNU General Public License as published by the Free
+//# Software Foundation, either version 3 of the License, or (at your option)
+//# any later version.
+//#
+//# livedata is distributed in the hope that it will be useful, but WITHOUT
 //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 //# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
 //# License for more details.
+//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+//# more details.
 //#
+//# You should have received a copy of the GNU Library General Public License
+//# along with this library; if not, write to the Free Software Foundation,
+//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
+//# You should have received a copy of the GNU General Public License along
+//# with livedata.  If not, see <http://www.gnu.org/licenses/>.
 //#
 //# Correspondence concerning this software should be addressed as follows:
 //#        Internet email: mcalabre@atnf.csiro.au.
 //#        Postal address: Dr. Mark Calabretta,
 //#                        Australia Telescope National Facility,
 //#                        P.O. Box 76,
 //#                        Epping, NSW, 2121,
+//# Correspondence concerning livedata may be directed to:
+//#        Internet email: mcalabre@atnf.csiro.au
+//#        Postal address: Dr. Mark Calabretta
+//#                        Australia Telescope National Facility, CSIRO
+//#                        PO Box 76
+//#                        Epping NSW 1710
 //#                        AUSTRALIA
 //#
+//# $Id$
+//# http://www.atnf.csiro.au/computing/software/livedata.html
+//# $Id: MBFITSreader.cc,v 19.57 2009-10-30 06:34:36 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# The MBFITSreader class reads single dish RPFITS files (such as Parkes
 …
 //#---------------------------------------------------------------------------
+#include <atnf/pks/pks_maths.h>
 #include <atnf/PKSIO/MBFITSreader.h>
 #include <atnf/PKSIO/PKSMBrecord.h>
 #include <RPFITS.h>
+#include <atnf/PKSIO/MBrecord.h>
+#include <casa/Logging/LogIO.h>
 #include <casa/math.h>
 …
 #include <unistd.h>
+#include <RPFITS.h>
 using namespace std;
 …
 const double PI = 3.141592653589793238462643;
 const double TWOPI = 2.0 * PI;
+const double HALFPI = PI / 2.0;
+const double R2D = 180.0 / PI;
+// Class name
+const string className = "MBFITSreader" ;
 //------------------------------------------------- MBFITSreader::MBFITSreader
 …
   cRefChan   = 0x0;
+  cVis = new float[2*4*8163];
+  cVis = 0x0;
+  cWgt = 0x0;
   cBeamSel   = 0x0;
 …
   cMBopen = 0;
+  jstat = -3;
+  // Tell RPFITSIN not to report errors directly.
+  //iostat_.errlun = -1;
+}
 …
         int  &extraSysCal)
+{
+  const string methodName = "open()" ;
+  LogIO os( LogOrigin( className, methodName, WHERE ) ) ;
   if (cMBopen) {
     close();
 …
   // Open the RPFITS file.
+  rpfitsin_(&jstat, cVis, weight, &baseline, &ut, &u, &v, &w, &flag, &bin,
+            &if_no, &sourceno);
+  if (jstat) {
+    fprintf(stderr, "Failed to open MBFITS file: %s\n", rpname);
+  int jstat = -3;
+  if (rpfitsin(jstat)) {
+    sprintf(cMsg, "Failed to open MBFITS file\n%s", rpname);
+    os << LogIO::SEVERE << cMsg << LogIO::POST ;
     return 1;
+  }
 …
   // Read the first header.
   jstat = -1;
+  rpfitsin_(&jstat, cVis, weight, &baseline, &ut, &u, &v, &w, &flag, &bin,
+            &if_no, &sourceno);
+  if (jstat) {
+    fprintf(stderr, "Failed to read MBFITS header: %s\n", rpname);
+  if (rpfitsin(jstat)) {
+    sprintf(cMsg, "Failed to read MBFITS header in file\n"
+                  "%s", rpname);
+    os << LogIO::SEVERE << cMsg << LogIO::POST ;
     close();
     return 1;
 …
   cMopra = strncmp(names_.instrument, "ATMOPRA", 7) == 0;
+  // Tidbinbilla data has some more.
+  cTid = strncmp(names_.sta, "tid", 3) == 0;
+  if (cTid) {
+    // Telescope position is stored in the source table.
+  // Non-ATNF data may not store the position in (u,v,w).
+  if (strncmp(names_.sta, "tid", 3) == 0) {
+    sprintf(cMsg, "Found Tidbinbilla data");
+    cSUpos = 1;
+  } else if (strncmp(names_.sta, "HOB", 3) == 0) {
+    sprintf(cMsg, "Found Hobart data");
+    cSUpos = 1;
+  } else if (strncmp(names_.sta, "CED", 3) == 0) {
+    sprintf(cMsg, "Found Ceduna data");
+    cSUpos = 1;
+  } else {
+    cSUpos = 0;
+  }
+  if (cSUpos) {
+    strcat(cMsg, ", using telescope position\n         from SU table.");
+    os << LogIO::WARN << cMsg << LogIO::POST ;
     cInterp = 0;
+  }
+  // Mean scan rate (for timestamp repairs).
+  cNRate = 0;
+  cAvRate[0] = 0.0;
+  cAvRate[1] = 0.0;
+  cCode5 = 0;
 …
   if (cNBeam <= 0) {
     fprintf(stderr, "Couldn't determine number of beams.\n");
+    os << LogIO::SEVERE << "Couldn't determine number of beams." << LogIO::POST ;
     close();
     return 1;
 …
   // ...beams present in the data.
   for (int iBeam = 0; iBeam < anten_.nant; iBeam++) {
+    cBeams[anten_.ant_num[iBeam] - 1] = 1;
+    // Guard against dubious beam numbers, e.g. zeroes in
+    // 1999-09-29_1632_024848p14_071b.hpf and the four scans following.
+    // Note that the actual beam number is decoded from the 'baseline' random
+    // parameter for each spectrum and is only used for beam selection.
+    int beamNo = anten_.ant_num[iBeam];
+    if (beamNo != iBeam+1) {
+      char sta[8];
+      strncpy(sta, names_.sta+(8*iBeam), 8);
+      char *cp = sta + 7;
+      while (*cp == ' ') *(cp--) = '\0';
+      sprintf(cMsg,
+        "RPFITSIN returned beam number %2d for AN table\n"
+        "entry %2d with name '%.8s'", beamNo, iBeam+1, sta);
+      char text[8];
+      sprintf(text, "MB%2.2d", iBeam+1);
+      cp = cMsg + strlen(cMsg);
+      if (strncmp(sta, text, 8) == 0) {
+        beamNo = iBeam + 1;
+        sprintf(cp, "; using beam number %2d.", beamNo);
+      } else {
+        sprintf(cp, ".");
+      }
+      os << LogIO::WARN << cMsg << LogIO::POST ;
+    }
+    if (0 < beamNo && beamNo <= cNBeam) {
+      cBeams[beamNo-1] = 1;
+    }
+  }
 …
+  }
   // Is the vis array declared by RPFITS.h large enough?
   if (8*8193 < maxProd) {
     // Need to allocate more memory for RPFITSIN.
     cVis = new float[2*maxProd];
+  }
+  // Allocate memory for RPFITSIN subroutine arguments.
+  if (cVis) delete [] cVis;
+  if (cWgt) delete [] cWgt;
+  cVis = new float[2*maxProd];
+  cWgt = new float[maxProd];
   nChan    = cNChan;
 …
   // Read the first syscal record.
   if (rpget(1, cEOS)) {
     fprintf(stderr, "Error: Failed to read first syscal record.\n");
+    os << LogIO::SEVERE << "Failed to read first syscal record." << LogIO::POST ;
     close();
     return 1;
 …
         double antPos[3],
         char   obsType[32],
+        char   bunit[32],
         float  &equinox,
         char   radecsys[32],
 …
         double &bandwidth)
+{
+  const string methodName = "getHeader()" ;
+  LogIO os( LogOrigin( className, methodName, WHERE ) ) ;
   if (!cMBopen) {
     fprintf(stderr, "An MBFITS file has not been opened.\n");
+    os << LogIO::SEVERE << "An MBFITS file has not been opened." << LogIO::POST ;
     return 1;
+  }
 …
     antPos[1] =  2816759.046;
     antPos[2] = -3454035.950;
   } else if (strncmp(names_.sta, "HOH", 3) == 0) {
     // Parkes HOH receiver.
 …
     antPos[1] =  2816759.046;
     antPos[2] = -3454035.950;
   } else if (strncmp(names_.sta, "CA0", 3) == 0) {
     // An ATCA antenna, use the array centre position.
 …
     antPos[1] =  2792906.182;
     antPos[2] = -3200483.747;
+    // ATCA-104.  Updated position at epoch 2007/06/24 from Chris Phillips.
+    // antPos[0] = -4751640.182; // ± 0.008
+    // antPos[1] =  2791700.322; // ± 0.006
+    // antPos[2] = -3200490.668; // ± 0.007
+    //
   } else if (strncmp(names_.sta, "MOP", 3) == 0) {
     // Mopra.
+    // Mopra.  Updated position at epoch 2007/06/24 from Chris Phillips.
     sprintf(telescope, "%-16.16s", "ATMOPRA");
+    antPos[0] = -4682768.630;
+    antPos[1] =  2802619.060;
+    antPos[2] = -3291759.900;
+    antPos[0] = -4682769.444; // ± 0.009
+    antPos[1] =  2802618.963; // ± 0.006
+    antPos[2] = -3291758.864; // ± 0.008
   } else if (strncmp(names_.sta, "HOB", 3) == 0) {
     // Hobart.
 …
     antPos[1] =  2522347.567;
     antPos[2] = -4311562.569;
   } else if (strncmp(names_.sta, "CED", 3) == 0) {
     // Ceduna.
+    // Ceduna.  Updated position at epoch 2007/06/24 from Chris Phillips.
     sprintf(telescope, "%-16.16s", "CEDUNA");
+    antPos[0] = -3749943.657;
+    antPos[1] =  3909017.709;
+    antPos[2] = -3367518.309;
+    antPos[0] = -3753443.168; // ± 0.017
+    antPos[1] =  3912709.794; // ± 0.017
+    antPos[2] = -3348067.060; // ± 0.016
   } else if (strncmp(names_.sta, "tid", 3) == 0) {
     // DSS.
 …
   obsType[j] = '\0';
+  // Brightness unit.
+  sprintf(bunit, "%-16.16s", names_.bunit);
+  if (strcmp(bunit, "JY") == 0) {
+    bunit[1] = 'y';
+  } else if (strcmp(bunit, "JY/BEAM") == 0) {
+    strcpy(bunit, "Jy/beam");
+  }
   // Coordinate frames.
   equinox = 2000.0f;
 …
   // Time at start of observation.
   sprintf(datobs, "%-10.10s", names_.datobs);
   utc = ut;
+  utc = cUTC;
   // Spectral parameters.
 …
 //--------------------------------------------------------- MBFITSreader::read
 // Read the next data record.
+// Read the next data record (if you're feeling lucky).
 int MBFITSreader::read(
         PKSMBrecord &MBrec)
+        MBrecord &MBrec)
+{
+  const string methodName = "read()" ;
+  LogIO os( LogOrigin( className, methodName, WHERE ) ) ;
   int beamNo = -1;
+  int haveData, status;
+  PKSMBrecord *iMBuff = 0x0;
+  int haveData, pCode = 0, status;
+  double raRate = 0.0, decRate = 0.0, paRate = 0.0;
+  MBrecord *iMBuff = 0x0;
   if (!cMBopen) {
     fprintf(stderr, "An MBFITS file has not been opened.\n");
+    os << LogIO::SEVERE << "An MBFITS file has not been opened." << LogIO::POST ;
     return 1;
+  }
   // Positions recorded in the input records do not coincide with the midpoint
   // of the integration and hence the input must be buffered so that true
   // positions may be interpolated.
+  // Positions recorded in the input records usually do not coincide with the
+  // midpoint of the integration and hence the input must be buffered so that
+  // true positions may be interpolated.
   //
   // On the first call nBeamSel buffers of length nBin, are allocated and
 …
       // Read the next record.
+      pCode = 0;
       if ((status = rpget(0, cEOS)) == -1) {
         // EOF.
 …
 #ifdef PKSIO_DEBUG
         printf("End-of-file detected, flushing last scan.\n");
+        os << LogIO::DEBUGGING << "\nEnd-of-file detected, flushing last cycle.\n" << LogIO::POST ;
 #endif
 …
           cXpolOff = new int[cNIF];
-          int simulIF = 0;
           int maxChan = 0;
           int maxXpol = 0;
+          cSimulIF = 0;
           for (int iIF = 0; iIF < cNIF; iIF++) {
             if (cIFs[iIF]) {
 …
               // Maximum number of selected IFs in any simultaneous set.
               simulIF = max(simulIF, cIFSel[iIF]+1);
+              cSimulIF = max(cSimulIF, cIFSel[iIF]+1);
               // Maximum memory required for any simultaneous set.
 …
           if (cNBin > 1 && cNBeamSel > 1) {
+            fprintf(stderr, "Cannot handle binning mode for multiple "
+                            "beams.\n");
+            os << LogIO::SEVERE << "Cannot handle binning mode for multiple beams.\nSelect a single beam for input." << LogIO::POST ;
             close();
             return 1;
+          }
+          // Allocate buffer data storage.
+          // Allocate buffer data storage; the MBrecord constructor zeroes
+          // class members such as cycleNo that are tested in the first pass
+          // below.
           int nBuff = cNBeamSel * cNBin;
           cBuffer = new PKSMBrecord[nBuff];
+          cBuffer = new MBrecord[nBuff];
           // Allocate memory for spectral arrays.
           for (int ibuff = 0; ibuff < nBuff; ibuff++) {
             cBuffer[ibuff].setNIFs(simulIF);
+            cBuffer[ibuff].setNIFs(cSimulIF);
             cBuffer[ibuff].allocate(0, maxChan, maxXpol);
+            // Signal that this IF in this buffer has been flushed.
+            for (int iIF = 0; iIF < cSimulIF; iIF++) {
+              cBuffer[ibuff].IFno[iIF] = 0;
+            }
+          }
 …
           cScanNo  = 1;
           cCycleNo = 0;
+          cUTC = 0.0;
+          cStaleness = new int[cNBeamSel];
+          for (int iBeamSel = 0; iBeamSel < cNBeamSel; iBeamSel++) {
+            cStaleness[iBeamSel] = 0;
+          }
+          cPrevUTC = -1.0;
+        }
 …
           cScanNo++;
           cCycleNo = 0;
+          cUTC = 0.0;
+        }
+        // Apply beam selection.
+        beamNo = int(baseline / 256.0);
+          cPrevUTC = -1.0;
+        }
+        // Apply beam and IF selection before the change-of-day test to allow
+        // a single selected beam and IF to be handled in binning-mode.
+        beamNo = int(cBaseline / 256.0);
+        if (beamNo == 1) {
+          // Store the position of beam 1 for grid convergence corrections.
+          cRA0  = cU;
+          cDec0 = cV;
+        }
         iBeamSel = cBeamSel[beamNo-1];
         if (iBeamSel < 0) continue;
         // Sanity check (mainly for MOPS).
+        if (if_no > cNIF) continue;
+        // Apply IF selection.
+        iIFSel = cIFSel[if_no - 1];
+        if (cIFno > cNIF) continue;
+        // Apply IF selection; iIFSel == 0 for the first selected IF, == 1
+        // for the second, etc.
+        iIFSel = cIFSel[cIFno - 1];
         if (iIFSel < 0) continue;
-        sprintf(cDateObs, "%-10.10s", names_.datobs);
-        // Change-of-day; note that the ut variable from RPFITS.h is global
-        // and will be preserved between calls to this function.
-        if (ut < cUTC - 85800.0) {
-          ut += 86400.0;
+        }
-        // New integration cycle?
-        if (ut > cUTC) {
-          cCycleNo++;
-          cUTC = ut + 0.0001;
+        }
         if (cNBin > 1) {
           // Binning mode: correct the time.
+          ut += param_.intbase * (bin - (cNBin + 1)/2.0);
+        }
+          cUTC += param_.intbase * (cBin - (cNBin + 1)/2.0);
+        }
+        // Check for change-of-day.
+        double cod = 0.0;
+        if ((cUTC + 86400.0) < (cPrevUTC + 600.0)) {
+          // cUTC should continue to increase past 86400 during a single scan.
+          // However, if the RPFITS file contains multiple scans that straddle
+          // midnight then cUTC can jump backwards from the end of one scan to
+          // the start of the next.
+#ifdef PKSIO_DEBUG
+          char buf[256] ;
+          sprintf(buf, "Change-of-day on cUTC: %.1f -> %.1f\n", cPrevUTC, cUTC);
+          os << LogIO::DEBUGGING << buf << LogIO::POST ;
+#endif
+          // Can't change the recorded value of cUTC directly (without also
+          // changing dateobs) so change-of-day must be recorded separately as
+          // an offset to be applied when comparing integration timestamps.
+          cod = 86400.0;
+        }
+        if ((cUTC+cod) < cPrevUTC - 1.0) {
+          if (cBin == 1 && iIFSel) {
+            // Multiple-IF, binning-mode data is only partially time ordered.
+#ifdef PKSIO_DEBUG
+            fprintf(stderr, "New IF in multiple-IF, binning-mode data.\n");
+#endif
+            cCycleNo -= cNBin;
+            cPrevUTC = -1.0;
+          } else {
+            // All other data should be fully time ordered.
+            sprintf(cMsg,
+              "Cycle %d:%03d-%03d, UTC went backwards from\n"
+              "%.1f to %.1f!  Incrementing day number,\n"
+              "positions may be unreliable.", cScanNo, cCycleNo,
+              cCycleNo+1, cPrevUTC, cUTC);
+            //logMsg(cMsg);
+            os << LogIO::WARN << cMsg << LogIO::POST ;
+            cUTC += 86400.0;
+          }
+        }
+        // New integration cycle?
+        if ((cUTC+cod) > cPrevUTC) {
+          cCycleNo++;
+          cPrevUTC = cUTC + 0.0001;
+        }
+        sprintf(cDateObs, "%-10.10s", names_.datobs);
+        cDateObs[10] = '\0';
         // Compute buffer number.
         iMBuff = cBuffer + iBeamSel;
         if (cNBin > 1) iMBuff += cNBeamSel*(bin-1);
+        if (cNBin > 1) iMBuff += cNBeamSel*(cBin-1);
         if (cCycleNo < iMBuff->cycleNo) {
 …
         // Begin flush cycle?
         if (cEOS || (iMBuff->nIF && ut > iMBuff->utc + 0.0001)) {
+        if (cEOS || (iMBuff->nIF && (cUTC+cod) > (iMBuff->utc+0.0001))) {
           cFlushing = 1;
           cFlushBin = 0;
 …
 #ifdef PKSIO_DEBUG
+        printf(" In:%4d%4d%3d%3d\n", cScanNo, cCycleNo, beamNo, if_no);
+        if (cEOS) printf("Start of new scan, flushing previous scan.\n");
+        char rel = '=';
+        double dt = utcDiff(cUTC, cW);
+        if (dt < 0.0) {
+          rel = '<';
+        } else if (dt > 0.0) {
+          rel = '>';
+        }
+        sprintf(buf, "\n In:%4d%4d%3d%3d  %.3f %c %.3f (%+.3fs) - "
+          "%sflushing\n", cScanNo, cCycleNo, beamNo, cIFno, cUTC, rel, cW, dt,
+          cFlushing ? "" : "not ");
+        os << LogIO::DEBUGGING << buf << LogIO::POST ;
+        if (cEOS) {
+          sprintf(buf, "Start of new scan, flushing previous scan.\n");
+          os << LogIO::DEBUGGING << buf << LogIO::POST ;
+        }
 #endif
+      }
 …
           iMBuff = cBuffer + iBeamSel + cNBeamSel*cFlushBin;
           // iMBuff->nIF is set to zero (below) to signal that all IFs in
           // an integration have been flushed.
+          // iMBuff->nIF is decremented (below) and if zero signals that all
+          // IFs in an integration have been flushed.
           if (iMBuff->nIF) {
             if (cycleNo == 0 || iMBuff->cycleNo < cycleNo) {
 …
           break;
+        }
+        // Start with the first IF in the next bin.
+        cFlushIF = 0;
+      }
 …
         // Find the IF to flush.
         for (; cFlushIF < iMBuff->nIF; cFlushIF++) {
+        for (; cFlushIF < cSimulIF; cFlushIF++) {
           if (iMBuff->IFno[cFlushIF]) break;
+        }
 …
         // The last record read must have been the first of a new cycle.
         beamNo = int(baseline / 256.0);
+        beamNo = int(cBaseline / 256.0);
         iBeamSel = cBeamSel[beamNo-1];
         // Compute buffer number.
         iMBuff = cBuffer + iBeamSel;
         if (cNBin > 1) iMBuff += cNBeamSel*(bin-1);
+        if (cNBin > 1) iMBuff += cNBeamSel*(cBin-1);
+      }
+    }
+    if (cFlushing && cFlushBin == 0 && cFlushIF == 0 && cInterp) {
+      // Interpolate the beam position at the start of the flush cycle.
+    if (cInterp && cFlushing == 1) {
+      // 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.  The interpolation method used here is
+      // based on the scan rate.
+      //
+      // "This" RA, Dec, and UTC refers to the position currently stored in
+      // the buffer marked for output (iMBuff).  This position is interpolated
+      // to the midpoint of that integration using either
+      //   a) the rate currently sitting in iMBuff, which was computed from
+      //      the previous integration, otherwise
+      //   b) from the position recorded in the "next" integration which is
+      //      currently sitting in the RPFITS commons,
+      // so that the position timestamps straddle the midpoint of the
+      // integration and is thereby interpolated rather than extrapolated.
+      //
+      // At the end of a scan, or if the next position has not been updated
+      // or its timestamp does not advance sufficiently, the most recent
+      // determination of the scan rate will be used for extrapolation which
+      // is quantified by the "rate age" measured in seconds beyond the
+      // interval defined by the position timestamps.
+      // At this point, iMBuff contains cU, cV, cW, parAngle and focusRot
+      // stored from the previous call to rpget() for this beam (i.e. "this"),
+      // and also raRate, decRate and paRate computed from that integration
+      // and the previous one.
+      double thisRA  = iMBuff->ra;
+      double thisDec = iMBuff->dec;
+      double thisUTC = cPosUTC[iBeamSel];
+      double thisPA  = iMBuff->parAngle + iMBuff->focusRot;
 #ifdef PKSIO_DEBUG
+      printf("Doing position interpolation for beam %d.\n", iMBuff->beamNo);
+      sprintf(buf, "This (%d) ra, dec, UTC: %9.4f %9.4f %10.3f %9.4f\n",
+        iMBuff->cycleNo, thisRA*R2D, thisDec*R2D, thisUTC, thisPA*R2D);
+      os << LogIO::DEBUGGING << buf << LogIO::POST ;
 #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
+        // 'ut', this usually being a second or two later.
+        //
+        // Note that the time recorded as the 'w' visibility coordinate
+        // cycles through 86400 back to 0 at midnight, whereas that in 'ut'
+        // continues to increase past 86400.
+        double thisRA  = u;
+        double thisDec = v;
+        double thisUTC = w;
+        if (thisUTC < prevUTC) {
+          // Must have cycled through midnight.
+          thisUTC += 86400.0;
+        }
+        // Guard against RA cycling through 24h in either direction.
+        if (fabs(thisRA - prevRA) > PI) {
+          if (thisRA < prevRA) {
+            thisRA += TWOPI;
+      if (cEOF || cEOS) {
+        // Use rates from the last cycle.
+        raRate  = iMBuff->raRate;
+        decRate = iMBuff->decRate;
+        paRate  = iMBuff->paRate;
+      } else {
+        if (cW == thisUTC) {
+          // The control system at Mopra typically does not update the
+          // positions between successive integration cycles at the end of a
+          // scan (nor are they flagged).  In this case we use the previously
+          // computed rates, even if from the previous scan since these are
+          // likely to be a better guess than anything else.
+          raRate  = iMBuff->raRate;
+          decRate = iMBuff->decRate;
+          paRate  = iMBuff->paRate;
+          if (cU == thisRA && cV == thisDec) {
+            // Position and timestamp unchanged.
+            pCode = 1;
+          } else if (fabs(cU-thisRA) < 0.0001 && fabs(cV-thisDec) < 0.0001) {
+            // Allow small rounding errors (seen infrequently).
+            pCode = 1;
           } else {
+            thisRA -= TWOPI;
+            // (cU,cV) are probably rubbish (not yet seen in practice).
+            pCode = 2;
+            cU = thisRA;
+            cV = thisDec;
+          }
+        }
+        // The control system at Mopra typically does not update the
+        // positions between successive integration cycles at the end of a
+        // scan (nor are they flagged).  In this case we use the previously
+        // computed rates, even if from the previous scan since these are
+        // likely to be a better guess than anything else.
+        double dUTC = thisUTC - prevUTC;
+        // Scan rate for this beam.
+        if (dUTC > 0.0) {
+          iMBuff->raRate  = (thisRA  - prevRA)  / dUTC;
+          iMBuff->decRate = (thisDec - prevDec) / dUTC;
+          if (cInterp == 2) {
+            // Use the same interpolation scheme as the original pksmbfits
+            // client.  This incorrectly assumed that (thisUTC - prevUTC) is
+            // equal to the integration time and interpolated by computing a
+            // weighted sum of the positions before and after the required
+            // time.
+            double utc = iMBuff->utc;
+            if (utc - prevUTC > 100.0) {
+              // Must have cycled through midnight.
+              utc -= 86400.0;
+#ifdef PKSIO_DEBUG
+          sprintf(buf, "Next (%d) ra, dec, UTC: %9.4f %9.4f %10.3f "
+            "(0.000s)\n", cCycleNo, cU*R2D, cV*R2D, cW);
+          os << LogIO::DEBUGGING << buf << LogIO::POST ;
+#endif
+        } else {
+          double nextRA  = cU;
+          double nextDec = cV;
+          // Check and, if necessary, repair the position timestamp,
+          // remembering that pCode refers to the NEXT cycle.
+          pCode = fixw(cDateObs, cCycleNo, beamNo, cAvRate, thisRA, thisDec,
+                       thisUTC, nextRA, nextDec, cW);
+          if (pCode > 0) pCode += 3;
+          double nextUTC = cW;
+#ifdef PKSIO_DEBUG
+          sprintf(buf, "Next (%d) ra, dec, UTC: %9.4f %9.4f %10.3f "
+            "(%+.3fs)\n", cCycleNo, nextRA*R2D, nextDec*R2D, nextUTC,
+            utcDiff(nextUTC, thisUTC));
+          os << LogIO::DEBUGGING << buf << LogIO::POST ;
+#endif
+          // Compute the scan rate for this beam.
+          double dUTC = utcDiff(nextUTC, thisUTC);
+          if ((0.0 < dUTC) && (dUTC < 600.0)) {
+            scanRate(cRA0, cDec0, thisRA, thisDec, nextRA, nextDec, dUTC,
+                     raRate, decRate);
+            // Update the mean scan rate.
+            cAvRate[0] = (cAvRate[0]*cNRate +  raRate) / (cNRate + 1);
+            cAvRate[1] = (cAvRate[1]*cNRate + decRate) / (cNRate + 1);
+            cNRate++;
+            // Rate of change of position angle.
+            if (sc_.sc_ant <= anten_.nant) {
+              paRate = 0.0;
+            } else {
+              int iOff = sc_.sc_q * (sc_.sc_ant - 1) - 1;
+              double nextPA = sc_.sc_cal[iOff + 4] + sc_.sc_cal[iOff + 7];
+              double paDiff = nextPA - thisPA;
+              if (paDiff > PI) {
+                paDiff -= TWOPI;
+              } else if (paDiff < -PI) {
+                paDiff += TWOPI;
+              }
+              paRate = paDiff / dUTC;
+            }
+            double tw1 = 1.0 - (utc - prevUTC) / iMBuff->exposure;
+            double tw2 = 1.0 - (thisUTC - utc) / iMBuff->exposure;
+            double gamma = (tw2 / (tw1 + tw2)) * dUTC / (utc - prevUTC);
+            iMBuff->raRate  *= gamma;
+            iMBuff->decRate *= gamma;
+          }
+          cStaleness[iBeamSel] = 0;
+        } else {
+          // Issue warnings.
+          int nch = 0;
+          fprintf(stderr, "WARNING, scan %d,%n cycle %d: Position ",
+            iMBuff->scanNo, &nch, iMBuff->cycleNo);
+          if (dUTC < 0.0) {
+            fprintf(stderr, "timestamp went backwards!\n");
+            if (cInterp == 2) {
+              // Use the same interpolation scheme as the original pksmbfits
+              // 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
+              // time.
+              double utc = iMBuff->utc;
+              double tw1 = 1.0 - utcDiff(utc, thisUTC) / iMBuff->exposure;
+              double tw2 = 1.0 - utcDiff(nextUTC, utc) / iMBuff->exposure;
+              double gamma = (tw2 / (tw1 + tw2)) * dUTC / (utc - thisUTC);
+              // Guard against RA cycling through 24h in either direction.
+              if (fabs(nextRA - thisRA) > PI) {
+                if (nextRA < thisRA) {
+                  nextRA += TWOPI;
+                } else {
+                  nextRA -= TWOPI;
+                }
+              }
+              raRate  = gamma * (nextRA  - thisRA)  / dUTC;
+              decRate = gamma * (nextDec - thisDec) / dUTC;
+            }
           } else {
+            if (thisRA != prevRA || thisDec != prevDec) {
+              fprintf(stderr, "changed but timestamp unchanged!\n");
+            if (cCycleNo == 2 && fabs(utcDiff(cUTC,cW)) < 600.0) {
+              // thisUTC (i.e. cW for the first cycle) is rubbish, and
+              // probably the position as well (extremely rare in practice,
+              // e.g. 97-12-19_1029_235708-18_586e.hpf which actually has the
+              // t/1000 scaling bug in the first cycle).
+              iMBuff->pCode = 3;
+              thisRA  = cU;
+              thisDec = cV;
+              thisUTC = cW;
+              raRate  = 0.0;
+              decRate = 0.0;
+              paRate  = 0.0;
             } else {
+              fprintf(stderr, "and timestamp unchanged!\n");
+              // cW is rubbish and probably (cU,cV), and possibly the
+              // parallactic angle and everything else as well (rarely seen
+              // in practice, e.g. 97-12-09_0743_235707-58_327c.hpf and
+              // 97-09-01_0034_123717-42_242b.hpf, the latter with bad
+              // parallactic angle).
+              pCode = 3;
+              cU = thisRA;
+              cV = thisDec;
+              cW = thisUTC;
+              raRate  = iMBuff->raRate;
+              decRate = iMBuff->decRate;
+              paRate  = iMBuff->paRate;
+            }
+          }
+          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,");
+        }
+      }
+      // Choose the closest rate determination.
+      if (cCycleNo == 1) {
+        // Scan containing a single integration.
+        iMBuff->raRate  = 0.0;
+        iMBuff->decRate = 0.0;
+        iMBuff->paRate  = 0.0;
+      } else {
+        double dUTC = iMBuff->utc - cPosUTC[iBeamSel];
+        if (dUTC >= 0.0) {
+          // In HIPASS/ZOA, the position timestamp, which should always occur
+          // on the whole second, normally precedes an integration midpoint
+          // falling on the half-second.  Consequently, positive ages are
+          // always half-integral.
+          dUTC = utcDiff(iMBuff->utc, cW);
+          if (dUTC > 0.0) {
+            iMBuff->rateAge = dUTC;
+          } else {
+            iMBuff->rateAge = 0.0f;
+          }
+          iMBuff->raRate  =  raRate;
+          iMBuff->decRate = decRate;
+          iMBuff->paRate  =  paRate;
+        } else {
+          // In HIPASS/ZOA, negative ages occur when the integration midpoint,
+          // occurring on the whole second, precedes the position timestamp.
+          // Thus negative ages are always an integral number of seconds.
+          // They have only been seen to occur sporadically in the period
+          // 1999/05/31 to 1999/11/01, e.g. 1999-07-26_1821_005410-74_007c.hpf
+          //
+          // In recent (2008/10/07) Mopra data, small negative ages (~10ms,
+          // occasionally up to ~300ms) seem to be the norm, with both the
+          // position timestamp and integration midpoint falling close to but
+          // not on the integral second.
+          if (cCycleNo == 2) {
+            // We have to start with something!
+            iMBuff->rateAge = dUTC;
+          } else {
+            // Although we did not record the relevant position timestamp
+            // explicitly, it can easily be deduced.
+            double w = iMBuff->utc - utcDiff(cUTC, iMBuff->utc) -
+                       iMBuff->rateAge;
+            dUTC = utcDiff(iMBuff->utc, w);
+            if (dUTC > 0.0) {
+              iMBuff->rateAge = 0.0f;
+            } else {
+              iMBuff->rateAge = dUTC;
+            }
+          }
+        }
+      }
+          iMBuff->raRate  =  raRate;
+          iMBuff->decRate = decRate;
+          iMBuff->paRate  =  paRate;
+        }
+      }
+#ifdef PKSIO_DEBUG
+      double avRate = sqrt(cAvRate[0]*cAvRate[0] + cAvRate[1]*cAvRate[1]);
+      sprintf(buf, "RA, Dec, Av & PA rates: %8.4f %8.4f %8.4f %8.4f "
+        "pCode %d\n", raRate*R2D, decRate*R2D, avRate*R2D, paRate*R2D, pCode);
+      os << LogIO::DEBUGGING << buf << LogIO::POST ;
+#endif
       // Compute the position of this beam for all bins.
 …
         cBuffer[jbuff].raRate  = iMBuff->raRate;
         cBuffer[jbuff].decRate = iMBuff->decRate;
+        double dutc = cBuffer[jbuff].utc - prevUTC;
+        if (dutc > 100.0) {
+        cBuffer[jbuff].paRate  = iMBuff->paRate;
+        double dUTC = utcDiff(cBuffer[jbuff].utc, thisUTC);
+        if (dUTC > 100.0) {
           // Must have cycled through midnight.
+          dutc -= 86400.0;
+        }
+        cBuffer[jbuff].ra  = prevRA  + cBuffer[jbuff].raRate  * dutc;
+        cBuffer[jbuff].dec = prevDec + cBuffer[jbuff].decRate * dutc;
+        if (cBuffer[jbuff].ra < 0.0) {
+          cBuffer[jbuff].ra += TWOPI;
+        } else if (cBuffer[jbuff].ra > TWOPI) {
+          cBuffer[jbuff].ra -= TWOPI;
+        }
+      }
+          dUTC -= 86400.0;
+        }
+        applyRate(cRA0, cDec0, thisRA, thisDec,
+          cBuffer[jbuff].raRate, cBuffer[jbuff].decRate, dUTC,
+          cBuffer[jbuff].ra, cBuffer[jbuff].dec);
+#ifdef PKSIO_DEBUG
+        sprintf(buf, "Intp (%d) ra, dec, UTC: %9.4f %9.4f %10.3f (pCode, "
+          "age: %d %.1fs)\n", iMBuff->cycleNo, cBuffer[jbuff].ra*R2D,
+          cBuffer[jbuff].dec*R2D, cBuffer[jbuff].utc, iMBuff->pCode,
+          iMBuff->rateAge);
+        os << LogIO::DEBUGGING << buf << LogIO::POST ;
+#endif
+      }
+      cFlushing = 2;
+    }
 …
 #ifdef PKSIO_DEBUG
+      printf("Out:%4d%4d%3d%3d\n", MBrec.scanNo, MBrec.cycleNo, MBrec.beamNo,
+        MBrec.IFno[0]);
+      sprintf(buf, "Out:%4d%4d%3d%3d\n", MBrec.scanNo, MBrec.cycleNo,
+        MBrec.beamNo, MBrec.IFno[0]);
+      os << LogIO::DEBUGGING << buf << LogIO::POST ;
 #endif
 …
       iMBuff->IFno[cFlushIF] = 0;
+      if (cFlushIF == iMBuff->nIF - 1) {
+        // Signal that all IFs in this buffer location have been flushed.
+        iMBuff->nIF = 0;
+      iMBuff->nIF--;
+      if (iMBuff->nIF == 0) {
+        // All IFs in this buffer location have been flushed.  Stop cEOS
+        // being set when the next integration is read.
+        iMBuff->cycleNo = 0;
       } else {
         // Carry on flushing the other IFs.
 …
       if (cFlushBin == cNBin - 1) {
         if (cEOS || cEOF) {
-          // Stop cEOS being set when the next integration is read.
-          iMBuff->cycleNo = 0;
           // Carry on flushing other buffers.
           cFlushIF = 0;
 …
         cFlushing = 0;
         beamNo = int(baseline / 256.0);
+        beamNo = int(cBaseline / 256.0);
         iBeamSel = cBeamSel[beamNo-1];
         // Compute buffer number.
         iMBuff = cBuffer + iBeamSel;
         if (cNBin > 1) iMBuff += cNBeamSel*(bin-1);
+        if (cNBin > 1) iMBuff += cNBeamSel*(cBin-1);
+      }
+    }
 …
     if (!cFlushing) {
       // Buffer this MBrec.
       if (cCycleNo == 1 && iMBuff->IFno[0]) {
+      if ((cScanNo > iMBuff->scanNo) && iMBuff->IFno[0]) {
         // Sanity check on the number of IFs in the new scan.
         if (if_.n_if != cNIF) {
+          fprintf(stderr, "WARNING, scan %d has %d IFs instead of %d, "
+            "continuing.\n", cScanNo, if_.n_if, cNIF);
+        }
+      }
+      iMBuff->scanNo  = cScanNo;
+      iMBuff->cycleNo = cCycleNo;
+      // Times.
+      strncpy(iMBuff->datobs, cDateObs, 10);
+      iMBuff->utc = ut;
+      iMBuff->exposure = param_.intbase;
+      // Source identification.
+      sprintf(iMBuff->srcName, "%-16.16s",
+              names_.su_name + (sourceno-1)*16);
+      iMBuff->srcRA  = doubles_.su_ra[sourceno-1];
+      iMBuff->srcDec = doubles_.su_dec[sourceno-1];
+      // Rest frequency of the line of interest.
+      iMBuff->restFreq = doubles_.rfreq;
+      if (strncmp(names_.instrument, "ATPKSMB", 7) == 0) {
+        // Fix the HI rest frequency recorded for Parkes multibeam data.
+        double reffreq  = doubles_.freq;
+        double restfreq = doubles_.rfreq;
+        if ((restfreq == 0.0 || fabs(restfreq - reffreq) == 0.0) &&
+             fabs(reffreq - 1420.40575e6) < 100.0) {
+          iMBuff->restFreq = 1420.40575e6;
+        }
+      }
+      // Observation type.
+      int j;
+      for (j = 0; j < 15; j++) {
+        iMBuff->obsType[j] = names_.card[11+j];
+        if (iMBuff->obsType[j] == '\'') break;
+      }
+      iMBuff->obsType[j] = '\0';
+      // Beam-dependent parameters.
+      iMBuff->beamNo = beamNo;
+      // Beam position at the specified time.
+      if (cTid) {
+        // Tidbinbilla data.
+        iMBuff->ra  = doubles_.su_ra[sourceno-1];
+        iMBuff->dec = doubles_.su_dec[sourceno-1];
+      } else {
+        iMBuff->ra  = u;
+        iMBuff->dec = v;
+      }
+      cPosUTC[iBeamSel] = w;
+          sprintf(cMsg, "Scan %d has %d IFs instead of %d, "
+            "continuing.", cScanNo, if_.n_if, cNIF);
+          os << LogIO::WARN << cMsg << LogIO::POST ;
+        }
+      }
+      // Sanity check on incomplete integrations within a scan.
+      if (iMBuff->nIF && (iMBuff->cycleNo != cCycleNo)) {
+        // Force the incomplete integration to be flushed before proceeding.
+        cFlushing = 1;
+        continue;
+      }
+#ifdef PKSIO_DEBUG
+      sprintf(buf, "Buf:%4d%4d%3d%3d\n", cScanNo, cCycleNo, beamNo, cIFno);
+      os << LogIO::DEBUGGING << buf << LogIO::POST ;
+#endif
+      // Store IF-independent parameters only for the first IF of a new cycle,
+      // particularly because this is the only one for which the scan rates
+      // are computed above.
+      int firstIF = (iMBuff->nIF == 0);
+      if (firstIF) {
+        iMBuff->scanNo  = cScanNo;
+        iMBuff->cycleNo = cCycleNo;
+        // Times.
+        strcpy(iMBuff->datobs, cDateObs);
+        iMBuff->utc = cUTC;
+        iMBuff->exposure = param_.intbase;
+        // Source identification.
+        sprintf(iMBuff->srcName, "%-16.16s",
+                names_.su_name + (cSrcNo-1)*16);
+        iMBuff->srcName[16] = '\0';
+        iMBuff->srcRA  = doubles_.su_ra[cSrcNo-1];
+        iMBuff->srcDec = doubles_.su_dec[cSrcNo-1];
+        // Rest frequency of the line of interest.
+        iMBuff->restFreq = doubles_.rfreq;
+        if (strncmp(names_.instrument, "ATPKSMB", 7) == 0) {
+          // Fix the HI rest frequency recorded for Parkes multibeam data.
+          double reffreq  = doubles_.freq;
+          double restfreq = doubles_.rfreq;
+          if ((restfreq == 0.0 || fabs(restfreq - reffreq) == 0.0) &&
+               fabs(reffreq - 1420.405752e6) < 100.0) {
+            iMBuff->restFreq = 1420.405752e6;
+          }
+        }
+        // Observation type.
+        int j;
+        for (j = 0; j < 15; j++) {
+          iMBuff->obsType[j] = names_.card[11+j];
+          if (iMBuff->obsType[j] == '\'') break;
+        }
+        iMBuff->obsType[j] = '\0';
+        // Beam-dependent parameters.
+        iMBuff->beamNo = beamNo;
+        // Beam position at the specified time.
+        if (cSUpos) {
+          // Non-ATNF data that does not store the position in (u,v,w).
+          iMBuff->ra  = doubles_.su_ra[cSrcNo-1];
+          iMBuff->dec = doubles_.su_dec[cSrcNo-1];
+        } else {
+          iMBuff->ra  = cU;
+          iMBuff->dec = cV;
+        }
+        cPosUTC[iBeamSel] = cW;
+        iMBuff->pCode = pCode;
+        // Store rates for next time.
+        iMBuff->raRate  =  raRate;
+        iMBuff->decRate = decRate;
+        iMBuff->paRate  =  paRate;
+      }
       // IF-dependent parameters.
       int iIF = if_no - 1;
+      int iIF = cIFno - 1;
       int startChan = cStartChan[iIF];
       int endChan   = cEndChan[iIF];
 …
       iIFSel = cIFSel[iIF];
+      iMBuff->nIF++;
+      iMBuff->IFno[iIFSel]  = if_no;
+      if (iMBuff->IFno[iIFSel] == 0) {
+        iMBuff->nIF++;
+        iMBuff->IFno[iIFSel] = cIFno;
+      } else {
+        // Integration cycle written to the output file twice (the only known
+        // example is 1999-05-22_1914_000-031805_03v.hpf).
+        sprintf(cMsg, "Integration cycle %d:%d, beam %2d, \n"
+                      "IF %d was duplicated.", cScanNo, cCycleNo-1,
+                      beamNo, cIFno);
+        os << LogIO::WARN << cMsg << LogIO::POST ;
+      }
       iMBuff->nChan[iIFSel] = nChan;
       iMBuff->nPol[iIFSel]  = cNPol[iIF];
 …
       // The baseline flag may be set independently.
       if (rpflag == 0) rpflag = flag;
+      if (rpflag == 0) rpflag = cFlag;
       // Copy and scale data.
 …
-      // Parallactic angle.
-      iMBuff->parAngle = sc_.sc_cal[scq*iBeam + 11];
       // Calibration factor applied to the data by the correlator.
       if (scq > 14) {
 …
+      }
+      if (sc_.sc_ant <= anten_.nant) {
+        // No extra syscal information present.
+        iMBuff->extraSysCal = 0;
+        iMBuff->azimuth   = 0.0f;
+        iMBuff->elevation = 0.0f;
+        iMBuff->parAngle  = 0.0f;
+        iMBuff->focusAxi  = 0.0f;
+        iMBuff->focusTan  = 0.0f;
+        iMBuff->focusRot  = 0.0f;
+        iMBuff->temp      = 0.0f;
+        iMBuff->pressure  = 0.0f;
+        iMBuff->humidity  = 0.0f;
+        iMBuff->windSpeed = 0.0f;
+        iMBuff->windAz    = 0.0f;
+        strcpy(iMBuff->tcalTime, "                ");
+        iMBuff->refBeam = 0;
+      } else {
+        // Additional information for Parkes Multibeam data.
+        int iOff = scq*(sc_.sc_ant - 1) - 1;
+        iMBuff->extraSysCal = 1;
+        iMBuff->azimuth   = sc_.sc_cal[iOff + 2];
+        iMBuff->elevation = sc_.sc_cal[iOff + 3];
+        iMBuff->parAngle  = sc_.sc_cal[iOff + 4];
+        iMBuff->focusAxi  = sc_.sc_cal[iOff + 5] * 1e-3;
+        iMBuff->focusTan  = sc_.sc_cal[iOff + 6] * 1e-3;
+        iMBuff->focusRot  = sc_.sc_cal[iOff + 7];
+        iMBuff->temp      = sc_.sc_cal[iOff + 8];
+        iMBuff->pressure  = sc_.sc_cal[iOff + 9];
+        iMBuff->humidity  = sc_.sc_cal[iOff + 10];
+        iMBuff->windSpeed = sc_.sc_cal[iOff + 11];
+        iMBuff->windAz    = sc_.sc_cal[iOff + 12];
+        char *tcalTime = iMBuff->tcalTime;
+        sprintf(tcalTime, "%-16.16s", (char *)(&sc_.sc_cal[iOff+13]));
+      if (firstIF) {
+        if (sc_.sc_ant <= anten_.nant) {
+          // No extra syscal information present.
+          iMBuff->extraSysCal = 0;
+          iMBuff->azimuth   = 0.0f;
+          iMBuff->elevation = 0.0f;
+          iMBuff->parAngle  = 0.0f;
+          iMBuff->focusAxi  = 0.0f;
+          iMBuff->focusTan  = 0.0f;
+          iMBuff->focusRot  = 0.0f;
+          iMBuff->temp      = 0.0f;
+          iMBuff->pressure  = 0.0f;
+          iMBuff->humidity  = 0.0f;
+          iMBuff->windSpeed = 0.0f;
+          iMBuff->windAz    = 0.0f;
+          strcpy(iMBuff->tcalTime, "                ");
+          iMBuff->refBeam = 0;
+        } else {
+          // Additional information for Parkes Multibeam data.
+          int iOff = scq*(sc_.sc_ant - 1) - 1;
+          iMBuff->extraSysCal = 1;
+          iMBuff->azimuth   = sc_.sc_cal[iOff + 2];
+          iMBuff->elevation = sc_.sc_cal[iOff + 3];
+          iMBuff->parAngle  = sc_.sc_cal[iOff + 4];
+          iMBuff->focusAxi  = sc_.sc_cal[iOff + 5] * 1e-3;
+          iMBuff->focusTan  = sc_.sc_cal[iOff + 6] * 1e-3;
+          iMBuff->focusRot  = sc_.sc_cal[iOff + 7];
+          iMBuff->temp      = sc_.sc_cal[iOff + 8];
+          iMBuff->pressure  = sc_.sc_cal[iOff + 9];
+          iMBuff->humidity  = sc_.sc_cal[iOff + 10];
+          iMBuff->windSpeed = sc_.sc_cal[iOff + 11];
+          iMBuff->windAz    = sc_.sc_cal[iOff + 12];
+          char *tcalTime = iMBuff->tcalTime;
+          sprintf(tcalTime, "%-16.16s", (char *)(&sc_.sc_cal[iOff+13]));
+          tcalTime[16] = '\0';
 #ifndef AIPS_LITTLE_ENDIAN
         // Do byte swapping on the ASCII date string.
         for (int j = 0; j < 16; j += 4) {
           char ctmp;
           ctmp = tcalTime[j];
           tcalTime[j]   = tcalTime[j+3];
           tcalTime[j+3] = ctmp;
           ctmp = tcalTime[j+1];
           tcalTime[j+1] = tcalTime[j+2];
           tcalTime[j+2] = ctmp;
+        }
+          // Do byte swapping on the ASCII date string.
+          for (int j = 0; j < 16; j += 4) {
+            char ctmp;
+            ctmp = tcalTime[j];
+            tcalTime[j]   = tcalTime[j+3];
+            tcalTime[j+3] = ctmp;
+            ctmp = tcalTime[j+1];
+            tcalTime[j+1] = tcalTime[j+2];
+            tcalTime[j+2] = ctmp;
+          }
 #endif
+        // Reference beam number.
+        float refbeam = sc_.sc_cal[iOff + 17];
+        if (refbeam > 0.0f || refbeam < 100.0f) {
+          iMBuff->refBeam = int(refbeam);
+        } else {
+          iMBuff->refBeam = 0;
+          // Reference beam number.
+          float refbeam = sc_.sc_cal[iOff + 17];
+          if (refbeam > 0.0f || refbeam < 100.0f) {
+            iMBuff->refBeam = int(refbeam);
+          } else {
+            iMBuff->refBeam = 0;
+          }
+        }
+      }
 …
 int MBFITSreader::rpget(int syscalonly, int &EOS)
+{
+  const string methodName = "rpget()" ;
+  LogIO os( LogOrigin( className, methodName, WHERE ) ) ;
   EOS = 0;
 …
   int numErr = 0;
   jstat = 0;
+  int jstat = 0;
   while (numErr < 10) {
     int lastjstat = jstat;
+    rpfitsin_(&jstat, cVis, weight, &baseline, &ut, &u, &v, &w, &flag, &bin,
+              &if_no, &sourceno);
+    switch(jstat) {
+    switch(rpfitsin(jstat)) {
     case -1:
       // Read failed; retry.
       numErr++;
       fprintf(stderr, "RPFITS read failed - retrying.\n");
+      os << LogIO::WARN << "RPFITS read failed - retrying." << LogIO::POST ;
       jstat = 0;
       break;
 …
       // Successful read.
       if (lastjstat == 0) {
         if (baseline == -1) {
+        if (cBaseline == -1) {
           // Syscal data.
           if (syscalonly) {
 …
     default:
       // Shouldn't reach here.
+      fprintf(stderr, "Unrecognized RPFITSIN return code: %d (retrying)\n",
+              jstat);
+      sprintf(cMsg, "Unrecognized RPFITSIN return code: %d "
+                    "(retrying).", jstat);
+      os << LogIO::WARN << cMsg << LogIO::POST ;
       jstat = 0;
       break;
 …
+  }
   fprintf(stderr, "RPFITS read failed too many times.\n");
+  os << LogIO::SEVERE << "RPFITS read failed too many times." << LogIO::POST ;
   return 2;
+}
+//----------------------------------------------------- MBFITSreader::rpfitsin
+// Wrapper around RPFITSIN that reports errors.  Returned RPFITSIN subroutine
+// arguments are captured as MBFITSreader member variables.
+int MBFITSreader::rpfitsin(int &jstat)
+{
+  rpfitsin_(&jstat, cVis, cWgt, &cBaseline, &cUTC, &cU, &cV, &cW, &cFlag,
+            &cBin, &cIFno, &cSrcNo);
+  // Handle messages from RPFITSIN.
+/**
+  if (names_.errmsg[0] != ' ') {
+    int i;
+    for (i = 80; i > 0; i--) {
+      if (names_.errmsg[i-1] != ' ') break;
+    }
+    sprintf(cMsg, "WARNING: Cycle %d:%03d, RPFITSIN reported -\n"
+                  "         %.*s", cScanNo, cCycleNo, i, names_.errmsg);
+    logMsg(cMsg);
+  }
+**/
+  return jstat;
+}
+//------------------------------------------------------- MBFITSreader::fixPos
+// Check and, if necessary, repair a position timestamp.
+//
+// Problems with the position timestamp manifest themselves via the scan rate:
+//
+//   1) Zero scan rate pairs, 1997/02/28 to 1998/01/07
+//
+//      These occur because the position timestamp for the first integration
+//      of the pair is erroneous; the value recorded is t/1000, where t is the
+//      true value.
+//        Earliest known: 97-02-28_1725_132653-42_258a.hpf
+//          Latest known: 98-01-02_1923_095644-50_165c.hpf
+//        (time range chosen to encompass observing runs).
+//
+//   2) Slow-fast scan rate pairs (0.013 - 0.020 deg/s),
+//        1997/03/28 to 1998/01/07.
+//
+//      The UTC position timestamp is 1.0s later than it should be (never
+//      earlier), almost certainly arising from an error in the telescope
+//      control system.
+//        Earliest known: 97-03-28_0150_010420-74_008d.hpf
+//          Latest known: 98-01-04_1502_065150-02_177c.hpf
+//        (time range chosen to encompass observing runs).
+//
+//   3) Slow-fast scan rate pairs (0.015 - 0.018 deg/s),
+//        1999/05/20 to 2001/07/12 (HIPASS and ZOA),
+//        2001/09/02 to 2001/12/04 (HIPASS and ZOA),
+//        2002/03/28 to 2002/05/13 (ZOA only),
+//        2003/04/26 to 2003/06/09 (ZOA only).
+//        Earliest known: 1999-05-20_1818_175720-50_297e.hpf
+//          Latest known: 2001-12-04_1814_065531p14_173e.hpf (HIPASS)
+//                        2003-06-09_1924_352-085940_-6c.hpf (ZOA)
+//
+//      Caused by the Linux signalling NaN problem.  IEEE "signalling" NaNs
+//      are silently transformed to "quiet" NaNs during assignment by setting
+//      bit 22.  This affected RPFITS because of its use of VAX-format
+//      floating-point numbers which, with their permuted bytes, may sometimes
+//      appear as signalling NaNs.
+//
+//      The problem arose when the linux correlator came online and was
+//      fixed with a workaround to the RPFITS library (repeated episodes
+//      are probably due to use of an older version of the library).  It
+//      should not have affected the data significantly because of the
+//      low relative error, which ranges from 0.0000038 to 0.0000076, but
+//      it is important for the computation of scan rates which requires
+//      taking the difference of two large UTC timestamps, one or other
+//      of which will have 0.5s added to it.
+//
+// The return value identifies which, if any, of these problems was repaired.
+int MBFITSreader::fixw(
+  const char *datobs,
+  int    cycleNo,
+  int    beamNo,
+  double avRate[2],
+  double thisRA,
+  double thisDec,
+  double thisUTC,
+  double nextRA,
+  double nextDec,
+  float &nextUTC)
+{
+  if (strcmp(datobs, "2003-06-09") > 0) {
+    return 0;
+  } else if (strcmp(datobs, "1998-01-07") <= 0) {
+    if (nextUTC < thisUTC && (nextUTC + 86400.0) > (thisUTC + 600.0)) {
+      // Possible scaling problem.
+      double diff = nextUTC*1000.0 - thisUTC;
+      if (0.0 < diff && diff < 600.0) {
+        nextUTC *= 1000.0;
+        return 1;
+      } else {
+        // Irreparable.
+        return -1;
+      }
+    }
+    if (cycleNo > 2) {
+      if (beamNo == 1) {
+        // This test is only reliable for beam 1.
+        double dUTC = nextUTC - thisUTC;
+        if (dUTC < 0.0) dUTC += 86400.0;
+        // Guard against RA cycling through 24h in either direction.
+        if (fabs(nextRA - thisRA) > PI) {
+          if (nextRA < thisRA) {
+            nextRA += TWOPI;
+          } else {
+            nextRA -= TWOPI;
+          }
+        }
+        double  dRA = (nextRA  - thisRA) * cos(nextDec);
+        double dDec =  nextDec - thisDec;
+        double  arc = sqrt(dRA*dRA + dDec*dDec);
+        double averate = sqrt(avRate[0]*avRate[0] + avRate[1]*avRate[1]);
+        double diff1 = fabs(averate - arc/(dUTC-1.0));
+        double diff2 = fabs(averate - arc/dUTC);
+        if ((diff1 < diff2) && (diff1 < 0.05*averate)) {
+          nextUTC -= 1.0;
+          cCode5 = cycleNo;
+          return 2;
+        } else {
+          cCode5 = 0;
+        }
+      } else {
+        if (cycleNo == cCode5) {
+          nextUTC -= 1.0;
+          return 2;
+        }
+      }
+    }
+  } else if ((strcmp(datobs, "1999-05-20") >= 0 &&
+              strcmp(datobs, "2001-07-12") <= 0) ||
+             (strcmp(datobs, "2001-09-02") >= 0 &&
+              strcmp(datobs, "2001-12-04") <= 0) ||
+             (strcmp(datobs, "2002-03-28") >= 0 &&
+              strcmp(datobs, "2002-05-13") <= 0) ||
+             (strcmp(datobs, "2003-04-26") >= 0 &&
+              strcmp(datobs, "2003-06-09") <= 0)) {
+    // Signalling NaN problem, e.g. 1999-07-26_1839_011106-74_009c.hpf.
+    // Position timestamps should always be an integral number of seconds.
+    double resid = nextUTC - int(nextUTC);
+    if (resid == 0.5) {
+      nextUTC -= 0.5;
+      return 3;
+    }
+  }
+  return 0;
+}
 …
+{
   if (cMBopen) {
     jstat = 1;
     rpfitsin_(&jstat, cVis, weight, &baseline, &ut, &u, &v, &w, &flag, &bin,
               &if_no, &sourceno);
+    int jstat = 1;
+    rpfitsin_(&jstat, cVis, cWgt, &cBaseline, &cUTC, &cU, &cV, &cW, &cFlag,
+              &cBin, &cIFno, &cSrcNo);
     if (cBeams)     delete [] cBeams;
 …
     if (cRefChan)   delete [] cRefChan;
+    if (cVis)       delete [] cVis;
+    if (cVis) delete [] cVis;
+    if (cWgt) delete [] cWgt;
     if (cBeamSel)   delete [] cBeamSel;
 …
+  }
+}
+//-------------------------------------------------------------------- utcDiff
+// Subtract two UTCs (s) allowing for any plausible number of cycles through
+// 86400s, returning a result in the range [-43200, +43200]s.
+double MBFITSreader::utcDiff(double utc1, double utc2)
+{
+  double diff = utc1 - utc2;
+  if (diff > 43200.0) {
+    diff -= 86400.0;
+    while (diff > 43200.0) diff -= 86400.0;
+  } else if (diff < -43200.0) {
+    diff += 86400.0;
+    while (diff < -43200.0) diff += 86400.0;
+  }
+  return diff;
+}
+//------------------------------------------------------- scanRate & applyRate
+// Compute and apply the scan rate corrected for grid convergence.  (ra0,dec0)
+// are the coordinates of the central beam, assumed to be the tracking centre.
+// The rate computed in RA will be a rate of change of angular distance in the
+// direction of increasing RA at the position of the central beam.  Similarly
+// for declination.  Angles in radian, time in s.
+void MBFITSreader::scanRate(
+  double ra0,
+  double dec0,
+  double ra1,
+  double dec1,
+  double ra2,
+  double dec2,
+  double dt,
+  double &raRate,
+  double &decRate)
+{
+  // Transform to a system where the central beam lies on the equator at 12h.
+  eulerx(ra1, dec1, ra0+HALFPI, -dec0, -HALFPI, ra1, dec1);
+  eulerx(ra2, dec2, ra0+HALFPI, -dec0, -HALFPI, ra2, dec2);
+  raRate  = (ra2  - ra1)  / dt;
+  decRate = (dec2 - dec1) / dt;
+}
+void MBFITSreader::applyRate(
+  double ra0,
+  double dec0,
+  double ra1,
+  double dec1,
+  double raRate,
+  double decRate,
+  double dt,
+  double &ra2,
+  double &dec2)
+{
+  // Transform to a system where the central beam lies on the equator at 12h.
+  eulerx(ra1, dec1, ra0+HALFPI, -dec0, -HALFPI, ra1, dec1);
+  ra2  = ra1  + (raRate  * dt);
+  dec2 = dec1 + (decRate * dt);
+  // Transform back.
+  eulerx(ra2, dec2, -HALFPI, dec0, ra0+HALFPI, ra2, dec2);
+}
+//--------------------------------------------------------------------- eulerx
+void MBFITSreader::eulerx(
+  double lng0,
+  double lat0,
+  double phi0,
+  double theta,
+  double phi,
+  double &lng1,
+  double &lat1)
+// Applies the Euler angle based transformation of spherical coordinates.
+//
+//     phi0  Longitude of the ascending node in the old system, radians.  The
+//           ascending node is the point of intersection of the equators of
+//           the two systems such that the equator of the new system crosses
+//           from south to north as viewed in the old system.
+//
+//    theta  Angle between the poles of the two systems, radians.  THETA is
+//           positive for a positive rotation about the ascending node.
+//
+//      phi  Longitude of the ascending node in the new system, radians.
+{
+  // Compute intermediaries.
+  double lng0p  = lng0 - phi0;
+  double slng0p = sin(lng0p);
+  double clng0p = cos(lng0p);
+  double slat0  = sin(lat0);
+  double clat0  = cos(lat0);
+  double ctheta = cos(theta);
+  double stheta = sin(theta);
+  double x = clat0*clng0p;
+  double y = clat0*slng0p*ctheta + slat0*stheta;
+  // Longitude in the new system.
+  if (x != 0.0 || y != 0.0) {
+    lng1 = phi + atan2(y, x);
+  } else {
+    // Longitude at the poles in the new system is consistent with that
+    // specified in the old system.
+    lng1 = phi + lng0p;
+  }
+  lng1 = fmod(lng1, TWOPI);
+  if (lng1 < 0.0) lng1 += TWOPI;
+  lat1 = asin(slat0*ctheta - clat0*stheta*slng0p);
+}

branches/alma/external/atnf/PKSIO/MBFITSreader.h

-              r1453
+              r1757
 //# MBFITSreader.h: ATNF single-dish RPFITS reader.
 //#---------------------------------------------------------------------------
 //# Copyright (C) 2000-2006
 //# Mark Calabretta, ATNF
+//# livedata - processing pipeline for single-dish, multibeam spectral data.
+//# Copyright (C) 2000-2009, Australia Telescope National Facility, CSIRO
 //#
+//# This library is free software; you can redistribute it and/or modify it
+//# under the terms of the GNU Library General Public License as published by
+//# the Free Software Foundation; either version 2 of the License, or (at your
+//# option) any later version.
+//# This file is part of livedata.
 //#
+//# This library is distributed in the hope that it will be useful, but WITHOUT
+//# livedata is free software: you can redistribute it and/or modify it under
+//# the terms of the GNU General Public License as published by the Free
+//# Software Foundation, either version 3 of the License, or (at your option)
+//# any later version.
+//#
+//# livedata is distributed in the hope that it will be useful, but WITHOUT
 //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 //# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
 //# License for more details.
+//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+//# more details.
 //#
+//# You should have received a copy of the GNU Library General Public License
+//# along with this library; if not, write to the Free Software Foundation,
+//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
+//# You should have received a copy of the GNU General Public License along
+//# with livedata.  If not, see <http://www.gnu.org/licenses/>.
 //#
 //# Correspondence concerning this software should be addressed as follows:
 //#        Internet email: mcalabre@atnf.csiro.au.
 //#        Postal address: Dr. Mark Calabretta,
 //#                        Australia Telescope National Facility,
 //#                        P.O. Box 76,
 //#                        Epping, NSW, 2121,
+//# Correspondence concerning livedata may be directed to:
+//#        Internet email: mcalabre@atnf.csiro.au
+//#        Postal address: Dr. Mark Calabretta
+//#                        Australia Telescope National Facility, CSIRO
+//#                        PO Box 76
+//#                        Epping NSW 1710
 //#                        AUSTRALIA
 //#
+//# $Id$
+//# http://www.atnf.csiro.au/computing/software/livedata.html
+//# $Id: MBFITSreader.h,v 19.23 2009-09-29 07:33:38 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# The MBFITSreader class reads single dish RPFITS files (such as Parkes
 …
 #include <atnf/PKSIO/FITSreader.h>
+#include <atnf/PKSIO/PKSMBrecord.h>
+#include <atnf/PKSIO/MBrecord.h>
+using namespace std;
 // <summary>
 …
         double antPos[3],
         char   obsType[32],
+        char   bunit[32],
         float  &equinox,
         char   radecsys[32],
 …
     // Read the next data record.
     virtual int read(PKSMBrecord &record);
+    virtual int read(MBrecord &record);
     // Close the RPFITS file.
 …
   private:
+    char   cDateObs[10];
+    // RPFITSIN subroutine arguments.
+    int   cBaseline, cFlag, cBin, cIFno, cSrcNo;
+    float cUTC, cU, cV, cW, *cVis, *cWgt;
+    char   cDateObs[12];
     int    *cBeamSel, *cChanOff, cFirst, *cIFSel, cInterp, cIntTime, cMBopen,
+           cMopra, cNBeamSel, cNBin, cRetry, *cStaleness, cTid, *cXpolOff;
+    float  *cVis;
+           cMopra, cNBeamSel, cNBin, cRetry, cSimulIF, cSUpos, *cXpolOff;
     // The data has to be bufferred to allow positions to be interpolated.
     int    cEOF, cEOS, cFlushBin, cFlushIF, cFlushing;
     double *cPosUTC;
     PKSMBrecord *cBuffer;
+    MBrecord *cBuffer;
+    // Scan and cycle number bookkeeping.
     int    cCycleNo, cScanNo;
     double cUTC;
+    double cPrevUTC;
     // Read the next data record from the RPFITS file.
     int rpget(int syscalonly, int &EOS);
+    // These are no longer define in the RPFITS.h file so moved here
+    int jstat;
+    float *weight;
+    int baseline;
+    int flag;
+    int bin;
+    int if_no;
+    int sourceno;
+    float *vis;
+    float u;
+    float v;
+    float w;
+    float ut;
+    int rpfitsin(int &jstat);
+    // Check and, if necessary, repair a position timestamp.
+    int    cCode5, cNRate;
+    double cAvRate[2];
+    int fixw(const char *datobs, int cycleNo, int beamNo, double avRate[2],
+             double thisRA, double thisDec, double thisUTC,
+             double nextRA, double nextDec, float &nextUTC);
+    // Subtract two UTCs (s).
+    double utcDiff(double utc1, double utc2);
+    // Compute and apply the scan rate corrected for grid convergence.
+    double cRA0, cDec0;
+    void  scanRate(double ra0, double dec0,
+                   double ra1, double dec1,
+                   double ra2, double dec2, double dt,
+                   double &raRate, double &decRate);
+    void applyRate(double ra0, double dec0,
+                   double ra1, double dec1,
+                   double raRate, double decRate, double dt,
+                   double &ra2, double &dec2);
+    void eulerx(double lng0, double lat0, double phi0, double theta,
+                double phi, double &lng1, double &lat1);
 };

branches/alma/external/atnf/PKSIO/MBrecord.cc

-              r1752
+              r1757
   refBeam = other.refBeam;
+  polNo = other.polNo ;
+  srcVelocity = other.srcVelocity ;
   return *this;
+}
 …
   refBeam = other.refBeam;
+  polNo = other.polNo ;
+  srcVelocity = other.srcVelocity ;
   return 0;
+}

branches/alma/external/atnf/PKSIO/MBrecord.h

r1752	r1757
166	166	short refBeam; // Reference beam, in beam-switching (MX)
167	167	// mode (added 1999/03/17).
	168	int polNo ; // polarization ID
	169	float srcVelocity ; // source velocity w.r.t. reference frame
168	170
169	171	private:

branches/alma/external/atnf/PKSIO/PKSFITSreader.cc

-              r1453
+              r1757
 //# PKSFITSreader.cc: Class to read Parkes multibeam data from a FITS file.
 //#---------------------------------------------------------------------------
 //# Copyright (C) 2000-2006
 //# Associated Universities, Inc. Washington DC, USA.
+//# livedata - processing pipeline for single-dish, multibeam spectral data.
+//# Copyright (C) 2000-2009, Australia Telescope National Facility, CSIRO
 //#
+//# This library is free software; you can redistribute it and/or modify it
+//# under the terms of the GNU Library General Public License as published by
+//# the Free Software Foundation; either version 2 of the License, or (at your
+//# option) any later version.
+//# This file is part of livedata.
 //#
 //# This library is distributed in the hope that it will be useful, but
 //# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 //# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
 //# License for more details.
+//# livedata is free software: you can redistribute it and/or modify it under
+//# the terms of the GNU General Public License as published by the Free
+//# Software Foundation, either version 3 of the License, or (at your option)
+//# any later version.
 //#
+//# You should have received a copy of the GNU Library General Public License
+//# along with this library; if not, write to the Free Software Foundation,
+//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
+//# livedata is distributed in the hope that it will be useful, but WITHOUT
+//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+//# more details.
 //#
+//# Correspondence concerning AIPS++ should be addressed as follows:
+//#        Internet email: aips2-request@nrao.edu.
+//#        Postal address: AIPS++ Project Office
+//#                        National Radio Astronomy Observatory
+//#                        520 Edgemont Road
+//#                        Charlottesville, VA 22903-2475 USA
+//# You should have received a copy of the GNU General Public License along
+//# with livedata.  If not, see <http://www.gnu.org/licenses/>.
 //#
+//# $Id$
+//# Correspondence concerning livedata may be directed to:
+//#        Internet email: mcalabre@atnf.csiro.au
+//#        Postal address: Dr. Mark Calabretta
+//#                        Australia Telescope National Facility, CSIRO
+//#                        PO Box 76
+//#                        Epping NSW 1710
+//#                        AUSTRALIA
+//#
+//# http://www.atnf.csiro.au/computing/software/livedata.html
+//# $Id: PKSFITSreader.cc,v 19.23 2009-09-29 07:33:38 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# Original: 2000/08/02, Mark Calabretta, ATNF
 …
 #include <atnf/PKSIO/SDFITSreader.h>
 #include <atnf/PKSIO/PKSFITSreader.h>
+#include <atnf/PKSIO/PKSMBrecord.h>
+#include <atnf/PKSIO/PKSrecord.h>
+#include <casa/stdio.h>
 #include <casa/Arrays/Array.h>
 #include <casa/BasicMath/Math.h>
 #include <casa/Quanta/MVTime.h>
+#include <casa/stdio.h>
+#include <casa/Logging/LogIO.h>
 //----------------------------------------------- PKSFITSreader::PKSFITSreader
 …
 Int PKSFITSreader::open(
         const String fitsName,
+        const String antenna,
         Vector<Bool> &beams,
         Vector<Bool> &IFs,
 …
   int    extraSysCal, haveBase_, *haveXPol_, haveSpectra_, nBeam, *nChan_,
          nIF, *nPol_, status;
+  if ((status = cReader->open((char *)fitsName.chars(), nBeam, cBeams, nIF,
+                              cIFs, nChan_, nPol_, haveXPol_, haveBase_,
+                              haveSpectra_, extraSysCal))) {
+  status = cReader->open((char *)fitsName.chars(), nBeam, cBeams, nIF, cIFs,
+                         nChan_, nPol_, haveXPol_, haveBase_, haveSpectra_,
+                         extraSysCal);
+  //logMsg(cReader->getMsg());
+  //cReader->clearMsg();
+  if (status) {
     return status;
+  }
 …
         Vector<Double> &antPosition,
         String &obsType,
+        String &bunit,
         Float  &equinox,
         String &dopplerFrame,
         Double &mjd,
         Double &refFreq,
         Double &bandwidth,
+        String &fluxunit)
+{
   char   datobs[32], dopplerFrame_[32], observer_[32], obsType_[32],
          project_[32], radecsys[32], telescope[32];
+        Double &bandwidth)
+{
+  char   bunit_[32], datobs[32], dopplerFrame_[32], observer_[32],
+         obsType_[32], project_[32], radecsys[32], telescope[32];
+  int    status;
   float  equinox_;
   double antPos[3], utc;
+  if (cReader->getHeader(observer_, project_, telescope, antPos, obsType_,
+                         equinox_, radecsys, dopplerFrame_, datobs, utc,
+                         refFreq, bandwidth)) {
+  status = cReader->getHeader(observer_, project_, telescope, antPos,
+                              obsType_, bunit_, equinox_, radecsys,
+                              dopplerFrame_, datobs, utc, refFreq, bandwidth);
+  //logMsg(cReader->getMsg());
+  //cReader->clearMsg();
+  if (status) {
     return 1;
+  }
-  fluxunit = "";
   observer = trim(observer_);
   project  = trim(project_);
 …
   antPosition(2) = antPos[2];
   obsType = trim(obsType_);
+  bunit   = trim(bunit_);
   equinox = equinox_;
   dopplerFrame = trim(dopplerFrame_);
 …
   double *startfreq, *endfreq;
+  Int status;
+  if (!(status = cReader->getFreqInfo(nIF, startfreq, endfreq))) {
+  Int status = cReader->getFreqInfo(nIF, startfreq, endfreq);
+  //logMsg(cReader->getMsg());
+  //cReader->clearMsg();
+  if (!status) {
     startFreq.takeStorage(IPosition(1,nIF), startfreq, TAKE_OVER);
     endFreq.takeStorage(IPosition(1,nIF), endfreq, TAKE_OVER);
 …
         const Bool getSpectra,
         const Bool getXPol,
+        const Bool getFeedPos)
+        const Bool getFeedPos,
+        const Bool getPointing,
+        const Int  coordSys)
+{
   // Apply beam selection.
 …
   cGetXPol    = getXPol;
   cGetFeedPos = getFeedPos;
+  cGetPointing = getPointing;
+  cCoordSys   = coordSys;
   uInt maxNChan = cReader->select(start, end, ref, cGetSpectra, cGetXPol,
+                                  cGetFeedPos);
+                                  cGetFeedPos, cGetPointing, cCoordSys);
+  //logMsg(cReader->getMsg());
+  //cReader->clearMsg();
   delete [] end;
 …
   double* posns;
+  Int status;
+  if (!(status = cReader->findRange(nRow, nSel, dateSpan, utcSpan, posns))) {
+  Int status = cReader->findRange(nRow, nSel, dateSpan, utcSpan, posns);
+  //logMsg(cReader->getMsg());
+  //cReader->clearMsg();
+  if (!status) {
     timeSpan.resize(2);
 …
 // 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,
+        Vector<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;
+  if ((status = cReader->read(cMBrec))) {
+Int PKSFITSreader::read(PKSrecord &pksrec)
+{
+  Int status = cReader->read(cMBrec);
+  //logMsg(cReader->getMsg());
+  //cReader->clearMsg();
+  if (status) {
     if (status != -1) {
       status = 1;
 …
   uInt nPol  = cMBrec.nPol[0];
+  scanNo  = cMBrec.scanNo;
+  cycleNo = cMBrec.cycleNo;
+  pksrec.scanNo  = cMBrec.scanNo;
+  pksrec.cycleNo = cMBrec.cycleNo;
+  pksrec.polNo = cMBrec.polNo ;
   // 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];
+  if ( strstr( cMBrec.datobs, "T" ) == NULL ) {
+    sscanf(cMBrec.datobs, "%4d-%2d-%2d", &year, &month, &day);
+    pksrec.mjd = MVTime(year, month, Double(day)).day() + cMBrec.utc/86400.0;
+  }
+  else {
+    Double dd, hour, min, sec ;
+    sscanf( cMBrec.datobs, "%4d-%2d-%2lfT%lf:%lf:%lf", &year, &month, &dd, &hour, &min, &sec ) ;
+    dd = dd + ( hour * 3600.0 + min * 60.0 + sec ) / 86400.0 ;
+    pksrec.mjd = MVTime(year, month, dd).day() ;
+  }
+  pksrec.interval  = cMBrec.exposure;
+  pksrec.fieldName = trim(cMBrec.srcName);
+  pksrec.srcName   = pksrec.fieldName;
+  int namelen = pksrec.srcName.length() ;
+  if ( namelen > 4 ) {
+    String srcsub = pksrec.srcName.substr( namelen-4, 4 ) ;
+    if ( srcsub.find( "_psc" ) != string::npos ) {
+      pksrec.fieldName = pksrec.srcName.substr( 0, namelen-4 ) ;
+      pksrec.srcName = pksrec.fieldName + "_ps_calon" ;
+    }
+    else if ( srcsub.find( "_pso" ) != string::npos ) {
+      pksrec.fieldName = pksrec.srcName.substr( 0, namelen-4 ) ;
+      pksrec.srcName = pksrec.fieldName + "_ps" ;
+    }
+    else if ( srcsub.find( "_prc" ) != string::npos ) {
+      pksrec.fieldName = pksrec.srcName.substr( 0, namelen-4 ) ;
+      pksrec.srcName = pksrec.fieldName + "_psr_calon" ;
+    }
+    else if ( srcsub.find( "_pro" ) != string::npos ) {
+      pksrec.fieldName = pksrec.srcName.substr( 0, namelen-4 ) ;
+      pksrec.srcName = pksrec.fieldName + "_psr" ;
+    }
+    else if ( srcsub.find( "_fsc" ) != string::npos ) {
+      pksrec.fieldName = pksrec.srcName.substr( 0, namelen-4 ) ;
+      pksrec.srcName = pksrec.fieldName + "_fs_calon" ;
+    }
+    else if ( srcsub.find( "_fso" ) != string::npos ) {
+      pksrec.fieldName = pksrec.srcName.substr( 0, namelen-4 ) ;
+      pksrec.srcName = pksrec.fieldName + "_fs" ;
+    }
+    else if ( srcsub.find( "_frc" ) != string::npos ) {
+      pksrec.fieldName = pksrec.srcName.substr( 0, namelen-4 ) ;
+      pksrec.srcName = pksrec.fieldName + "_fsr_calon" ;
+    }
+    else if ( srcsub.find( "_fro" ) != string::npos ) {
+      pksrec.fieldName = pksrec.srcName.substr( 0, namelen-4 ) ;
+      pksrec.srcName = pksrec.fieldName + "_fsr" ;
+    }
+    else if ( srcsub.find( "_nsc" ) != string::npos || srcsub.find( "_nrc" ) != string::npos ) {
+      pksrec.fieldName = pksrec.srcName.substr( 0, namelen-4 ) ;
+      pksrec.srcName = pksrec.fieldName + "_nod_calon" ;
+    }
+    else if ( srcsub.find( "_nso" ) != string::npos || srcsub.find( "_nro" ) != string::npos ) {
+      pksrec.fieldName = pksrec.srcName.substr( 0, namelen-4 ) ;
+      pksrec.srcName = pksrec.fieldName + "_nod" ;
+    }
+  }
+  pksrec.srcDir.resize(2);
+  pksrec.srcDir(0) = cMBrec.srcRA;
+  pksrec.srcDir(1) = cMBrec.srcDec;
+  pksrec.srcPM.resize(2);
+  pksrec.srcPM(0)  = 0.0;
+  pksrec.srcPM(1)  = 0.0;
+  pksrec.srcVel    = cMBrec.srcVelocity;
+  pksrec.obsType   = trim(cMBrec.obsType);
+  pksrec.IFno = cMBrec.IFno[0];
   Double chanWidth = fabs(cMBrec.fqDelt[0]);
+  refFreq   = cMBrec.fqRefVal[0];
+  bandwidth = chanWidth * nChan;
+  freqInc   = cMBrec.fqDelt[0];
+  //restFreq  = cMBrec.restFreq;
+  restFreq.resize(1);
+  restFreq(0)  = cMBrec.restFreq;
+  tcal.resize(nPol);
+  pksrec.refFreq   = cMBrec.fqRefVal[0];
+  pksrec.bandwidth = chanWidth * nChan;
+  pksrec.freqInc   = cMBrec.fqDelt[0];
+  pksrec.restFreq.resize(1) ;
+  pksrec.restFreq(0)  = cMBrec.restFreq;
+  pksrec.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);
+    pksrec.tcal(ipol) = cMBrec.tcal[0][ipol];
+  }
+  pksrec.tcalTime  = trim(cMBrec.tcalTime);
+  pksrec.azimuth   = cMBrec.azimuth;
+  pksrec.elevation = cMBrec.elevation;
+  pksrec.parAngle  = cMBrec.parAngle;
+  pksrec.focusAxi  = cMBrec.focusAxi;
+  pksrec.focusTan  = cMBrec.focusTan;
+  pksrec.focusRot  = cMBrec.focusRot;
+  pksrec.temperature = cMBrec.temp;
+  pksrec.pressure    = cMBrec.pressure;
+  pksrec.humidity    = cMBrec.humidity;
+  pksrec.windSpeed   = cMBrec.windSpeed;
+  pksrec.windAz      = cMBrec.windAz;
+  pksrec.refBeam = cMBrec.refBeam;
+  pksrec.beamNo  = cMBrec.beamNo;
+  pksrec.direction.resize(2);
+  pksrec.direction(0) = cMBrec.ra;
+  pksrec.direction(1) = cMBrec.dec;
+  pksrec.pCode        = cMBrec.pCode;
+  pksrec.rateAge      = cMBrec.rateAge;
+  pksrec.scanRate.resize(2);
+  pksrec.scanRate(0)  = cMBrec.raRate;
+  pksrec.scanRate(1)  = cMBrec.decRate;
+  pksrec.paRate       = cMBrec.paRate;
+  pksrec.tsys.resize(nPol);
+  pksrec.sigma.resize(nPol);
+  pksrec.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];
+    pksrec.tsys(ipol)  = cMBrec.tsys[0][ipol];
+    pksrec.sigma(ipol) = (pksrec.tsys(ipol) / 0.81) /
+                            sqrt(pksrec.interval * chanWidth);
+    pksrec.calFctr(ipol) = cMBrec.calfctr[0][ipol];
+  }
   if (cMBrec.haveBase) {
     baseLin.resize(2,nPol);
     baseSub.resize(9,nPol);
+    pksrec.baseLin.resize(2,nPol);
+    pksrec.baseSub.resize(24,nPol);
     for (uInt ipol = 0; ipol < nPol; ipol++) {
       baseLin(0,ipol) = cMBrec.baseLin[0][ipol][0];
       baseLin(1,ipol) = cMBrec.baseLin[0][ipol][1];
       for (uInt j = 0; j < 9; j++) {
         baseSub(j,ipol) = cMBrec.baseSub[0][ipol][j];
+      pksrec.baseLin(0,ipol) = cMBrec.baseLin[0][ipol][0];
+      pksrec.baseLin(1,ipol) = cMBrec.baseLin[0][ipol][1];
+      for (uInt j = 0; j < 24; j++) {
+        pksrec.baseSub(j,ipol) = cMBrec.baseSub[0][ipol][j];
+      }
+    }
   } else {
     baseLin.resize(0,0);
     baseSub.resize(0,0);
+    pksrec.baseLin.resize(0,0);
+    pksrec.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);
+    pksrec.spectra.resize(nChan,nPol);
+    pksrec.spectra.takeStorage(IPosition(2,nChan,nPol), cMBrec.spectra[0],
+      SHARE);
+    pksrec.flagged.resize(nChan,nPol);
+    pksrec.flagged.takeStorage(IPosition(2,nChan,nPol), cMBrec.flagged[0],
+      SHARE);
   } else {
     spectra.resize(0,0);
     flagged.resize(0,0);
+    pksrec.spectra.resize(0,0);
+    pksrec.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);
+    pksrec.xCalFctr = Complex(cMBrec.xcalfctr[0][0],
+                             cMBrec.xcalfctr[0][1]);
+    pksrec.xPol.resize(nChan);
+    pksrec.xPol.takeStorage(IPosition(1,nChan), (Complex *)cMBrec.xpol[0],
+      SHARE);
+  }
 …
+}
-//-------------------------------------------------------- PKSFITSreader::read
-// Read the next data record, just the basics.
-Int PKSFITSreader::read(
-        Int           &IFno,
-        Vector<Float> &tsys,
-        Vector<Float> &calFctr,
-        Matrix<Float> &baseLin,
-        Matrix<Float> &baseSub,
-        Matrix<Float> &spectra,
-        Matrix<uChar> &flagged)
+{
-  Int status;
-  if ((status = cReader->read(cMBrec))) {
-    if (status != -1) {
-      status = 1;
+    }
-    return status;
+  }
-  IFno = cMBrec.IFno[0];
-  uInt nChan = cMBrec.nChan[0];
-  uInt nPol  = cMBrec.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) {
-    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];
-      for (uInt j = 0; j < 9; j++) {
-        baseSub(j,ipol) = cMBrec.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);
-  } else {
-    spectra.resize(0,0);
-    flagged.resize(0,0);
+  }
-  return 0;
+}
 //------------------------------------------------------- PKSFITSreader::close
 …
+{
   cReader->close();
+  //logMsg(cReader->getMsg());
+  //cReader->clearMsg();
+}

branches/alma/external/atnf/PKSIO/PKSFITSreader.h

-              r1453
+              r1757
 //# PKSFITSreader.h: Class to read Parkes Multibeam data from a FITS file.
 //#---------------------------------------------------------------------------
 //# Copyright (C) 2000-2006
 //# Associated Universities, Inc. Washington DC, USA.
+//# livedata - processing pipeline for single-dish, multibeam spectral data.
+//# Copyright (C) 2000-2009, Australia Telescope National Facility, CSIRO
 //#
+//# This library is free software; you can redistribute it and/or modify it
+//# under the terms of the GNU Library General Public License as published by
+//# the Free Software Foundation; either version 2 of the License, or (at your
+//# option) any later version.
+//# This file is part of livedata.
 //#
+//# This library is distributed in the hope that it will be useful, but WITHOUT
+//# livedata is free software: you can redistribute it and/or modify it under
+//# the terms of the GNU General Public License as published by the Free
+//# Software Foundation, either version 3 of the License, or (at your option)
+//# any later version.
+//#
+//# livedata is distributed in the hope that it will be useful, but WITHOUT
 //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 //# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
 //# License for more details.
+//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+//# more details.
 //#
+//# You should have received a copy of the GNU Library General Public License
+//# along with this library; if not, write to the Free Software Foundation,
+//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
+//# You should have received a copy of the GNU General Public License along
+//# with livedata.  If not, see <http://www.gnu.org/licenses/>.
 //#
+//# Correspondence concerning AIPS++ should be addressed as follows:
+//#        Internet email: aips2-request@nrao.edu.
+//#        Postal address: AIPS++ Project Office
+//#                        National Radio Astronomy Observatory
+//#                        520 Edgemont Road
+//#                        Charlottesville, VA 22903-2475 USA
+//# Correspondence concerning livedata may be directed to:
+//#        Internet email: mcalabre@atnf.csiro.au
+//#        Postal address: Dr. Mark Calabretta
+//#                        Australia Telescope National Facility, CSIRO
+//#                        PO Box 76
+//#                        Epping NSW 1710
+//#                        AUSTRALIA
 //#
+//# $Id$
+//# http://www.atnf.csiro.au/computing/software/livedata.html
+//# $Id: PKSFITSreader.h,v 19.18 2009-09-29 07:33:38 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# This class is basically a wrapper class for reading data from either an
 …
 #include <atnf/PKSIO/FITSreader.h>
+#include <atnf/PKSIO/PKSrecord.h>
 #include <atnf/PKSIO/PKSreader.h>
 #include <casa/aips.h>
+#include <casa/stdio.h>
 #include <casa/Arrays/Vector.h>
 #include <casa/Arrays/Matrix.h>
 …
 #include <casa/BasicSL/String.h>
+#include <casa/namespace.h>
 // <summary>
 // Class to read Parkes Multibeam data from a FITS file.
 // </summary>
-#include <casa/namespace.h>
 class PKSFITSreader : public PKSreader
+{
 …
     virtual Int open(
         const String fitsName,
+        const String antenna,
         Vector<Bool> &beams,
         Vector<Bool> &IFs,
 …
         Vector<Double> &antPosition,
         String &obsType,
+        String &bunit,
         Float  &equinox,
         String &dopplerFrame,
         Double &mjd,
         Double &refFreq,
+        Double &bandwidth,
+        String &fluxunit);
+        Double &bandwidth);
     // Get frequency parameters for each IF.
 …
         const Bool getSpectra = True,
         const Bool getXPol    = False,
+        const Bool getFeedPos = False);
+        const Bool getFeedPos = False,
+        const Bool getPointing = False,
+        const Int  coordSys   = 0);
     // Find the range of the data selected in time and position.
 …
     // 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,
+        Vector<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);
+    // Read the next data record, just the basics.
+    virtual Int read(
+        Int           &IFno,
+        Vector<Float> &tsys,
+        Vector<Float> &calFctr,
+        Matrix<Float> &baseLin,
+        Matrix<Float> &baseSub,
+        Matrix<Float> &spectra,
+        Matrix<uChar> &flagged);
+    virtual Int read(PKSrecord &pksrec);
     // Close the FITS file.
 …
     Int    *cBeams, *cIFs;
     uInt   cNBeam, cNIF;
     PKSMBrecord cMBrec;
+    MBrecord cMBrec;
     FITSreader  *cReader;

branches/alma/external/atnf/PKSIO/PKSMS2reader.cc

-              r1453
+              r1757
 //# PKSMS2reader.cc: Class to read Parkes Multibeam data from a v2 MS.
 //#---------------------------------------------------------------------------
 //# Copyright (C) 2000-2006
 //# Associated Universities, Inc. Washington DC, USA.
+//# livedata - processing pipeline for single-dish, multibeam spectral data.
+//# Copyright (C) 2000-2009, Australia Telescope National Facility, CSIRO
 //#
+//# This library is free software; you can redistribute it and/or modify it
+//# under the terms of the GNU Library General Public License as published by
+//# the Free Software Foundation; either version 2 of the License, or (at your
+//# option) any later version.
+//# This file is part of livedata.
 //#
 //# This library is distributed in the hope that it will be useful, but
 //# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 //# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
 //# License for more details.
+//# livedata is free software: you can redistribute it and/or modify it under
+//# the terms of the GNU General Public License as published by the Free
+//# Software Foundation, either version 3 of the License, or (at your option)
+//# any later version.
 //#
+//# You should have received a copy of the GNU Library General Public License
+//# along with this library; if not, write to the Free Software Foundation,
+//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
+//# livedata is distributed in the hope that it will be useful, but WITHOUT
+//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+//# more details.
 //#
+//# Correspondence concerning AIPS++ should be addressed as follows:
+//#        Internet email: aips2-request@nrao.edu.
+//#        Postal address: AIPS++ Project Office
+//#                        National Radio Astronomy Observatory
+//#                        520 Edgemont Road
+//#                        Charlottesville, VA 22903-2475 USA
+//# You should have received a copy of the GNU General Public License along
+//# with livedata.  If not, see <http://www.gnu.org/licenses/>.
 //#
+//# $Id$
+//# Correspondence concerning livedata may be directed to:
+//#        Internet email: mcalabre@atnf.csiro.au
+//#        Postal address: Dr. Mark Calabretta
+//#                        Australia Telescope National Facility, CSIRO
+//#                        PO Box 76
+//#                        Epping NSW 1710
+//#                        AUSTRALIA
+//#
+//# http://www.atnf.csiro.au/computing/software/livedata.html
+//# $Id: PKSMS2reader.cc,v 19.23 2009-09-29 07:33:38 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# Original: 2000/08/03, Mark Calabretta, ATNF
 //#---------------------------------------------------------------------------
 // AIPS++ includes.
 …
 #include <casa/Quanta/MVAngle.h>
 #include <casa/BasicMath/Math.h>
+#include <casa/Logging/LogIO.h>
+#include <casa/Utilities/Sort.h>
 #include <measures/Measures/MeasConvert.h>
 #include <measures/Measures/MEpoch.h>
 …
 // Parkes includes.
 #include <atnf/pks/pks_maths.h>
+#include <atnf/PKSIO/PKSrecord.h>
 #include <atnf/PKSIO/PKSMS2reader.h>
 …
 Int PKSMS2reader::open(
         const String msName,
+        const String antenna,
         Vector<Bool> &beams,
         Vector<Bool> &IFs,
 …
   cPKSMS  = MeasurementSet(msName);
+  // data selection by antenna
+  if ( antenna.length() == 0 ) {
+    cAntId.resize( 1 ) ;
+    cAntId[0] = 0 ;
+  }
+  else {
+    setupAntennaList( antenna ) ;
+    if ( cAntId.size() > 1 ) {
+      LogIO os( LogOrigin( "PKSMS2reader", "open()", WHERE ) ) ;
+      os << LogIO::WARN << "PKSMS2reader is not ready for multiple antenna selection. Use first antenna id " << cAntId[0] << "."<< LogIO::POST ;
+      Int tmp = cAntId[0] ;
+      cAntId.resize( 1 ) ;
+      cAntId[0] = tmp ;
+    }
+    stringstream ss ;
+    ss << "SELECT FROM $1 WHERE ANTENNA1 == ANTENNA2 && ANTENNA1 IN [" ;
+    for ( uInt i = 0 ; i < cAntId.size() ; i++ ) {
+      ss << cAntId[i] ;
+      if ( i == cAntId.size()-1 ) {
+        ss << "]" ;
+      }
+      else {
+        ss << "," ;
+      }
+    }
+    string taql = ss.str() ;
+    //cerr << "taql = " << taql << endl ;
+    cPKSMS = MeasurementSet( tableCommand( taql, cPKSMS ) ) ;
+  }
   // taql access to the syscal table
   cHaveSysCal = False;
 …
+  }
+  // Lock the table for read access.
+  cPKSMS.lock(False);
   cIdx    = 0;
   lastmjd = 0.0;
   cNRow   = cPKSMS.nrow();
   cMSopen = True;
-  // Lock the table for read access.
-  cPKSMS.lock(False);
   // Main MS table and subtable column access.
 …
   cSigStateCol.reference(stateCols.sig());
   cRefStateCol.reference(stateCols.ref());
   cDataDescIdCol.reference(msCols.dataDescId());
   cSpWinIdCol.reference(dataDescCols.spectralWindowId());
   cChanFreqCol.reference(spWinCols.chanFreq());
+  cTotBWCol.reference(spWinCols.totalBandwidth());
   cWeatherTimeCol.reference(weatherCols.time());
 …
   cBeamNoCol.reference(msCols.feed1());
   cPointingCol.reference(pointingCols.direction());
+  cPointingTimeCol.reference(pointingCols.time());
   cSigmaCol.reference(msCols.sigma());
   cNumReceptorCol.reference(feedCols.numReceptors());
 …
   cHaveDataCol = False;
   cHaveCorrectedDataCol = False;
-  //String telName = antennaCols.name()(0);
   ROMSObservationColumns observationCols(cPKSMS.observation());
+  String telName = observationCols.telescopeName()(0);
+  //cATF = (telName.contains("DA41") || telName.contains("DV01"));
+  cATF = telName.contains("ATF");
+  //String telName = observationCols.telescopeName()(0);
+  cTelName = observationCols.telescopeName()(0);
+  //cATF = cTelName.contains("ATF");
+  //cOSF = cTelName.contains("OSF");
+  //cALMA = cTelName.contains("ALMA");
+  cALMA = cTelName.contains("ATF")||cTelName.contains("OSF")||
+           cTelName.contains("ALMA");
   if (cHaveDataCol = cPKSMS.isColumn(MSMainEnums::DATA)) {
     if (cATF) {
+    if (cALMA) {
       //try to read a single baseline interferometeric data
       //and treat it as single dish data
 …
+  }
   cFlagCol.reference(msCols.flag());
   if (cGetXPol = (cPKSMS.isColumn(MSMainEnums::DATA) && (!cATF))) {
+  cFlagRowCol.reference(msCols.flagRow());
+  if (cGetXPol = (cPKSMS.isColumn(MSMainEnums::DATA) && (!cALMA))) {
     if ((cHaveXCalFctr = cPKSMS.tableDesc().isColumn("XCALFCTR"))) {
       cXCalFctrCol.attach(cPKSMS, "XCALFCTR");
 …
   //uInt nIF = dataDescCols.nrow();
   uInt nIF =spWinCols.nrow();
+  Vector<Int> spWinIds = cSpWinIdCol.getColumn() ;
   IFs.resize(nIF);
   IFs = True;
+  for ( Int ispw = 0 ; ispw < nIF ; ispw++ ) {
+    if ( allNE( ispw, spWinIds ) ) {
+      IFs(ispw) = False ;
+    }
+  }
   // Number of polarizations and channels in each IF.
-  ROScalarColumn<Int> spWinIdCol(dataDescCols.spectralWindowId());
   ROScalarColumn<Int> numChanCol(spWinCols.numChan());
 …
   nPol.resize(nIF);
   for (uInt iIF = 0; iIF < nIF; iIF++) {
+    nChan(iIF) = numChanCol(spWinIdCol(iIF));
+    nPol(iIF)  = numPolCol(polIdCol(iIF));
+    if ( IFs(iIF) ) {
+      nChan(iIF) = numChanCol(cSpWinIdCol(iIF)) ;
+      nPol(iIF) = numPolCol(polIdCol(iIF)) ;
+    }
+    else {
+      nChan(iIF) = 0 ;
+      nPol(iIF) = 0 ;
+    }
+  }
 …
   haveXPol = False;
   if (cGetXPol && !(cATF)) {
+  if (cGetXPol && !(cALMA)) {
     for (Int irow = 0; irow < cNRow; irow++) {
       if (cDataCol.isDefined(irow)) {
 …
         String &antName,
         Vector<Double> &antPosition,
+        String &obsMode,
+        // before merge...
+        //String &obsMode,
+        String &obsType,
+        String &bunit,
         Float  &equinox,
         String &dopplerFrame,
         Double &mjd,
         Double &refFreq,
+        Double &bandwidth,
+        String &fluxunit)
+        Double &bandwidth)
+{
   if (!cMSopen) {
 …
   // Antenna name and ITRF coordinates.
   ROMSAntennaColumns antennaCols(cPKSMS.antenna());
+  antName = antennaCols.name()(0);
+  antPosition = antennaCols.position()(0);
+  //antName = antennaCols.name()(0);
+  antName = antennaCols.name()(cAntId[0]);
+  if (cALMA) {
+     antName = cTelName + "-" + antName;
+  }
+  //antPosition = antennaCols.position()(0);
+  antPosition = antennaCols.position()(cAntId[0]);
   // Observation type.
   if (cObsModeCol.nrow()) {
     obsMode = cObsModeCol(0);
     if (obsMode == "\0") obsMode = "RF";
+    obsType = cObsModeCol(0);
+    if (obsType == "\0") obsType = "RF";
   } else {
     obsMode = "RF";
+  }
   fluxunit = "";
+    obsType = "RF";
+  }
+  bunit = "";
   if (cHaveDataCol) {
     const TableRecord& keywordSet2
        = cDataCol.columnDesc().keywordSet();
     if(keywordSet2.isDefined("UNIT")) {
       fluxunit = keywordSet2.asString("UNIT");
+      bunit = keywordSet2.asString("UNIT");
+    }
   } else {
 …
        = cFloatDataCol.columnDesc().keywordSet();
     if(keywordSet.isDefined("UNIT")) {
       fluxunit = keywordSet.asString("UNIT");
+      bunit = keywordSet.asString("UNIT");
+    }
+  }
 …
   String dirref = pointingCols.direction().keywordSet().asRecord("MEASINFO").
                     asString("Ref");
+  cDirRef = dirref;
+  if (dirref =="AZELGEO" || dirref == "AZEL") {
+     dirref = "J2000";
+  }
   sscanf(dirref.chars()+1, "%f", &equinox);
 …
         const Bool getSpectra,
         const Bool getXPol,
+        const Bool getFeedPos)
+        const Bool getFeedPos,
+        const Bool getPointing,
+        const Int  coordSys)
+{
   if (!cMSopen) {
 …
   cGetFeedPos = False;
+  // Get Pointing data (for MS)
+  cGetPointing = getPointing;
+  // Coordinate system?  (Only equatorial available.)
+  cCoordSys = 0;
   return maxNChan;
+}
 …
 // Read the next data record.
+/**
 Int PKSMS2reader::read(
         Int             &scanNo,
 …
         Matrix<Float>   &spectra,
         Matrix<uChar>   &flagged,
+        uInt            &flagrow,
         Complex         &xCalFctr,
         Vector<Complex> &xPol)
+**/
+Int PKSMS2reader::read(PKSrecord &pksrec)
+{
+  LogIO os( LogOrigin( "PKSMS2reader", "read()", WHERE ) ) ;
   if (!cMSopen) {
     return 1;
 …
   // Renumerate scan no. Here still is 1-based
   //scanNo = cScanNoCol(cIdx) - cScanNoCol(0) + 1;
+  scanNo = cScanNoCol(cIdx);
+  if (scanNo != cScanNo) {
+  //scanNo = cScanNoCol(cIdx);
+  pksrec.scanNo = cScanNoCol(cIdx);
+  if (pksrec.scanNo != cScanNo) {
     // Start of new scan.
     cScanNo  = scanNo;
+    cScanNo  = pksrec.scanNo;
     cCycleNo = 1;
     cTime    = cTimeCol(cIdx);
 …
   Double time = cTimeCol(cIdx);
   mjd      = time/86400.0;
   interval = cIntervalCol(cIdx);
+  pksrec.mjd      = time/86400.0;
+  pksrec.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;
   cTime   = time;
+  cCycleNo += nint((time - cTime)/pksrec.interval);
+  pksrec.cycleNo = cCycleNo;
+  cTime = time;
   Int fieldId = cFieldIdCol(cIdx);
   fieldName = cFieldNameCol(fieldId);
+  pksrec.fieldName = cFieldNameCol(fieldId);
   Int srcId = cSrcIdCol(fieldId);
 …
   for (uInt irow = 0; irow < cSrcId2Col.nrow(); irow++) {
     if (cSrcId2Col(irow) == srcId) {
+      srcName = cSrcNameCol(irow);
+    }
+  }
+  srcDir  = cSrcDirCol(srcId);
+  srcPM   = cSrcPMCol(srcId);
+      //srcName = cSrcNameCol(irow);
+      pksrec.srcName = cSrcNameCol(irow);
+    }
+  }
+  pksrec.srcDir  = cSrcDirCol(srcId);
+  pksrec.srcPM   = cSrcPMCol(srcId);
   // Systemic velocity.
   if (!cHaveSrcVel || cATF) {
     srcVel = 0.0f;
+  if (!cHaveSrcVel || cALMA) {
+    pksrec.srcVel = 0.0f;
   } else {
     srcVel  = cSrcVelCol(srcId)(IPosition(1,0));
+    pksrec.srcVel = cSrcVelCol(srcId)(IPosition(1,0));
+  }
   ROMSAntennaColumns antennaCols(cPKSMS.antenna());
+  String telescope = antennaCols.name()(0);
+  //String telescope = antennaCols.name()(0);
+  String telescope = antennaCols.name()(cAntId[0]);
   Bool cGBT = telescope.contains("GBT");
+  //Bool cPM = telescope.contains("PM"); // ACA TP antenna
+  //Bool cDV = telescope.contains("DV"); // VERTEX
+  //Bool cCM = telescope.contains("CM"); // ACA 7m antenna
+  //Bool cALMA = cPM || cDV || cCM ;
   // Observation type.
   // check if State Table exist
 …
   StateNRow=cObsModeCol.nrow();
   if (Table::isReadable(cPKSMS.stateTableName())) {
         obsMode = " ";
+        pksrec.obsType = " ";
     if (StateNRow > 0) {
       stateId = cStateIdCol(cIdx);
       if (stateId == -1) {
         //obsMode = " ";
+        //pksrec.obsType = " ";
       } else {
         obsMode = cObsModeCol(stateId);
+        pksrec.obsType = cObsModeCol(stateId);
         Bool sigState =cSigStateCol(stateId);
         Bool refState =cRefStateCol(stateId);
         //DEBUG
         //cerr <<"stateid="<<stateId<<" obsmode="<<obsMode<<endl;
+        //cerr <<"stateid="<<stateId<<" obsmode="<<pksrec.obsType<<endl;
         if (cGBT) {
           // split the obsMode string and append a proper label
+          // split the obsType string and append a proper label
           // (these are GBT specific)
           int epos = obsMode.find_first_of(':');
           int nextpos = obsMode.find_first_of(':',epos+1);
           string obsMode1 = obsMode.substr(0,epos);
           string obsMode2 = obsMode.substr(epos+1,nextpos-epos-1);
+          int epos = pksrec.obsType.find_first_of(':');
+          int nextpos = pksrec.obsType.find_first_of(':',epos+1);
+          string obsMode1 = pksrec.obsType.substr(0,epos);
+          string obsMode2 = pksrec.obsType.substr(epos+1,nextpos-epos-1);
           //cerr <<"obsMode2= "<<obsMode2<<endl;
           if (!srcName.contains("_ps")
               &&!srcName.contains("_psr")
               &&!srcName.contains("_nod")
               &&!srcName.contains("_fs")
               &&!srcName.contains("_fsr")) {
+          if (!pksrec.srcName.contains("_ps")
+              &&!pksrec.srcName.contains("_psr")
+              &&!pksrec.srcName.contains("_nod")
+              &&!pksrec.srcName.contains("_fs")
+              &&!pksrec.srcName.contains("_fsr")) {
             // if Nod mode observation , append '_nod'
             if (obsMode1 == "Nod") {
+              srcName.append("_nod");
+              //pksrec.srcName.append("_nod");
+              pksrec.srcType = SrcType::NOD ;
             } else if (obsMode1 == "OffOn") {
             // for GBT position switch observations (OffOn or OnOff)
+              if (obsMode2 == "PSWITCHON") srcName.append("_ps");
+              if (obsMode2 == "PSWITCHOFF") srcName.append("_psr");
+              //if (obsMode2 == "PSWITCHON") pksrec.srcName.append("_ps");
+              //if (obsMode2 == "PSWITCHOFF") pksrec.srcName.append("_psr");
+              if (obsMode2 == "PSWITCHON") pksrec.srcType = SrcType::PSON ;
+              if (obsMode2 == "PSWITCHOFF") pksrec.srcType = SrcType::PSOFF ;
             } else {
               if (obsMode2 == "FSWITCH") {
               // for GBT frequency switch mode
+                if (sigState) srcName.append("_fs");
+                if (refState) srcName.append("_fsr");
+                //if (sigState) pksrec.srcName.append("_fs");
+                //if (refState) pksrec.srcName.append("_fsr");
+                if (sigState) pksrec.srcType = SrcType::FSON ;
+                if (refState) pksrec.srcType = SrcType::FSOFF ;
+              }
+            }
+          }
+        }
+        else if (cALMA) {
+          // ALMA tag
+          // split the obsType string and append a proper label
+          string substr[1] ;
+          int numSubstr = split( pksrec.obsType, substr, 1, "," );
+          String obsType = String( substr[0] );
+          int epos = obsType.find_first_of('.');
+          int nextpos = obsType.find_first_of('.',epos+1);
+          string obsMode1 = obsType.substr(0,epos);
+          string obsMode2 = obsType.substr(epos+1,nextpos-epos-1);
+          //cerr <<"obsMode2= "<<obsMode2<<endl;
+          // Current OBS_MODE format:
+          //
+          //     ON: OBSERVE_TARGET.ON_SOURCE
+          //    OFF: OBSERVE_TARGET.OFF_SOURCE
+          //
+          if (obsMode1 == "OBSERVE_TARGET") {
+            //if (obsMode2 == "ON_SOURCE") pksrec.srcName.append("_pson");
+            //if (obsMode2 == "OFF_SOURCE") pksrec.srcName.append("_psoff");
+            if (obsMode2 == "ON_SOURCE") pksrec.srcType = SrcType::PSON ;
+            if (obsMode2 == "OFF_SOURCE") pksrec.srcType = SrcType::PSOFF ;
+          }
+        }
+      }
+    }
 …
+  }
   if (cGBT) {
+    if (Cal > 0 && !srcName.contains("_calon")) {
+      srcName.append("_calon");
+    }
+  }
+  IFno = iIF + 1;
+    if (Cal > 0 && !pksrec.srcName.contains("_calon")) {
+      //pksrec.srcName.append("_calon");
+      if ( pksrec.srcType == SrcType::NOD )
+        pksrec.srcType = SrcType::NODCAL ;
+      else if ( pksrec.srcType == SrcType::PSON )
+        pksrec.srcType = SrcType::PONCAL ;
+      else if ( pksrec.srcType == SrcType::PSOFF )
+        pksrec.srcType = SrcType::POFFCAL ;
+      else if ( pksrec.srcType == SrcType::FSON )
+        pksrec.srcType = SrcType::FONCAL ;
+      else if ( pksrec.srcType == SrcType::FSOFF )
+        pksrec.srcType = SrcType::FOFFCAL ;
+      else
+        pksrec.srcName.append("_calon");
+    }
+  }
+  pksrec.IFno = iIF + 1;
   Int nChan = abs(cEndChan(iIF) - cStartChan(iIF)) + 1;
   // Minimal handling on continuum data.
   Vector<Double> chanFreq = cChanFreqCol(iIF);
+  pksrec.nchan = nChan;
   if (nChan == 1) {
+    freqInc  = chanFreq(0);
+    refFreq  = chanFreq(0);
+    restFreq = 0.0f;
+    //pksrec.freqInc  = chanFreq(0);
+    pksrec.freqInc  = cTotBWCol(iIF);
+    pksrec.refFreq  = chanFreq(0);
+    pksrec.restFreq.resize(1);
+    pksrec.restFreq[0] = 0.0f;
   } else {
     if (cStartChan(iIF) <= cEndChan(iIF)) {
       freqInc = chanFreq(1) - chanFreq(0);
+      pksrec.freqInc = chanFreq(1) - chanFreq(0);
     } else {
+      freqInc = chanFreq(0) - chanFreq(1);
+    }
+    refFreq  = chanFreq(cRefChan(iIF)-1);
+      pksrec.freqInc = chanFreq(0) - chanFreq(1);
+    }
+    pksrec.refFreq  = chanFreq(cRefChan(iIF)-1);
     Bool HaveSrcRestFreq= cSrcRestFrqCol.isDefined(srcId);
     if (HaveSrcRestFreq) {
       //restFreq = cSrcRestFrqCol(srcId)(IPosition(1,0));
+      restFreq = cSrcRestFrqCol(srcId);
+      //restFreq = cSrcRestFrqCol(srcId);
+      pksrec.restFreq = cSrcRestFrqCol(srcId);
     } else {
+      restFreq = 0.0f;
+    }
+  }
+  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;
+      pksrec.restFreq.resize(1);
+      pksrec.restFreq[0] = 0.0f;
+    }
+  }
+  //pksrec.bandwidth = abs(pksrec.freqInc * nChan);
+  pksrec.bandwidth = abs(cTotBWCol(0));
+  pksrec.tcal.resize(cNPol(iIF));
+  pksrec.tcal      = 0.0f;
+  pksrec.tcalTime  = "";
+//  pksrec.azimuth   = 0.0f;
+//  pksrec.elevation = 0.0f;
+  pksrec.parAngle  = 0.0f;
+  pksrec.focusAxi  = 0.0f;
+  pksrec.focusTan  = 0.0f;
+  pksrec.focusRot  = 0.0f;
   // Find the appropriate entry in the WEATHER subtable.
 …
+    }
+  }
   if (weatherIdx < 0 || !cHaveWeatherTab) {
     // No appropriate WEATHER entry.
     pressure    = 0.0f;
     humidity    = 0.0f;
     temperature = 0.0f;
+    pksrec.temperature = 0.0f;
+    pksrec.pressure    = 0.0f;
+    pksrec.humidity    = 0.0f;
   } else {
+    pressure    = cPressureCol(weatherIdx);
+    humidity    = cHumidityCol(weatherIdx);
+    temperature = cTemperatureCol(weatherIdx);
+  }
+  windSpeed = 0.0f;
+  windAz    = 0.0f;
+  refBeam = 0;
+  beamNo  = ibeam + 1;
+  //Matrix<Double> pointingDir = cPointingCol(fieldId);
+  //pointingDir = cPointingCol(fieldId);
+  //direction = pointingDir.column(0);
+  //uInt ncols = pointingDir.ncolumn();
+  //if (ncols == 1) {
+  //  scanRate = 0.0f;
+  //} else {
+  //  scanRate  = pointingDir.column(1);
+  //}
+    pksrec.temperature = cTemperatureCol(weatherIdx);
+    pksrec.pressure    = cPressureCol(weatherIdx);
+    pksrec.humidity    = cHumidityCol(weatherIdx);
+  }
+  pksrec.windSpeed = 0.0f;
+  pksrec.windAz    = 0.0f;
+  pksrec.refBeam = 0;
+  pksrec.beamNo  = ibeam + 1;
+  //pointing/azel
+  MVPosition mvpos(antennaCols.position()(cAntId[0]));
+  MPosition mp(mvpos);
+  Quantum<Double> qt(time,"s");
+  MVEpoch mvt(qt);
+  MEpoch me(mvt);
+  MeasFrame frame(mp, me);
+  MDirection md;
+  pksrec.pCode = 0;
+  pksrec.rateAge = 0.0f;
+  pksrec.paRate = 0.0f;
+  if (cGetPointing) {
+    //cerr << "get pointing data ...." << endl;
+    ROScalarColumn<Int> pAntIdCol ;
+    ROScalarColumn<Double> psTimeCol ;
+    Table ptTable = cPKSMS.pointing() ;
+    MSPointing selPtTab( ptTable( ptTable.col("ANTENNA_ID") == cAntId[0] ) ) ;
+    pAntIdCol.attach( selPtTab, "ANTENNA_ID" ) ;
+    Vector<Int> antIds = pAntIdCol.getColumn() ;
+    psTimeCol.attach( selPtTab, "TIME" ) ;
+    Vector<Double> pTimes = psTimeCol.getColumn();
+    Bool doInterp = False ;
+    Int PtIdx=-1;
+    for (PtIdx = pTimes.nelements()-1; PtIdx >= 0; PtIdx--) {
+      if ( pTimes[PtIdx] == time ) {
+        break ;
+      }
+      else if ( pTimes[PtIdx] < time ) {
+        if ( PtIdx != pTimes.nelements()-1 ) {
+          doInterp = True ;
+        }
+        break ;
+      }
+    }
+    if ( PtIdx == -1 ) {
+      PtIdx = 0 ;
+    }
+    //cerr << "got index=" << PtIdx << endl;
+    Matrix<Double> pointingDir = cPointingCol(PtIdx);
+    ROMSPointingColumns PtCols( selPtTab ) ;
+    Vector<Double> pointingDirVec ;
+    if ( doInterp ) {
+      Double dt1 = time - pTimes[PtIdx] ;
+      Double dt2 = pTimes[PtIdx+1] - time ;
+      Vector<Double> dirVec1 = pointingDir.column(0) ;
+      Matrix<Double> pointingDir2 = cPointingCol(PtIdx+1) ;
+      Vector<Double> dirVec2 = pointingDir2.column(0) ;
+      pointingDirVec = (dt1*dirVec2+dt2*dirVec1)/(dt1+dt2) ;
+      Vector<MDirection> vmd1(1) ;
+      Vector<MDirection> vmd2(1) ;
+      PtCols.directionMeasCol().get(PtIdx,vmd1) ;
+      Vector<Double> angle1 = vmd1(0).getAngle().getValue("rad") ;
+      PtCols.directionMeasCol().get(PtIdx+1,vmd2) ;
+      Vector<Double> angle2 = vmd2(0).getAngle().getValue("rad") ;
+      Vector<Double> angle = (dt1*angle2+dt2*angle1)/(dt1+dt2) ;
+      Quantum< Vector<Double> > qangle( angle, "rad" ) ;
+      String typeStr = vmd1(0).getRefString() ;
+      //cerr << "vmd1.getRefString()=" << typeStr << endl ;
+      MDirection::Types mdType ;
+      MDirection::getType( mdType, typeStr ) ;
+      //cerr << "mdType=" << mdType << endl ;
+      md = MDirection( qangle, mdType ) ;
+      //cerr << "md=" << md.getAngle().getValue("rad") << endl ;
+    }
+    else {
+      pointingDirVec = pointingDir.column(0) ;
+      Vector<MDirection> vmd(1);
+      PtCols.directionMeasCol().get(PtIdx,vmd);
+      md = vmd[0];
+    }
+    // put J2000 coordinates in "direction"
+    if (cDirRef =="J2000") {
+      pksrec.direction = pointingDirVec ;
+    }
+    else {
+      pksrec.direction =
+        MDirection::Convert(md, MDirection::Ref(MDirection::J2000,
+                                                frame)
+                            )().getAngle("rad").getValue();
+    }
+    uInt ncols = pointingDir.ncolumn();
+    pksrec.scanRate.resize(2);
+    if (ncols == 1) {
+      pksrec.scanRate = 0.0f;
+    } else {
+      pksrec.scanRate(0) = pointingDir.column(1)(0);
+      pksrec.scanRate(1) = pointingDir.column(1)(1);
+    }
+  }
+  else {
   // Get direction from FIELD table
   // here, assume direction to be the field direction not pointing
+  Matrix<Double> delayDir = cFieldDelayDirCol(fieldId);
+  direction = delayDir.column(0);
+  uInt ncols = delayDir.ncolumn();
+  if (ncols == 1) {
+    scanRate = 0.0f;
+  } else {
+    scanRate  = delayDir.column(1);
+  }
+    Matrix<Double> delayDir = cFieldDelayDirCol(fieldId);
+    pksrec.direction = delayDir.column(0);
+    uInt ncols = delayDir.ncolumn();
+    pksrec.scanRate.resize(2);
+    if (ncols == 1) {
+      pksrec.scanRate = 0.0f;
+    } else {
+      pksrec.scanRate(0)  = delayDir.column(1)(0);
+      pksrec.scanRate(1)  = delayDir.column(1)(1);
+    }
+  }
   // caluculate azimuth and elevation
   // first, get the reference frame
+ /**
   MVPosition mvpos(antennaCols.position()(0));
   MPosition mp(mvpos);
 …
   MEpoch me(mvt);
   MeasFrame frame(mp, me);
+  **/
   //
   ROMSFieldColumns fldCols(cPKSMS.field());
   Vector<MDirection> vmd(1);
   MDirection md;
+  //MDirection md;
   fldCols.delayDirMeasCol().get(fieldId,vmd);
   md = vmd[0];
 …
                             )().getAngle("rad").getValue();
   //cerr<<"azel="<<azel<<endl;
   azimuth = azel[0];
   elevation = azel[1];
+  pksrec.azimuth = azel[0];
+  pksrec.elevation = azel[1];
   // Get Tsys assuming that entries in the SYSCAL table match the main table.
 …
+  }
   if (cHaveTsys) {
     cTsysCol.get(cIdx, tsys, True);
+    cTsysCol.get(cIdx, pksrec.tsys, True);
   } else {
     Int numReceptor;
     cNumReceptorCol.get(0, numReceptor);
     tsys.resize(numReceptor);
     tsys = 1.0f;
+  }
   cSigmaCol.get(cIdx, sigma, True);
+    pksrec.tsys.resize(numReceptor);
+    pksrec.tsys = 1.0f;
+  }
+  cSigmaCol.get(cIdx, pksrec.sigma, True);
   //get Tcal if available
 …
     if (nTcalColRow > 0) {
     // find tcal match with the data with the data time stamp
       Double mjds = mjd*(24*3600);
+      Double mjds = pksrec.mjd*(24*3600);
       Double dtcalTime;
       if ( mjd > lastmjd || cIdx==0 ) {
+      if ( pksrec.mjd > lastmjd || cIdx==0 ) {
         //Table tmptab = cSysCalTab(near(cSysCalTab.col("TIME"),mjds));
         tmptab = cSysCalTab(near(cSysCalTab.col("TIME"),mjds), nrws);
 …
       ROScalarColumn<Double> tcalTimeCol(tmptab2, "TIME");
       if (syscalrow==0) {
+        cerr<<"Cannot find any matching Tcal at/near the data timestamp."
+           << " Set Tcal=0.0"<<endl;
+        os << LogIO::NORMAL
+           <<"Cannot find any matching Tcal at/near the data timestamp."
+           << " Set Tcal=0.0" << LogIO::POST ;
       } else {
         tcalCol.get(0, tcal);
+        tcalCol.get(0, pksrec.tcal);
         tcalTimeCol.get(0,dtcalTime);
         tcalTime = MVTime(dtcalTime/(24*3600)).string(MVTime::YMD);
+        pksrec.tcalTime = MVTime(dtcalTime/(24*3600)).string(MVTime::YMD);
         //DEBUG
         //cerr<<"cIdx:"<<cIdx<<" tcal="<<tcal<<" tcalTime="<<tcalTime<<endl;
 …
+      }
+    }
     lastmjd = mjd;
+    lastmjd = pksrec.mjd;
+  }
   // Calibration factors (if available).
   calFctr.resize(cNPol(iIF));
+  pksrec.calFctr.resize(cNPol(iIF));
   if (cHaveCalFctr) {
     cCalFctrCol.get(cIdx, calFctr);
+    cCalFctrCol.get(cIdx, pksrec.calFctr);
   } else {
     calFctr = 0.0f;
+    pksrec.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);
+    pksrec.baseLin.resize(2,cNPol(iIF));
+    cBaseLinCol.get(cIdx, pksrec.baseLin);
+    pksrec.baseSub.resize(24,cNPol(iIF));
+    cBaseSubCol.get(cIdx, pksrec.baseSub);
   } else {
+    baseLin.resize(0,0);
+    baseSub.resize(0,0);
+  }
+    pksrec.baseLin.resize(0,0);
+    pksrec.baseSub.resize(0,0);
+  }
   // Get spectral data.
   if (cGetSpectra) {
 …
     // Transpose spectra.
     Int nPol = tmpData.nrow();
     spectra.resize(nChan, nPol);
     flagged.resize(nChan, nPol);
+    pksrec.spectra.resize(nChan, nPol);
+    pksrec.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);
+          pksrec.spectra(ichan,ipol) = tmpData(ipol,ichan);
+          pksrec.flagged(ichan,ipol) = tmpFlag(ipol,ichan);
+        }
+      }
 …
       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);
+          pksrec.spectra(ichan,ipol) = tmpData(ipol,jchan);
+          pksrec.flagged(ichan,ipol) = tmpFlag(ipol,jchan);
+        }
+      }
+    }
+    // Row-based flagging info. (True:1, False:0)
+    pksrec.flagrow = (cFlagRowCol(cIdx) ? 1 : 0);
+  }
 …
     if (cHaveXCalFctr) {
       cXCalFctrCol.get(cIdx, xCalFctr);
+      cXCalFctrCol.get(cIdx, pksrec.xCalFctr);
     } else {
       xCalFctr = Complex(0.0f, 0.0f);
+    }
     if(!cATF) {
       cDataCol.get(cIdx, xPol, True);
+      pksrec.xCalFctr = Complex(0.0f, 0.0f);
+    }
+    if(!cALMA) {
+      cDataCol.get(cIdx, pksrec.xPol, True);
       if (cEndChan(iIF) < cStartChan(iIF)) {
 …
         Int jchan = nChan - 1;
         for (Int ichan = 0; ichan < nChan/2; ichan++, jchan--) {
           ctmp = xPol(ichan);
           xPol(ichan) = xPol(jchan);
           xPol(jchan) = ctmp;
+          ctmp = pksrec.xPol(ichan);
+          pksrec.xPol(ichan) = pksrec.xPol(jchan);
+          pksrec.xPol(jchan) = ctmp;
+        }
+      }
 …
     cBaseLinCol.get(cIdx, baseLin);
     baseSub.resize(9,cNPol(iIF));
+    baseSub.resize(24,cNPol(iIF));
     cBaseSubCol.get(cIdx, baseSub);
 …
   cMSopen = False;
+}
+//-------------------------------------------------------- PKSMS2reader::splitAntenanSelectionString
+// split antenna selection string
+// delimiter is ','
+Vector<String> PKSMS2reader::splitAntennaSelectionString( const String s )
+{
+  Char delim = ',' ;
+  Int n = s.freq( delim ) + 1 ;
+  Vector<String> antlist ;
+  string sl[n] ;
+  Int numSubstr = split( s, sl, n, "," );
+  antlist.resize( numSubstr ) ;
+  for ( Int i = 0 ; i < numSubstr ; i++ ) {
+    antlist[i] = String( sl[i] ) ;
+    antlist[i].trim() ;
+  }
+  //cerr << "antlist = " << antlist << endl ;
+  return antlist ;
+}
+//-------------------------------------------------------- PKSMS2reader::setupAntennaList
+// Fill cAntenna and cAntId
+void PKSMS2reader::setupAntennaList( const String s )
+{
+  LogIO os( LogOrigin( "PKSMS2reader", "setupAntennaList()", WHERE ) ) ;
+  //cerr << "antenna specification: " << s << endl ;
+  ROMSAntennaColumns antennaCols(cPKSMS.antenna());
+  ROScalarColumn<String> antNames = antennaCols.name();
+  Int nrow = antNames.nrow() ;
+  Vector<String> antlist = splitAntennaSelectionString( s ) ;
+  Int len = antlist.size() ;
+  Vector<Int> AntId( len ) ;
+  Regex re( "[0-9]+" ) ;
+  for ( Int i = 0 ; i < len ; i++ ) {
+    if ( antlist[i].matches( re ) ) {
+      AntId[i] = atoi( antlist[i].c_str() ) ;
+      if ( AntId[i] >= nrow ) {
+        os << LogIO::SEVERE << "Antenna index out of range: " << AntId[i] << LogIO::EXCEPTION ;
+      }
+    }
+    else {
+      AntId[i] = -1 ;
+      for ( uInt j = 0 ; j < antNames.nrow() ; j++ ) {
+        if ( antlist[i] == antNames(j) ) {
+          AntId[i] = j ;
+          break ;
+        }
+      }
+      if ( AntId[i] == -1 ) {
+        os << LogIO::SEVERE << "Specified antenna name not found: " << antlist[i] << LogIO::EXCEPTION ;
+      }
+    }
+  }
+  //cerr << "AntId = " << AntId << endl ;
+  vector<Int> uniqId ;
+  uniqId.push_back( AntId(0) ) ;
+  for ( uInt i = 1 ; i < AntId.size() ; i++ ) {
+    if ( count(uniqId.begin(),uniqId.end(),AntId[i]) == 0 ) {
+      uniqId.push_back( AntId[i] ) ;
+    }
+  }
+  Vector<Int> newAntId( uniqId ) ;
+  cAntId.assign( newAntId ) ;
+  //cerr << "cAntId = " << cAntId << endl ;
+}

branches/alma/external/atnf/PKSIO/PKSMS2reader.h

-              r1453
+              r1757
 //# PKSMS2reader.h: Class to read Parkes Multibeam data from a v2 MS.
 //#---------------------------------------------------------------------------
+//# Copyright (C) 2000-2006
+//# Associated Universities, Inc. Washington DC, USA.
+//#
+//# This library is free software; you can redistribute it and/or modify it
+//# under the terms of the GNU Library General Public License as published by
+//# the Free Software Foundation; either version 2 of the License, or (at your
+//# option) any later version.
+//#
+//# This library is distributed in the hope that it will be useful, but WITHOUT
+//# livedata - processing pipeline for single-dish, multibeam spectral data.
+//# Copyright (C) 2000-2009, Australia Telescope National Facility, CSIRO
+//#
+//# This file is part of livedata.
+//#
+//# livedata is free software: you can redistribute it and/or modify it under
+//# the terms of the GNU General Public License as published by the Free
+//# Software Foundation, either version 3 of the License, or (at your option)
+//# any later version.
+//#
+//# livedata is distributed in the hope that it will be useful, but WITHOUT
 //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
+//# License for more details.
+//#
+//# You should have received a copy of the GNU Library General Public License
+//# along with this library; if not, write to the Free Software Foundation,
+//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
+//#
+//# Correspondence concerning AIPS++ should be addressed as follows:
+//#        Internet email: aips2-request@nrao.edu.
+//#        Postal address: AIPS++ Project Office
+//#                        National Radio Astronomy Observatory
+//#                        520 Edgemont Road
+//#                        Charlottesville, VA 22903-2475 USA
+//#
+//# $Id$
+//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+//# more details.
+//#
+//# You should have received a copy of the GNU General Public License along
+//# with livedata.  If not, see <http://www.gnu.org/licenses/>.
+//#
+//# Correspondence concerning livedata may be directed to:
+//#        Internet email: mcalabre@atnf.csiro.au
+//#        Postal address: Dr. Mark Calabretta
+//#                        Australia Telescope National Facility, CSIRO
+//#                        PO Box 76
+//#                        Epping NSW 1710
+//#                        AUSTRALIA
+//#
+//# http://www.atnf.csiro.au/computing/software/livedata.html
+//# $Id: PKSMS2reader.h,v 19.18 2009-09-29 07:33:38 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# Original: 2000/08/03, Mark Calabretta, ATNF
 …
 #include <atnf/PKSIO/PKSreader.h>
+#include <atnf/PKSIO/PKSrecord.h>
 #include <casa/aips.h>
 …
 #include <tables/Tables/ScalarColumn.h>
+#include <casa/namespace.h>
 // <summary>
 // Class to read Parkes Multibeam data from a v2 MS.
 // </summary>
-#include <casa/namespace.h>
 class PKSMS2reader : public PKSreader
 …
     virtual Int open(
         const String msName,
+        const String antenna,
         Vector<Bool> &beams,
         Vector<Bool> &IFs,
 …
         Vector<Double> &antPosition,
         String &obsMode,
+        String &bunit,
         Float  &equinox,
+        String &freqRef,
+        //String &freqRef,
+        String &dopplerFrame,
         Double &mjd,
         Double &refFreq,
+        Double &bandwidth,
+        String &fluxunit);
+        Double &bandwidth);
     // Get frequency parameters for each IF.
 …
         const Bool getSpectra = True,
         const Bool getXPol    = False,
+        const Bool getFeedPos = False);
+        const Bool getFeedPos = False,
+        const Bool getPointing = False,
+        const Int  coordSys   = 0);
     // Find the range of the data selected in time and position.
 …
     // Read the next data record.
+/**
     virtual Int read(
         Int             &scanNo,
 …
         Complex         &xCalFctr,
         Vector<Complex> &xPol);
+**/
+    virtual Int read(PKSrecord &pksrec);
     // Read the next data record, just the basics.
 …
   private:
+    Vector<String> splitAntennaSelectionString( const String s );
+    void setupAntennaList( const String s ) ;
     Bool   cHaveBaseLin, cHaveCalFctr, cHaveSrcVel, cHaveTsys, cHaveXCalFctr,
            cMSopen, cHaveTcal, cHaveDataCol, cATF, cHaveSysCal, cHaveCorrectedDataCol;
+           cMSopen, cHaveTcal, cHaveDataCol, cALMA, cHaveSysCal, cHaveCorrectedDataCol;
     Int    cCycleNo, cIdx, cNRow, cScanNo;
     Double cTime, lastmjd;
 …
     Vector<Bool>   cBeams, cIFs;
     Vector<Slicer> cDataSel;
+    String         cDirRef, cTelName;
     MeasurementSet cPKSMS;
     Table          cSysCalTab, tmptab, tmptab2;
+    //Vector<String> cAntenna;
+    Vector<Int> cAntId;
     ROScalarColumn<Int>     cScanNoCol;
 …
     ROScalarColumn<Int>     cSpWinIdCol;
     ROArrayColumn<Double>   cChanFreqCol;
+    ROScalarColumn<Double>   cTotBWCol;
     ROScalarColumn<Double>  cWeatherTimeCol;
     ROScalarColumn<Float>   cTemperatureCol;
 …
     ROScalarColumn<Int>     cBeamNoCol;
     ROArrayColumn<Double>   cPointingCol;
+    ROScalarColumn<Double>  cPointingTimeCol;
     ROArrayColumn<Float>    cTsysCol;
     ROArrayColumn<Float>    cSigmaCol;
 …
     ROArrayColumn<Float>    cFloatDataCol;
     ROArrayColumn<Bool>     cFlagCol;
+    ROScalarColumn<Bool>    cFlagRowCol;
     ROScalarColumn<Complex> cXCalFctrCol;
     ROArrayColumn<Complex>  cDataCol;

branches/alma/external/atnf/PKSIO/PKSMS2writer.cc

-              r1453
+              r1757
 //# PKSMS2writer.cc: Class to write Parkes multibeam data to a measurementset.
 //#---------------------------------------------------------------------------
 //# Copyright (C) 2000-2006
 //# Associated Universities, Inc. Washington DC, USA.
+//# livedata - processing pipeline for single-dish, multibeam spectral data.
+//# Copyright (C) 2000-2009, Australia Telescope National Facility, CSIRO
 //#
+//# This library is free software; you can redistribute it and/or modify it
+//# under the terms of the GNU Library General Public License as published by
+//# the Free Software Foundation; either version 2 of the License, or (at your
+//# option) any later version.
+//# This file is part of livedata.
 //#
 //# This library is distributed in the hope that it will be useful, but
 //# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 //# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
 //# License for more details.
+//# livedata is free software: you can redistribute it and/or modify it under
+//# the terms of the GNU General Public License as published by the Free
+//# Software Foundation, either version 3 of the License, or (at your option)
+//# any later version.
 //#
+//# You should have received a copy of the GNU Library General Public License
+//# along with this library; if not, write to the Free Software Foundation,
+//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
+//# livedata is distributed in the hope that it will be useful, but WITHOUT
+//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+//# more details.
 //#
+//# Correspondence concerning AIPS++ should be addressed as follows:
+//#        Internet email: aips2-request@nrao.edu.
+//#        Postal address: AIPS++ Project Office
+//#                        National Radio Astronomy Observatory
+//#                        520 Edgemont Road
+//#                        Charlottesville, VA 22903-2475 USA
+//# You should have received a copy of the GNU General Public License along
+//# with livedata.  If not, see <http://www.gnu.org/licenses/>.
 //#
+//# $Id: PKSMS2writer.cc,v 19.11 2006/11/06 22:25:22 mmarquar Exp $
+//# Correspondence concerning livedata may be directed to:
+//#        Internet email: mcalabre@atnf.csiro.au
+//#        Postal address: Dr. Mark Calabretta
+//#                        Australia Telescope National Facility, CSIRO
+//#                        PO Box 76
+//#                        Epping NSW 1710
+//#                        AUSTRALIA
+//#
+//# http://www.atnf.csiro.au/computing/software/livedata.html
+//# $Id: PKSMS2writer.cc,v 19.16 2009-09-29 07:33:38 cal103 Exp $
 //#---------------------------------------------------------------------------
+#include <atnf/PKSIO/PKSrecord.h>
 #include <atnf/PKSIO/PKSMS2writer.h>
 …
 #include <tables/Tables/TiledShapeStMan.h>
+// Class name
+const string className = "PKSMS2writer" ;
 //------------------------------------------------- PKSMS2writer::PKSMS2writer
 …
 PKSMS2writer::PKSMS2writer()
+{
+  cPKSMS = 0x0;
+}
 …
         const Vector<Double> antPosition,
         const String obsMode,
+        const String bunit,
         const Float  equinox,
         const String dopplerFrame,
 …
         const Vector<uInt> nPol,
         const Vector<Bool> haveXPol,
+        const Bool   haveBase,
+        const String fluxUnit)
+{
+        const Bool   haveBase)
+{
+  const string methodName = "create()" ;
+  LogIO os( LogOrigin( className, methodName, WHERE ) ) ;
+  if (cPKSMS) {
+    os << LogIO::SEVERE << "Output MS already open, close it first." << LogIO::POST ;
+    return 1;
+  }
   // Open a MS table.
   TableDesc pksDesc = MS::requiredTableDesc();
 …
   Int maxNPol = max(cNPol);
+  cGBT = cAPEX = cSMT = cALMA = False;
+  cGBT = cAPEX = cSMT = cALMA = cATF = False;
+  String telName = antName;
   // check if it is GBT data
   if (antName.contains("GBT")) {
 …
     cALMA = True;
+  }
+  else if (antName.contains("ATF")) {
+    cATF = True;
+    telName="ATF";
+  }
-  //cGBT = antName.contains("GBT");
-  //cAPEX = antName.contains("APEX");
-  //cSMT = antName.contains("HHT");
-  //cALMA = antName.contains("ALMA");
   // Add the non-standard CALFCTR column.
   pksDesc.addColumn(ArrayColumnDesc<Float>("CALFCTR", "Calibration factors",
 …
   //              define("UNIT", String("Jy"));
   pksDesc.rwColumnDesc(MS::columnName(MS::FLOAT_DATA)).rwKeywordSet().
                 define("UNIT", fluxUnit);
+                define("UNIT", bunit);
   pksDesc.rwColumnDesc(MS::columnName(MS::FLOAT_DATA)).rwKeywordSet().
                 define("MEASURE_TYPE", "");
 …
                 IPosition(2,2,maxNPol), ColumnDesc::Direct));
     pksDesc.addColumn(ArrayColumnDesc<Float>("BASESUB", "Baseline subtracted",
                 IPosition(2,9,maxNPol), ColumnDesc::Direct));
+                IPosition(2,24,maxNPol), ColumnDesc::Direct));
+  }
 …
     //            define("UNIT", "Jy");
     pksDesc.rwColumnDesc(MS::columnName(MS::DATA)).rwKeywordSet().
                 define("UNIT", fluxUnit);
+                define("UNIT", bunit);
     pksDesc.rwColumnDesc(MS::columnName(MS::DATA)).rwKeywordSet().
                 define("MEASURE_TYPE", "");
 …
   addFeedEntry();
   //addObservationEntry(observer, project);
   addObservationEntry(observer, project, antName);
+  addObservationEntry(observer, project, telName);
   addProcessorEntry();
 …
 // Write the next data record.
+/**
 Int PKSMS2writer::write(
         const Int             scanNo,
 …
         const Matrix<Float>   &spectra,
         const Matrix<uChar>   &flagged,
+        const uInt            flagrow,
         const Complex         xCalFctr,
         const Vector<Complex> &xPol)
+**/
+Int PKSMS2writer::write(
+        const PKSrecord &pksrec)
+{
   // Extend the time range in the OBSERVATION subtable.
   Vector<Double> timerange(2);
   cObservationCols->timeRange().get(0, timerange);
   Double time = mjd*86400.0;
+  Double time = pksrec.mjd*86400.0;
   if (timerange(0) == 0.0) {
     timerange(0) = time;
 …
   cObservationCols->timeRange().put(0, timerange);
   Int iIF = IFno - 1;
+  Int iIF = pksrec.IFno - 1;
   Int nChan = cNChan(iIF);
   Int nPol  = cNPol(iIF);
 …
   // IFno is the 1-relative row number in the DATA_DESCRIPTION,
   // SPECTRAL_WINDOW, and POLARIZATION subtables.
   if (Int(cDataDescription.nrow()) < IFno) {
+  if (Int(cDataDescription.nrow()) < pksrec.IFno) {
     // Add a new entry to each subtable.
+    addDataDescriptionEntry(IFno);
+    addSpectralWindowEntry(IFno, nChan, refFreq, bandwidth, freqInc);
+    addPolarizationEntry(IFno, nPol);
+    addDataDescriptionEntry(pksrec.IFno);
+    addSpectralWindowEntry(pksrec.IFno, nChan, pksrec.refFreq,
+      pksrec.bandwidth, pksrec.freqInc);
+    addPolarizationEntry(pksrec.IFno, nPol);
+  }
   // Find or add the source to the SOURCE subtable.
+  Int srcId = addSourceEntry(srcName, srcDir, srcPM, restFreq, srcVel);
+  Int srcId = addSourceEntry(pksrec.srcName, pksrec.srcDir, pksrec.srcPM,
+    pksrec.restFreq, pksrec.srcVel);
   // Find or add the obsMode to the STATE subtable.
   Int stateId = addStateEntry(obsMode);
+  Int stateId = addStateEntry(pksrec.obsType);
   // FIELD subtable.
+  Int fieldId = addFieldEntry(fieldName, time, direction, scanRate, srcId);
+  //Vector<Double> scanRate(2);
+  //scanRate(0) = pksrec.scanRate(0);
+  //scanRate(1) = pksrec.scanRate(1);
+  Int fieldId = addFieldEntry(pksrec.fieldName, time, pksrec.direction,
+    pksrec.scanRate, srcId);
   // POINTING subtable.
+  addPointingEntry(time, interval, fieldName, direction, scanRate);
+  addPointingEntry(time, pksrec.interval, pksrec.fieldName, pksrec.direction,
+    pksrec.scanRate);
   // SYSCAL subtable.
   addSysCalEntry(beamNo, iIF, time, interval, tcal, tsys, nPol);
+  addSysCalEntry(pksrec.beamNo, iIF, time, pksrec.interval, pksrec.tcal,
+    pksrec.tsys, nPol);
   // Handle weather information.
 …
   Int nWeather = wTime.nrow();
   if (nWeather == 0 || time > wTime(nWeather-1)) {
+    addWeatherEntry(time, interval, pressure, humidity, temperature);
+    addWeatherEntry(time, pksrec.interval, pksrec.pressure, pksrec.humidity,
+      pksrec.temperature);
+  }
 …
   cMSCols->antenna1().put(irow, 0);
   cMSCols->antenna2().put(irow, 0);
   cMSCols->feed1().put(irow, beamNo-1);
   cMSCols->feed2().put(irow, beamNo-1);
+  cMSCols->feed1().put(irow, pksrec.beamNo-1);
+  cMSCols->feed2().put(irow, pksrec.beamNo-1);
   cMSCols->dataDescId().put(irow, iIF);
   cMSCols->processorId().put(irow, 0);
 …
   // Non-key attributes.
   cMSCols->interval().put(irow, interval);
   cMSCols->exposure().put(irow, interval);
+  cMSCols->interval().put(irow, pksrec.interval);
+  cMSCols->exposure().put(irow, pksrec.interval);
   cMSCols->timeCentroid().put(irow, time);
   cMSCols->scanNumber().put(irow, scanNo);
+  cMSCols->scanNumber().put(irow, pksrec.scanNo);
   cMSCols->arrayId().put(irow, 0);
   cMSCols->observationId().put(irow, 0);
 …
   // Baseline fit parameters.
   if (cHaveBase) {
     cBaseLinCol->put(irow, baseLin);
     if (baseSub.nrow() == 9) {
       cBaseSubCol->put(irow, baseSub);
+    cBaseLinCol->put(irow, pksrec.baseLin);
+    if (pksrec.baseSub.nrow() == 24) {
+      cBaseSubCol->put(irow, pksrec.baseSub);
     } else {
       Matrix<Float> tmp(9, 2, 0.0f);
+      Matrix<Float> tmp(24, 2, 0.0f);
       for (Int ipol = 0; ipol < nPol; ipol++) {
         for (uInt j = 0; j < baseSub.nrow(); j++) {
           tmp(j,ipol) = baseSub(j,ipol);
+        for (uInt j = 0; j < pksrec.baseSub.nrow(); j++) {
+          tmp(j,ipol) = pksrec.baseSub(j,ipol);
+        }
+      }
 …
+    }
+  }
   // Transpose spectra.
   Matrix<Float> tmpData(nPol, nChan);
 …
   for (Int ipol = 0; ipol < nPol; ipol++) {
     for (Int ichan = 0; ichan < nChan; ichan++) {
       tmpData(ipol,ichan) = spectra(ichan,ipol);
       tmpFlag(ipol,ichan) = flagged(ichan,ipol);
+      tmpData(ipol,ichan) = pksrec.spectra(ichan,ipol);
+      tmpFlag(ipol,ichan) = pksrec.flagged(ichan,ipol);
+    }
+  }
+  cCalFctrCol->put(irow, calFctr);
+  cCalFctrCol->put(irow, pksrec.calFctr);
   cMSCols->floatData().put(irow, tmpData);
   cMSCols->flag().put(irow, tmpFlag);
 …
   // Cross-polarization spectra.
   if (cHaveXPol(iIF)) {
     cXCalFctrCol->put(irow, xCalFctr);
     cMSCols->data().put(irow, xPol);
+  }
   cMSCols->sigma().put(irow, sigma);
+    cXCalFctrCol->put(irow, pksrec.xCalFctr);
+    cMSCols->data().put(irow, pksrec.xPol);
+  }
+  cMSCols->sigma().put(irow, pksrec.sigma);
   //Vector<Float> weight(1, 1.0f);
 …
   //cMSCols->flag().put(irow, flags.xyPlane(0));
   cMSCols->flagCategory().put(irow, flags);
+  cMSCols->flagRow().put(irow, False);
+  // Row-based flagging info. (True:>0, False:0)
+  cMSCols->flagRow().put(irow, (pksrec.flagrow > 0));
   return 0;
 …
     delete cXCalFctrCol; cXCalFctrCol=0;
+  }
   // Release all subtables.
   cAntenna         = MSAntenna();
 …
   cWeather         = MSWeather();
   // Release the main table.
+  delete cPKSMS; cPKSMS=0;
+  delete cPKSMS;
+  cPKSMS=0x0;
+}
 …
+  }
   else if (cALMA) {
+    // this needs to be changed in future...
     cAntennaCols->station().put(n, "CHAJNANTOR");
+    cAntennaCols->dishDiameter().put(n, 12.0);
+  }
+  else if (cATF) {
+    //pad name for the antenna is static...
+    String stname="unknown";
+    if (antName.contains("DV")) {
+       stname="PAD001";
+    }
+    if (antName.contains("DA")) {
+       stname="PAD002";
+    }
+    cAntennaCols->station().put(n, stname);
     cAntennaCols->dishDiameter().put(n, 12.0);
+  }
 …
 Int PKSMS2writer::addStateEntry(
         const String obsMode)
+        const String obsType)
+{
   // Look for an entry in the STATE subtable.
   for (uInt n = 0; n < cStateCols->nrow(); n++) {
     if (cStateCols->obsMode()(n) == obsMode) {
+    if (cStateCols->obsMode()(n) == obsType) {
       return n;
+    }
 …
   // Data.
   if (obsMode.contains("RF")) {
+  if (obsType.contains("RF")) {
     cStateCols->sig().put(n, False);
     cStateCols->ref().put(n, True);
   } else if (!obsMode.contains("PA")) {
+  } else if (!obsType.contains("PA")) {
     // Signal and reference are both false for "paddle" data.
     cStateCols->sig().put(n, True);
 …
   cStateCols->cal().put(n, 0.0);
   cStateCols->subScan().put(n, 0);
   cStateCols->obsMode().put(n, obsMode);
+  cStateCols->obsMode().put(n, obsType);
   // Flags.

branches/alma/external/atnf/PKSIO/PKSMS2writer.h

-              r1453
+              r1757
 //# PKSMS2writer.h: Class to write Parkes Multibeam data to a measurementset.
 //#---------------------------------------------------------------------------
+//# Copyright (C) 2000-2006
+//# Associated Universities, Inc. Washington DC, USA.
+//#
+//# This library is free software; you can redistribute it and/or modify it
+//# under the terms of the GNU Library General Public License as published by
+//# the Free Software Foundation; either version 2 of the License, or (at your
+//# option) any later version.
+//#
+//# This library is distributed in the hope that it will be useful, but WITHOUT
+//# livedata - processing pipeline for single-dish, multibeam spectral data.
+//# Copyright (C) 2000-2009, Australia Telescope National Facility, CSIRO
+//#
+//# This file is part of livedata.
+//#
+//# livedata is free software: you can redistribute it and/or modify it under
+//# the terms of the GNU General Public License as published by the Free
+//# Software Foundation, either version 3 of the License, or (at your option)
+//# any later version.
+//#
+//# livedata is distributed in the hope that it will be useful, but WITHOUT
 //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
+//# License for more details.
+//#
+//# You should have received a copy of the GNU Library General Public License
+//# along with this library; if not, write to the Free Software Foundation,
+//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
+//#
+//# Correspondence concerning AIPS++ should be addressed as follows:
+//#        Internet email: aips2-request@nrao.edu.
+//#        Postal address: AIPS++ Project Office
+//#                        National Radio Astronomy Observatory
+//#                        520 Edgemont Road
+//#                        Charlottesville, VA 22903-2475 USA
+//#
+//# $Id$
+//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+//# more details.
+//#
+//# You should have received a copy of the GNU General Public License along
+//# with livedata.  If not, see <http://www.gnu.org/licenses/>.
+//#
+//# Correspondence concerning livedata may be directed to:
+//#        Internet email: mcalabre@atnf.csiro.au
+//#        Postal address: Dr. Mark Calabretta
+//#                        Australia Telescope National Facility, CSIRO
+//#                        PO Box 76
+//#                        Epping NSW 1710
+//#                        AUSTRALIA
+//#
+//# http://www.atnf.csiro.au/computing/software/livedata.html
+//# $Id: PKSMS2writer.h,v 19.14 2009-09-29 07:33:38 cal103 Exp $
 //#---------------------------------------------------------------------------
 …
 #define ATNF_PKSMS2WRITER_H
+#include <atnf/PKSIO/PKSrecord.h>
 #include <atnf/PKSIO/PKSwriter.h>
 …
 #include <casa/Arrays/Vector.h>
 #include <casa/BasicSL/Complex.h>
+#include <casa/BasicSL/String.h>
 #include <ms/MeasurementSets/MeasurementSet.h>
 #include <ms/MeasurementSets/MSColumns.h>
+#include <casa/BasicSL/String.h>
+#include <casa/namespace.h>
 // <summary>
 …
 // </summary>
-#include <casa/namespace.h>
 class PKSMS2writer : public PKSwriter
+{
 …
         const Vector<Double> antPosition,
         const String obsMode,
+        const String bunit,
         const Float  equinox,
         const String dopplerFrame,
 …
         const Vector<uInt> nPol,
         const Vector<Bool> haveXPol,
+        const Bool   haveBase,
+        const String fluxUnit);
+        const Bool   haveBase);
     // Write the next data record.
+/**
     virtual Int write(
         const Int             scanNo,
 …
         const Matrix<Float>   &spectra,
         const Matrix<uChar>   &flagged,
+        const uInt            flagrow,
         const Complex         xCalFctr,
         const Vector<Complex> &xPol);
+**/
+    virtual Int write(
+        const PKSrecord &pksrec);
     // Close the MS, flushing all associated Tables.
 …
     // for handling parameters specific to GBT and other telescopes
+    Bool cGBT;
+    Bool cSMT;
+    Bool cAPEX;
+    Bool cALMA;
+    Bool cGBT, cSMT, cAPEX, cALMA, cATF;
     // Add an entry to the ANTENNA subtable.

branches/alma/external/atnf/PKSIO/PKSSDwriter.cc

-              r1453
+              r1757
 //# PKSSDwriter.cc: Class to write Parkes multibeam data to an SDFITS file.
 //#---------------------------------------------------------------------------
+//# Copyright (C) 2000-2006
+//# Associated Universities, Inc. Washington DC, USA.
+//#
+//# This library is free software; you can redistribute it and/or modify it
+//# under the terms of the GNU Library General Public License as published by
+//# the Free Software Foundation; either version 2 of the License, or (at your
+//# option) any later version.
+//#
+//# This library is distributed in the hope that it will be useful, but
+//# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+//# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
+//# License for more details.
+//#
+//# You should have received a copy of the GNU Library General Public License
+//# along with this library; if not, write to the Free Software Foundation,
+//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
+//#
+//# Correspondence concerning AIPS++ should be addressed as follows:
+//#        Internet email: aips2-request@nrao.edu.
+//#        Postal address: AIPS++ Project Office
+//#                        National Radio Astronomy Observatory
+//#                        520 Edgemont Road
+//#                        Charlottesville, VA 22903-2475 USA
+//#
+//# $Id$
+//# livedata - processing pipeline for single-dish, multibeam spectral data.
+//# Copyright (C) 2000-2009, Australia Telescope National Facility, CSIRO
+//#
+//# This file is part of livedata.
+//#
+//# livedata is free software: you can redistribute it and/or modify it under
+//# the terms of the GNU General Public License as published by the Free
+//# Software Foundation, either version 3 of the License, or (at your option)
+//# any later version.
+//#
+//# livedata is distributed in the hope that it will be useful, but WITHOUT
+//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+//# more details.
+//#
+//# You should have received a copy of the GNU General Public License along
+//# with livedata.  If not, see <http://www.gnu.org/licenses/>.
+//#
+//# Correspondence concerning livedata may be directed to:
+//#        Internet email: mcalabre@atnf.csiro.au
+//#        Postal address: Dr. Mark Calabretta
+//#                        Australia Telescope National Facility, CSIRO
+//#                        PO Box 76
+//#                        Epping NSW 1710
+//#                        AUSTRALIA
+//#
+//# http://www.atnf.csiro.au/computing/software/livedata.html
+//# $Id: PKSSDwriter.cc,v 19.17 2009-09-29 07:33:38 cal103 Exp $
 //#---------------------------------------------------------------------------
 #include <atnf/PKSIO/PKSMBrecord.h>
+#include <atnf/PKSIO/MBrecord.h>
 #include <atnf/PKSIO/PKSSDwriter.h>
+#include <casa/Logging/LogIO.h>
+#include <casa/stdio.h>
 #include <casa/Quanta/MVTime.h>
+#include <string>
+#include <cstring>
+// Class name
+const string className = "PKSSDwriter" ;
 //--------------------------------------------------- PKSSDwriter::PKSSDwriter
 …
         const Vector<Double> antPosition,
         const String obsMode,
+        const String bunit,
         const Float  equinox,
         const String dopplerFrame,
 …
         const Vector<uInt> nPol,
         const Vector<Bool> haveXPol,
+        const Bool   haveBase,
+        const String fluxUnit)
+{
+        const Bool   haveBase)
+{
+  const string methodName = "create()" ;
+  LogIO os( LogOrigin( className, methodName, WHERE ) ) ;
   double antPos[3];
   antPos[0] = antPosition(0);
 …
   cNIF = nChan.nelements();
   if (nPol.nelements() != cNIF || haveXPol.nelements() != cNIF) {
+    cerr << "PKSSDwriter::create: "
+         << "Inconsistent number of IFs for nChan, nPol, and/or haveXPol."
+         << endl;
+    os << LogIO::SEVERE << "Inconsistent number of IFs for nChan, nPol, and/or haveXPol." << LogIO::POST ;
     return 1;
+  }
 …
   Int status = cSDwriter.create((char *)sdName.chars(),
         (char *)observer.chars(), (char *)project.chars(),
         (char *)antName.chars(), antPos, (char *)obsMode.chars(), equinox,
         (char *)dopplerFrame.chars(), cNIF,
+        (char *)antName.chars(), antPos, (char *)obsMode.chars(),
+        (char *)bunit.chars(), equinox, (char *)dopplerFrame.chars(), cNIF,
         (int *)cNChan.getStorage(deleteIt),
         (int *)cNPol.getStorage(deleteIt),
         (int *)cHaveXPol.getStorage(deleteIt), (int)cHaveBase, 1);
+  //logMsg(cSDwriter.getMsg());
+  //cSDwriter.clearMsg();
   if (status) {
-    cSDwriter.reportError();
     cSDwriter.deleteFile();
     close();
 …
 Int PKSSDwriter::write(
+        const Int             scanNo,
+        const Int             cycleNo,
+        const Double          mjd,
+        const Double          interval,
+        const String          fieldName,
+        const String          srcName,
+        const Vector<Double>  srcDir,
+        const Vector<Double>  srcPM,
+        const Double          srcVel,
+        const String          obsMode,
+        const Int             IFno,
+        const Double          refFreq,
+        const Double          bandwidth,
+        const Double          freqInc,
+        //const Double          restFreq,
+        const Vector<Double>  restFreq,
+        const Vector<Float>   tcal,
+        const String          tcalTime,
+        const Float           azimuth,
+        const Float           elevation,
+        const Float           parAngle,
+        const Float           focusAxi,
+        const Float           focusTan,
+        const Float           focusRot,
+        const Float           temperature,
+        const Float           pressure,
+        const Float           humidity,
+        const Float           windSpeed,
+        const Float           windAz,
+        const Int             refBeam,
+        const Int             beamNo,
+        const Vector<Double>  direction,
+        const Vector<Double>  scanRate,
+        const Vector<Float>   tsys,
+        const Vector<Float>   sigma,
+        const Vector<Float>   calFctr,
+        const Matrix<Float>   baseLin,
+        const Matrix<Float>   baseSub,
+        const Matrix<Float>   &spectra,
+        const Matrix<uChar>   &flagged,
+        const Complex         xCalFctr,
+        const Vector<Complex> &xPol)
+{
+        const PKSrecord &pksrec)
+{
+  const string methodName = "write()" ;
+  LogIO os( LogOrigin( className, methodName, WHERE ) ) ;
   // Do basic checks.
+  Int IFno = pksrec.IFno;
   uInt iIF = IFno - 1;
   if (IFno < 1 || Int(cNIF) < IFno) {
     cerr << "PKSDwriter::write: "
          << "Invalid IF number " << IFno
          << " (maximum " << cNIF << ")." << endl;
+    os << LogIO::SEVERE
+       << "Invalid IF number " << IFno
+       << " (maximum " << cNIF << ")." << LogIO::POST ;
     return 1;
+  }
   uInt nChan = spectra.nrow();
+  uInt nChan = pksrec.spectra.nrow();
   if (nChan != cNChan(iIF)) {
+    cerr << "PKSDwriter::write: "
+         << "Wrong number of channels for IF " << IFno << "," << endl
+         << "                   "
+    os << LogIO::SEVERE << "Wrong number of channels for IF " << IFno << "," << endl
          << "got " << nChan << " should be " << cNChan(iIF) << "." << endl;
+    os << LogIO::POST ;
     return 1;
+  }
   uInt nPol = spectra.ncolumn();
+  uInt nPol = pksrec.spectra.ncolumn();
   if (nPol != cNPol(iIF)) {
+    cerr << "PKSDwriter::write: "
+         << "Wrong number of polarizations for IF " << IFno << "," << endl
+         << "                   "
+         << "got " << nPol << " should be " << cNPol(iIF) << "." << endl;
+    os << LogIO::SEVERE << "Wrong number of polarizations for IF " << IFno << "," << endl
+       << "got " << nPol << " should be " << cNPol(iIF) << "." << endl;
+    os << LogIO::POST ;
     return 1;
+  }
   // Extract calendar information from mjd.
   MVTime time(mjd);
+  // Extract calendar information frrom mjd.
+  MVTime time(pksrec.mjd);
   Int year  = time.year();
   Int month = time.month();
   Int day   = time.monthday();
   // Transfer data to a single-IF PKSMBrecord.
   PKSMBrecord mbrec(1);
+  // Transfer data to a single-IF MBrecord.
+  MBrecord mbrec(1);
   // Start with basic beam- and IF-independent bookkeeping information.
   mbrec.scanNo  = scanNo;
   mbrec.cycleNo = cycleNo;
+  mbrec.scanNo  = pksrec.scanNo;
+  mbrec.cycleNo = pksrec.cycleNo;
   sprintf(mbrec.datobs, "%4.4d-%2.2d-%2.2d", year, month, day);
+  mbrec.utc      = fmod(mjd, 1.0) * 86400.0;
+  mbrec.exposure = float(interval);
+  strncpy(mbrec.srcName, (char *)srcName.chars(), 17);
+  mbrec.srcRA    = srcDir(0);
+  mbrec.srcDec   = srcDir(1);
+  //mbrec.restFreq = restFreq;
+  mbrec.restFreq = restFreq(0);
+  strncpy(mbrec.obsType, (char *)obsMode.chars(), 16);
+  mbrec.utc      = fmod(pksrec.mjd, 1.0) * 86400.0;
+  mbrec.exposure = float(pksrec.interval);
+  strncpy(mbrec.srcName, (char *)pksrec.srcName.chars(), 17);
+  mbrec.srcRA    = pksrec.srcDir(0);
+  mbrec.srcDec   = pksrec.srcDir(1);
+  if (pksrec.restFreq.shape()==0) {
+     mbrec.restFreq = 0;
+  }
+  else {
+     mbrec.restFreq = pksrec.restFreq(0);
+  }
+  strncpy(mbrec.obsType, (char *)pksrec.obsType.chars(), 16);
   // Now beam-dependent parameters.
   mbrec.beamNo   = beamNo;
   mbrec.ra       = direction(0);
   mbrec.dec      = direction(1);
   mbrec.raRate   = scanRate(0);
   mbrec.decRate  = scanRate(1);
+  mbrec.beamNo   = pksrec.beamNo;
+  mbrec.ra       = pksrec.direction(0);
+  mbrec.dec      = pksrec.direction(1);
+  mbrec.raRate   = pksrec.scanRate(0);
+  mbrec.decRate  = pksrec.scanRate(1);
   // Now IF-dependent parameters.
 …
   mbrec.fqRefPix[0] = (nChan/2) + 1;
   mbrec.fqRefVal[0] = refFreq;
   mbrec.fqDelt[0]   = freqInc;
+  mbrec.fqRefVal[0] = pksrec.refFreq;
+  mbrec.fqDelt[0]   = pksrec.freqInc;
   // Now the data itself.
   for (uInt i = 0; i < tsys.nelements(); i++) {
     mbrec.tsys[0][i] = tsys(i);
+  for (uInt i = 0; i < pksrec.tsys.nelements(); i++) {
+    mbrec.tsys[0][i] = pksrec.tsys(i);
+  }
   for (uInt ipol = 0; ipol < nPol; ipol++) {
     mbrec.calfctr[0][ipol] = calFctr(ipol);
+    mbrec.calfctr[0][ipol] = pksrec.calFctr(ipol);
+  }
   if (cHaveXPol(iIF)) {
     mbrec.xcalfctr[0][0] = xCalFctr.real();
     mbrec.xcalfctr[0][1] = xCalFctr.imag();
+    mbrec.xcalfctr[0][0] = pksrec.xCalFctr.real();
+    mbrec.xcalfctr[0][1] = pksrec.xCalFctr.imag();
   } else {
     mbrec.xcalfctr[0][0] = 0.0f;
 …
     for (uInt ipol = 0; ipol < nPol; ipol++) {
       mbrec.baseLin[0][ipol][0] = baseLin(0,ipol);
       mbrec.baseLin[0][ipol][1] = baseLin(1,ipol);
       for (uInt j = 0; j < baseSub.nrow(); j++) {
         mbrec.baseSub[0][ipol][j] = baseSub(j,ipol);
+      mbrec.baseLin[0][ipol][0] = pksrec.baseLin(0,ipol);
+      mbrec.baseLin[0][ipol][1] = pksrec.baseLin(1,ipol);
+      for (uInt j = 0; j < pksrec.baseSub.nrow(); j++) {
+        mbrec.baseSub[0][ipol][j] = pksrec.baseSub(j,ipol);
+      }
       for (uInt j = baseSub.nrow(); j < 9; j++) {
+      for (uInt j = pksrec.baseSub.nrow(); j < 24; j++) {
         mbrec.baseSub[0][ipol][j] = 0.0f;
+      }
 …
   Bool delSpectra = False;
   const Float *specstor = spectra.getStorage(delSpectra);
+  const Float *specstor = pksrec.spectra.getStorage(delSpectra);
   mbrec.spectra[0] = (float *)specstor;
   Bool delFlagged = False;
   const uChar *flagstor = flagged.getStorage(delFlagged);
+  const uChar *flagstor = pksrec.flagged.getStorage(delFlagged);
   mbrec.flagged[0] = (unsigned char *)flagstor;
 …
   const Complex *xpolstor;
   if (cHaveXPol(iIF)) {
     xpolstor = xPol.getStorage(delXPol);
+    xpolstor = pksrec.xPol.getStorage(delXPol);
   } else {
     xpolstor = 0;
 …
   // Finish off with system calibration parameters.
   mbrec.extraSysCal = 1;
   mbrec.refBeam     = refBeam;
   for (uInt i = 0; i < tcal.nelements(); i++) {
     mbrec.tcal[0][i] = tcal(i);
+  }
   strncpy(mbrec.tcalTime, (char *)tcalTime.chars(), 16);
   mbrec.azimuth   = azimuth;
   mbrec.elevation = elevation;
   mbrec.parAngle  = parAngle;
   mbrec.focusAxi  = focusAxi;
   mbrec.focusTan  = focusTan;
   mbrec.focusRot  = focusRot;
   mbrec.temp      = temperature;
   mbrec.pressure  = pressure;
   mbrec.humidity  = humidity;
   mbrec.windSpeed = windSpeed;
   mbrec.windAz    = windAz;
+  mbrec.refBeam     = pksrec.refBeam;
+  for (uInt i = 0; i < pksrec.tcal.nelements(); i++) {
+    mbrec.tcal[0][i] = pksrec.tcal(i);
+  }
+  strncpy(mbrec.tcalTime, (char *)pksrec.tcalTime.chars(), 16);
+  mbrec.azimuth   = pksrec.azimuth;
+  mbrec.elevation = pksrec.elevation;
+  mbrec.parAngle  = pksrec.parAngle;
+  mbrec.focusAxi  = pksrec.focusAxi;
+  mbrec.focusTan  = pksrec.focusTan;
+  mbrec.focusRot  = pksrec.focusRot;
+  mbrec.temp      = pksrec.temperature;
+  mbrec.pressure  = pksrec.pressure;
+  mbrec.humidity  = pksrec.humidity;
+  mbrec.windSpeed = pksrec.windSpeed;
+  mbrec.windAz    = pksrec.windAz;
   Int status = cSDwriter.write(mbrec);
+  //logMsg(cSDwriter.getMsg());
+  //cSDwriter.clearMsg();
   if (status) {
-    cSDwriter.reportError();
     status = 1;
+  }
   spectra.freeStorage(specstor, delSpectra);
   flagged.freeStorage(flagstor, delFlagged);
   xPol.freeStorage(xpolstor, delXPol);
+  pksrec.spectra.freeStorage(specstor, delSpectra);
+  pksrec.flagged.freeStorage(flagstor, delFlagged);
+  pksrec.xPol.freeStorage(xpolstor, delXPol);
   return status;
+}
+//------------------------------------------------------- PKSSDwriter::history
+// Write a history record.
+Int PKSSDwriter::history(const String text)
+{
+  return cSDwriter.history((char *)text.chars());
+}
+Int PKSSDwriter::history(const char *text)
+{
+  return cSDwriter.history((char *)text);
+}
 //--------------------------------------------------------- PKSSDwriter::close
 …
+{
   cSDwriter.close();
+}
+  //logMsg(cSDwriter.getMsg());
+  //cSDwriter.clearMsg();
+}

branches/alma/external/atnf/PKSIO/PKSSDwriter.h

-              r1453
+              r1757
 //#---------------------------------------------------------------------------
 //# PKSSDWriter.h: Class to write Parkes multibeam data to an SDFITS file.
+//# PKSSDwriter.h: Class to write Parkes multibeam data to an SDFITS file.
 //#---------------------------------------------------------------------------
 //# Copyright (C) 2000-2006
 //# Associated Universities, Inc. Washington DC, USA.
+//# livedata - processing pipeline for single-dish, multibeam spectral data.
+//# Copyright (C) 2000-2009, Australia Telescope National Facility, CSIRO
 //#
+//# This library is free software; you can redistribute it and/or modify it
+//# under the terms of the GNU Library General Public License as published by
+//# the Free Software Foundation; either version 2 of the License, or (at your
+//# option) any later version.
+//# This file is part of livedata.
 //#
+//# This library is distributed in the hope that it will be useful, but WITHOUT
+//# livedata is free software: you can redistribute it and/or modify it under
+//# the terms of the GNU General Public License as published by the Free
+//# Software Foundation, either version 3 of the License, or (at your option)
+//# any later version.
+//#
+//# livedata is distributed in the hope that it will be useful, but WITHOUT
 //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 //# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
 //# License for more details.
+//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+//# more details.
 //#
+//# You should have received a copy of the GNU Library General Public License
+//# along with this library; if not, write to the Free Software Foundation,
+//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
+//# You should have received a copy of the GNU General Public License along
+//# with livedata.  If not, see <http://www.gnu.org/licenses/>.
 //#
+//# Correspondence concerning AIPS++ should be addressed as follows:
+//#        Internet email: aips2-request@nrao.edu.
+//#        Postal address: AIPS++ Project Office
+//#                        National Radio Astronomy Observatory
+//#                        520 Edgemont Road
+//#                        Charlottesville, VA 22903-2475 USA
+//# Correspondence concerning livedata may be directed to:
+//#        Internet email: mcalabre@atnf.csiro.au
+//#        Postal address: Dr. Mark Calabretta
+//#                        Australia Telescope National Facility, CSIRO
+//#                        PO Box 76
+//#                        Epping NSW 1710
+//#                        AUSTRALIA
 //#
+//# $Id$
+//# http://www.atnf.csiro.au/computing/software/livedata.html
+//# $Id: PKSSDwriter.h,v 19.17 2009-09-29 07:33:38 cal103 Exp $
 //# Original: 2000/07/21, Mark Calabretta, ATNF
 //#---------------------------------------------------------------------------
 …
 #include <atnf/PKSIO/PKSwriter.h>
+#include <atnf/PKSIO/PKSrecord.h>
 #include <atnf/PKSIO/SDFITSwriter.h>
 #include <casa/aips.h>
+#include <casa/stdio.h>
 #include <casa/Arrays/Vector.h>
 #include <casa/Arrays/Matrix.h>
 …
 #include <casa/BasicSL/String.h>
+#include <casa/namespace.h>
 // <summary>
 // Class to write Parkes multibeam data to an SDFITS file.
 // </summary>
-#include <casa/namespace.h>
 class PKSSDwriter : public PKSwriter
+{
 …
         const Vector<Double> antPosition,
         const String obsMode,
+        const String bunit,
         const Float  equinox,
         const String dopplerFrame,
 …
         const Vector<uInt> nPol,
         const Vector<Bool> haveXPol,
+        const Bool   haveBase,
+        const String fluxUnit);
+        const Bool   haveBase);
     // Write the next data record.
     virtual Int write(
+        const Int             scanNo,
+        const Int             cycleNo,
+        const Double          mjd,
+        const Double          interval,
+        const String          fieldName,
+        const String          srcName,
+        const Vector<Double>  srcDir,
+        const Vector<Double>  srcPM,
+        const Double          srcVel,
+        const String          obsMode,
+        const Int             IFno,
+        const Double          refFreq,
+        const Double          bandwidth,
+        const Double          freqInc,
+        //const Double          restFreq,
+        const Vector<Double>  restFreq,
+        const Vector<Float>   tcal,
+        const String          tcalTime,
+        const Float           azimuth,
+        const Float           elevation,
+        const Float           parAngle,
+        const Float           focusAxi,
+        const Float           focusTan,
+        const Float           focusRot,
+        const Float           temperature,
+        const Float           pressure,
+        const Float           humidity,
+        const Float           windSpeed,
+        const Float           windAz,
+        const Int             refBeam,
+        const Int             beamNo,
+        const Vector<Double>  direction,
+        const Vector<Double>  scanRate,
+        const Vector<Float>   tsys,
+        const Vector<Float>   sigma,
+        const Vector<Float>   calFctr,
+        const Matrix<Float>   baselin,
+        const Matrix<Float>   basesub,
+        const Matrix<Float>   &spectra,
+        const Matrix<uChar>   &flagged,
+        const Complex         xCalFctr,
+        const Vector<Complex> &xPol);
+        const PKSrecord &pksrec);
+    // Write a history record.
+    virtual Int history(const String text);
+    virtual Int history(const char *text);
     // Close the SDFITS file.

branches/alma/external/atnf/PKSIO/PKSreader.cc

-              r1453
+              r1757
 //# PKSreader.cc: Class to read Parkes multibeam data.
 //#---------------------------------------------------------------------------
+//# Copyright (C) 2000-2006
+//# Associated Universities, Inc. Washington DC, USA.
+//#
+//# This library is free software; you can redistribute it and/or modify it
+//# under the terms of the GNU Library General Public License as published by
+//# the Free Software Foundation; either version 2 of the License, or (at your
+//# option) any later version.
+//#
+//# This library is distributed in the hope that it will be useful, but WITHOUT
+//# livedata - processing pipeline for single-dish, multibeam spectral data.
+//# Copyright (C) 2000-2009, Australia Telescope National Facility, CSIRO
+//#
+//# This file is part of livedata.
+//#
+//# livedata is free software: you can redistribute it and/or modify it under
+//# the terms of the GNU General Public License as published by the Free
+//# Software Foundation, either version 3 of the License, or (at your option)
+//# any later version.
+//#
+//# livedata is distributed in the hope that it will be useful, but WITHOUT
 //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
+//# License for more details.
+//#
+//# You should have received a copy of the GNU Library General Public License
+//# along with this library; if not, write to the Free Software Foundation,
+//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
+//#
+//# Correspondence concerning AIPS++ should be addressed as follows:
+//#        Internet email: aips2-request@nrao.edu.
+//#        Postal address: AIPS++ Project Office
+//#                        National Radio Astronomy Observatory
+//#                        520 Edgemont Road
+//#                        Charlottesville, VA 22903-2475 USA
+//#
+//# $Id$
+//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+//# more details.
+//#
+//# You should have received a copy of the GNU General Public License along
+//# with livedata.  If not, see <http://www.gnu.org/licenses/>.
+//#
+//# Correspondence concerning livedata may be directed to:
+//#        Internet email: mcalabre@atnf.csiro.au
+//#        Postal address: Dr. Mark Calabretta
+//#                        Australia Telescope National Facility, CSIRO
+//#                        PO Box 76
+//#                        Epping NSW 1710
+//#                        AUSTRALIA
+//#
+//# http://www.atnf.csiro.au/computing/software/livedata.html
+//# $Id: PKSreader.cc,v 19.13 2009-09-29 07:33:39 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# Original: 2000/08/23, Mark Calabretta, ATNF
 …
 #include <casa/OS/File.h>
 //--------------------------------------------------------------- getPKSreader
 …
         const Int retry,
         const Int interpolate,
+        String &format,
+        Vector<Bool> &beams,
+        Vector<Bool> &IFs,
+        Vector<uInt> &nChan,
+        Vector<uInt> &nPol,
+        Vector<Bool> &haveXPol,
+        Bool   &haveBase,
+        Bool   &haveSpectra)
+        String &format)
+{
   // Check accessibility of the input.
 …
   if (!inFile.exists()) {
     format = "DATASET NOT FOUND";
     return 0;
+    return 0x0;
+  }
   if (!inFile.isReadable()) {
     format = "DATASET UNREADABLE";
     return 0;
+    return 0x0;
+  }
   // Determine the type of input.
   PKSreader *reader = 0;
+  PKSreader *reader = 0x0;
   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);
+       }
+    }
 …
     format = "UNRECOGNIZED INPUT FORMAT";
+  }
+  return reader;
+}
+//--------------------------------------------------------------- getPKSreader
+// Search a list of directories for a Parkes Multibeam dataset and return an
+PKSreader* getPKSreader(
+        const String name,
+        const Vector<String> directories,
+        const Int retry,
+        const Int interpolate,
+        Int    &iDir,
+        String &format)
+{
+  PKSreader *reader = 0x0;
+  iDir = -1;
+  Int nDir = directories.nelements();
+  for (Int i = 0; i < nDir; i++) {
+    String inName = directories(i) + "/" + name;
+    reader = getPKSreader(inName, retry, interpolate, format);
+    if (reader) {
+      iDir = i;
+      break;
+    }
+  }
+  return reader;
+}
+//--------------------------------------------------------------- getPKSreader
+// Open an appropriate PKSreader for a Parkes Multibeam dataset.
+PKSreader* getPKSreader(
+        const String name,
+        const String antenna,
+        const Int retry,
+        const Int interpolate,
+        String &format,
+        Vector<Bool> &beams,
+        Vector<Bool> &IFs,
+        Vector<uInt> &nChan,
+        Vector<uInt> &nPol,
+        Vector<Bool> &haveXPol,
+        Bool   &haveBase,
+        Bool   &haveSpectra)
+{
+  PKSreader *reader = getPKSreader(name, retry, interpolate, format);
   // Try to open it.
   if (reader) {
     if (reader->open(name, beams, IFs, nChan, nPol, haveXPol, haveBase,
                      haveSpectra)) {
+    if (reader->open(name, antenna, beams, IFs, nChan, nPol, haveXPol,
+                     haveBase, haveSpectra)) {
       format += " OPEN ERROR";
       delete reader;
+    } else {
+      return reader;
+    }
+  }
+  return 0;
+}
+      reader = 0x0;
+    }
+  }
+  return reader;
+}
 //--------------------------------------------------------------- getPKSreader
 …
 // Search a list of directories for a Parkes Multibeam dataset and return an
 // appropriate PKSreader for it.
+PKSreader* getPKSreader(
         const String name,
+PKSreader* getPKSreader(
+        const String name,
+        const String antenna,
         const Vector<String> directories,
         const Int retry,
 …
         Bool   &haveSpectra)
+{
+  Int nDir = directories.nelements();
+  for (iDir = 0; iDir < nDir; iDir++) {
+    String inName = directories(iDir) + "/" + name;
+    PKSreader *reader = getPKSreader(inName, retry, interpolate, format,
+                                     beams, IFs, nChan, nPol, haveXPol,
+                                     haveBase, haveSpectra);
+    if (reader != 0) {
+      return reader;
+    }
+  }
+  iDir = -1;
+  return 0;
+}
+  PKSreader *reader = getPKSreader(name, directories, retry, interpolate,
+                                   iDir, format);
+  // Try to open it.
+  if (reader) {
+    if (reader->open(name, antenna, beams, IFs, nChan, nPol, haveXPol,
+                     haveBase, haveSpectra)) {
+      format += " OPEN ERROR";
+      delete reader;
+      reader = 0x0;
+    }
+  }
+  return reader;
+}

branches/alma/external/atnf/PKSIO/PKSreader.h

-              r1453
+              r1757
 //# PKSreader.h: Class to read Parkes multibeam data.
 //#---------------------------------------------------------------------------
+//# Copyright (C) 2000-2006
+//# Associated Universities, Inc. Washington DC, USA.
+//#
+//# This library is free software; you can redistribute it and/or modify it
+//# under the terms of the GNU Library General Public License as published by
+//# the Free Software Foundation; either version 2 of the License, or (at your
+//# option) any later version.
+//#
+//# This library is distributed in the hope that it will be useful, but WITHOUT
+//# livedata - processing pipeline for single-dish, multibeam spectral data.
+//# Copyright (C) 2000-2009, Australia Telescope National Facility, CSIRO
+//#
+//# This file is part of livedata.
+//#
+//# livedata is free software: you can redistribute it and/or modify it under
+//# the terms of the GNU General Public License as published by the Free
+//# Software Foundation, either version 3 of the License, or (at your option)
+//# any later version.
+//#
+//# livedata is distributed in the hope that it will be useful, but WITHOUT
 //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
+//# License for more details.
+//#
+//# You should have received a copy of the GNU Library General Public License
+//# along with this library; if not, write to the Free Software Foundation,
+//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
+//#
+//# Correspondence concerning AIPS++ should be addressed as follows:
+//#        Internet email: aips2-request@nrao.edu.
+//#        Postal address: AIPS++ Project Office
+//#                        National Radio Astronomy Observatory
+//#                        520 Edgemont Road
+//#                        Charlottesville, VA 22903-2475 USA
+//#
+//# $Id$
+//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+//# more details.
+//#
+//# You should have received a copy of the GNU General Public License along
+//# with livedata.  If not, see <http://www.gnu.org/licenses/>.
+//#
+//# Correspondence concerning livedata may be directed to:
+//#        Internet email: mcalabre@atnf.csiro.au
+//#        Postal address: Dr. Mark Calabretta
+//#                        Australia Telescope National Facility, CSIRO
+//#                        PO Box 76
+//#                        Epping NSW 1710
+//#                        AUSTRALIA
+//#
+//# http://www.atnf.csiro.au/computing/software/livedata.html
+//# $Id: PKSreader.h,v 19.24 2009-09-29 07:33:39 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# Original: 2000/08/02, Mark Calabretta, ATNF
 …
 #ifndef ATNF_PKSREADER_H
 #define ATNF_PKSREADER_H
+#include <atnf/PKSIO/PKSrecord.h>
+#include <atnf/PKSIO/SrcType.h>
 #include <casa/aips.h>
 …
 #include <casa/BasicSL/String.h>
+#include <casa/namespace.h>
 // <summary>
 // Class to read Parkes multibeam data.
 // </summary>
+#include <casa/namespace.h>
+// Return an appropriate PKSreader for a Parkes Multibeam dataset.
+class PKSreader* getPKSreader(
+        const String name,
+        const Int retry,
+        const Int interpolate,
+        String &format);
+// As above, but search a list of directories for it.
+class PKSreader* getPKSreader(
+        const String name,
+        const Vector<String> directories,
+        const Int retry,
+        const Int interpolate,
+        Int    &iDir,
+        String &format);
 // Open an appropriate PKSreader for a Parkes Multibeam dataset.
 class PKSreader* getPKSreader(
         const String name,
+        const String antenna,
         const Int retry,
         const Int interpolate,
 …
 class PKSreader* getPKSreader(
         const String name,
+        const String antenna,
         const Vector<String> directories,
         const Int retry,
 …
     virtual Int open(
         const String inName,
+        const String antenna,
         Vector<Bool> &beams,
         Vector<Bool> &IFs,
 …
         Vector<Double> &antPosition,
         String &obsType,
+        String &bunit,
         Float  &equinox,
         String &dopplerFrame,
         Double &mjd,
         Double &refFreq,
+        Double &bandwidth,
+        String &fluxunit) = 0;
+        Double &bandwidth) = 0;
     // Get frequency parameters for each IF.
 …
     // Set data selection criteria.  Channel numbering is 1-relative, zero or
     // negative channel numbers are taken to be offsets from the last channel.
+    // Coordinate system selection (only supported for SDFITS input):
+    //   0: equatorial (RA,Dec),
+    //   1: horizontal (Az,El),
+    //   2: feed-plane,
+    //   3: zenithal position angle of feed and elevation, (ZPA,El).
     virtual uInt select(
         const Vector<Bool> beamSel,
 …
         const Bool getSpectra = True,
         const Bool getXPol    = False,
+        const Bool getFeedPos = False) = 0;
+        const Bool getFeedPos = False,
+        const Bool getPointing = False,
+        const Int  coordSys   = 0) = 0;
     // Find the range of the data selected in time and position.
 …
         Matrix<Double> &positions) = 0;
+    // Read the next data record.
+    // Read the next data record.
+/**
     virtual Int read(
         Int             &scanNo,
 …
         Complex         &xCalFctr,
         Vector<Complex> &xPol) = 0;
+**/
+/**
     // Read the next data record, just the basics.
     virtual Int read(
 …
         Matrix<Float> &spectra,
         Matrix<uChar> &flagged) = 0;
+**/
+    virtual Int read(PKSrecord &pksrec) = 0;
     // Close the input file.
 …
   protected:
+    Bool   cGetFeedPos, cGetSpectra, cGetXPol;
+    Bool   cGetFeedPos, cGetSpectra, cGetXPol, cGetPointing;
+    Int   cCoordSys;
     Vector<uInt> cNChan, cNPol;

branches/alma/external/atnf/PKSIO/PKSrecord.h

-              r1752
+              r1757
     Double          bandwidth;
     Double          freqInc;
+    Double          restFreq;
+    Int             nchan;
+    Vector<Double>  restFreq;
     Vector<Float>   tcal;
     String          tcalTime;
 …
     Int             pCode;
     Float           rateAge;
     Vector<Float>   scanRate;
+    Vector<Double>  scanRate;
     Float           paRate;
     Vector<Float>   tsys;
 …
     Matrix<Float>   spectra;
     Matrix<uChar>   flagged;
+    uInt            flagrow;
     Complex         xCalFctr;
     Vector<Complex> xPol;
+    Int             polNo ;
+    Int             srcType ;
 };

branches/alma/external/atnf/PKSIO/PKSwriter.h

-              r1453
+              r1757
 //# PKSwriter.h: Class to write out Parkes multibeam data.
 //#---------------------------------------------------------------------------
 //# Copyright (C) 2000-2006
 //# Associated Universities, Inc. Washington DC, USA.
+//# livedata - processing pipeline for single-dish, multibeam spectral data.
+//# Copyright (C) 2000-2009, Australia Telescope National Facility, CSIRO
 //#
+//# This library is free software; you can redistribute it and/or modify it
+//# under the terms of the GNU Library General Public License as published by
+//# the Free Software Foundation; either version 2 of the License, or (at your
+//# option) any later version.
+//# This file is part of livedata.
 //#
+//# This library is distributed in the hope that it will be useful, but WITHOUT
+//# livedata is free software: you can redistribute it and/or modify it under
+//# the terms of the GNU General Public License as published by the Free
+//# Software Foundation, either version 3 of the License, or (at your option)
+//# any later version.
+//#
+//# livedata is distributed in the hope that it will be useful, but WITHOUT
 //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 //# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
 //# License for more details.
+//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+//# more details.
 //#
+//# You should have received a copy of the GNU Library General Public License
+//# along with this library; if not, write to the Free Software Foundation,
+//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
+//# You should have received a copy of the GNU General Public License along
+//# with livedata.  If not, see <http://www.gnu.org/licenses/>.
 //#
+//# Correspondence concerning AIPS++ should be addressed as follows:
+//#        Internet email: aips2-request@nrao.edu.
+//#        Postal address: AIPS++ Project Office
+//#                        National Radio Astronomy Observatory
+//#                        520 Edgemont Road
+//#                        Charlottesville, VA 22903-2475 USA
+//# Correspondence concerning livedata may be directed to:
+//#        Internet email: mcalabre@atnf.csiro.au
+//#        Postal address: Dr. Mark Calabretta
+//#                        Australia Telescope National Facility, CSIRO
+//#                        PO Box 76
+//#                        Epping NSW 1710
+//#                        AUSTRALIA
 //#
+//# $Id$
+//# http://www.atnf.csiro.au/computing/software/livedata.html
+//# $Id: PKSwriter.h,v 19.17 2009-09-29 07:33:39 cal103 Exp $
 //#---------------------------------------------------------------------------
 #ifndef ATNF_PKSWRITER_H
 #define ATNF_PKSWRITER_H
+#include <atnf/PKSIO/PKSrecord.h>
 #include <casa/aips.h>
 …
 #include <casa/BasicSL/String.h>
+#include <casa/namespace.h>
 // <summary>
 // Class to write out Parkes multibeam data.
 // </summary>
-#include <casa/namespace.h>
 class PKSwriter
+{
 …
         const Vector<Double> antPosition,
         const String obsMode,
+        const String bunit,
         const Float  equinox,
         const String dopplerFrame,
 …
         const Vector<uInt> nPol,
         const Vector<Bool> haveXPol,
+        const Bool havebase,
+        const String fluxUnit) = 0;
+        const Bool havebase) = 0;
     // Write the next data record.
     virtual Int write (
+        const Int             scanNo,
+        const Int             cycleNo,
+        const Double          mjd,
+        const Double          interval,
+        const String          fieldName,
+        const String          srcName,
+        const Vector<Double>  srcDir,
+        const Vector<Double>  srcPM,
+        const Double          srcVel,
+        const String          obsMode,
+        const Int             IFno,
+        const Double          refFreq,
+        const Double          bandwidth,
+        const Double          freqInc,
+        //const Double          restFreq,
+        const Vector<Double>  restFreq,
+        const Vector<Float>   tcal,
+        const String          tcalTime,
+        const Float           azimuth,
+        const Float           elevation,
+        const Float           parAngle,
+        const Float           focusAxi,
+        const Float           focusTan,
+        const Float           focusRot,
+        const Float           temperature,
+        const Float           pressure,
+        const Float           humidity,
+        const Float           windSpeed,
+        const Float           windAz,
+        const Int             refBeam,
+        const Int             beamNo,
+        const Vector<Double>  direction,
+        const Vector<Double>  scanRate,
+        const Vector<Float>   tsys,
+        const Vector<Float>   sigma,
+        const Vector<Float>   calFctr,
+        const Matrix<Float>   baseLin,
+        const Matrix<Float>   baseSub,
+        const Matrix<Float>   &spectra,
+        const Matrix<uChar>   &flagged,
+        const Complex         xCalFctr,
+        const Vector<Complex> &xPol) = 0;
+        const PKSrecord &pksrec) = 0;
+    // Write a history record.
+    virtual Int history(const String text) {return 0;};
+    virtual Int history(const char *text)  {return 0;};
     // Close the output file.

branches/alma/external/atnf/PKSIO/SDFITSreader.cc

-              r1453
+              r1757
 //#---------------------------------------------------------------------------
 //# SDFITSreader.cc: ATNF CFITSIO interface class for SDFITS input.
+//# SDFITSreader.cc: ATNF interface class for SDFITS input using CFITSIO.
 //#---------------------------------------------------------------------------
 //# Copyright (C) 2000-2006
 //# Associated Universities, Inc. Washington DC, USA.
+//# livedata - processing pipeline for single-dish, multibeam spectral data.
+//# Copyright (C) 2000-2009, Australia Telescope National Facility, CSIRO
 //#
+//# This library is free software; you can redistribute it and/or modify it
+//# under the terms of the GNU Library General Public License as published by
+//# the Free Software Foundation; either version 2 of the License, or (at your
+//# option) any later version.
+//# This file is part of livedata.
 //#
+//# This library is distributed in the hope that it will be useful, but WITHOUT
+//# livedata is free software: you can redistribute it and/or modify it under
+//# the terms of the GNU General Public License as published by the Free
+//# Software Foundation, either version 3 of the License, or (at your option)
+//# any later version.
+//#
+//# livedata is distributed in the hope that it will be useful, but WITHOUT
 //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 //# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
 //# License for more details.
+//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+//# more details.
 //#
+//# You should have received a copy of the GNU Library General Public License
+//# along with this library; if not, write to the Free Software Foundation,
+//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
+//# You should have received a copy of the GNU General Public License along
+//# with livedata.  If not, see <http://www.gnu.org/licenses/>.
 //#
+//# Correspondence concerning this software should be addressed as follows:
+//#        Internet email: aips2-request@nrao.edu.
+//#        Postal address: AIPS++ Project Office
+//#                        National Radio Astronomy Observatory
+//#                        520 Edgemont Road
+//#                        Charlottesville, VA 22903-2475 USA
+//# Correspondence concerning livedata may be directed to:
+//#        Internet email: mcalabre@atnf.csiro.au
+//#        Postal address: Dr. Mark Calabretta
+//#                        Australia Telescope National Facility, CSIRO
+//#                        PO Box 76
+//#                        Epping NSW 1710
+//#                        AUSTRALIA
 //#
+//# $Id$
+//# http://www.atnf.csiro.au/computing/software/livedata.html
+//# $Id: SDFITSreader.cc,v 19.45 2009-09-30 07:23:48 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# The SDFITSreader class reads single dish FITS files such as those written
 …
 //#---------------------------------------------------------------------------
+#include <atnf/pks/pks_maths.h>
+#include <atnf/PKSIO/MBrecord.h>
+#include <atnf/PKSIO/SDFITSreader.h>
+#include <casa/Logging/LogIO.h>
+#include <casa/Quanta/MVTime.h>
+#include <casa/math.h>
+#include <casa/stdio.h>
 #include <algorithm>
 #include <strings.h>
+// AIPS++ includes.
+#include <casa/iostream.h>
+#include <casa/math.h>
+#include <casa/stdio.h>
+// ATNF includes.
+#include <atnf/pks/pks_maths.h>
+#include <atnf/PKSIO/PKSMBrecord.h>
+#include <atnf/PKSIO/SDFITSreader.h>
+#include <cstring>
 class FITSparm
 …
     long nelem;         // Column data repeat count; < 0 for vardim.
     int  tdimcol;       // TDIM column number; 0 for keyword; -1 absent.
+    char units[32];     // Units from TUNITn keyword.
 };
 …
 // Factor to convert radians to degrees.
 const double D2R = PI / 180.0;
+// Class name
+const string className = "SDFITSreader" ;
+//---------------------------------------------------- SDFITSreader::(statics)
+int SDFITSreader::sInit  = 1;
+int SDFITSreader::sReset = 0;
+int (*SDFITSreader::sALFAcalNon)[2]   = (int (*)[2])(new float[16]);
+int (*SDFITSreader::sALFAcalNoff)[2]  = (int (*)[2])(new float[16]);
+float (*SDFITSreader::sALFAcalOn)[2]  = (float (*)[2])(new float[16]);
+float (*SDFITSreader::sALFAcalOff)[2] = (float (*)[2])(new float[16]);
+float (*SDFITSreader::sALFAcal)[2]    = (float (*)[2])(new float[16]);
 //------------------------------------------------- SDFITSreader::SDFITSreader
 …
+{
   // Default constructor.
   cSDptr = 0;
+  cSDptr = 0x0;
   // Allocate space for data descriptors.
 …
   cEndChan   = 0x0;
   cRefChan   = 0x0;
+  cPols      = 0x0;
+}
 …
         int    &extraSysCal)
+{
+  const string methodName = "open()" ;
   if (cSDptr) {
     close();
 …
   cStatus = 0;
   if (fits_open_file(&cSDptr, sdName, READONLY, &cStatus)) {
     cerr << "Failed to open SDFITS file: " << sdName << endl;
     reportError();
+    sprintf(cMsg, "ERROR: Failed to open SDFITS file\n       %s", sdName);
+    log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE, cMsg);
     return 1;
+  }
 …
         cALFA_CIMA = 1;
+        // Check for later versions of CIMAFITS.
+        float version;
+        readParm("VERSION", TFLOAT, &version);
+        if (version >= 2.0f) cALFA_CIMA = int(version);
       } else {
+        cerr << "Failed to locate SDFITS binary table." << endl;
+        reportError();
+        log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE, "Failed to locate SDFITS binary table.");
         close();
         return 1;
 …
     // Arecibo ALFA data of some kind.
     cALFA = 1;
+    for (int iBeam = 0; iBeam < 8; iBeam++) {
+      for (int iPol = 0; iPol < 2; iPol++) {
+        cALFAcalOn[iBeam][iPol]  = 0.0f;
+        cALFAcalOff[iBeam][iPol] = 0.0f;
+        // Nominal factor to calibrate spectra in Jy.
+        cALFAcal[iBeam][iPol] = 3.0f;
+      }
+    if (sInit) {
+      for (int iBeam = 0; iBeam < 8; iBeam++) {
+        for (int iPol = 0; iPol < 2; iPol++) {
+          sALFAcalOn[iBeam][iPol]  = 0.0f;
+          sALFAcalOff[iBeam][iPol] = 0.0f;
+          // Nominal factor to calibrate spectra in Jy.
+          sALFAcal[iBeam][iPol] = 3.0f;
+        }
+      }
+      sInit = 0;
+    }
+  }
 …
          strncmp(telescope, "NRAO_GBT", 8) == 0;
-  cRow = 0;
   // Check that the DATA array column is present.
 …
   haveSpectra = cHaveSpectra = cData[DATA].colnum > 0;
+  cNAxisTime = 0;
   if (cHaveSpectra) {
     // Find the number of data axes (must be the same for each IF).
     cNAxis = 5;
     if (readDim(DATA, 1, &cNAxis, cNAxes)) {
       reportError();
+    cNAxes = 5;
+    if (readDim(DATA, 1, &cNAxes, cNAxis)) {
+      log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE);
       close();
       return 1;
 …
     if (cALFA_BD) {
       // ALFA BDFITS: variable length arrays don't actually vary and there is
+      // ALFA BDFITS: variable length arrays don't actually vary and there is
       // no TDIM (or MAXISn) card; use the LAGS_IN value.
       cNAxis = 5;
       readParm("LAGS_IN", TLONG, cNAxes);
       cNAxes[1] = 1;
       cNAxes[2] = 1;
       cNAxes[3] = 1;
       cNAxes[4] = 1;
       cData[DATA].nelem = cNAxes[0];
+    }
     if (cNAxis < 4) {
+      cNAxes = 5;
+      readParm("LAGS_IN", TLONG, cNAxis);
+      cNAxis[1] = 1;
+      cNAxis[2] = 1;
+      cNAxis[3] = 1;
+      cNAxis[4] = 1;
+      cData[DATA].nelem = cNAxis[0];
+    }
+    if (cNAxes < 4) {
       // Need at least four axes (for now).
       cerr << "DATA array contains fewer than four axes." << endl;
+      log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE, "DATA array contains fewer than four axes.");
       close();
       return 1;
     } else if (cNAxis > 5) {
+    } else if (cNAxes > 5) {
       // We support up to five axes.
       cerr << "DATA array contains more than five axes." << endl;
+      log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE, "DATA array contains more than five axes.");
       close();
       return 1;
 …
     findData(DATAXED, "DATAXED", TSTRING);
     if (cData[DATAXED].colnum < 0) {
       cerr << "DATA array column absent from binary table." << endl;
+      log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE, "DATA array column absent from binary table.");
       close();
       return 1;
 …
     readParm("DATAXED", TSTRING, dataxed);
     for (int iaxis = 0; iaxis < 5; iaxis++) cNAxes[iaxis] = 0;
     sscanf(dataxed, "(%ld,%ld,%ld,%ld,%ld)", cNAxes, cNAxes+1, cNAxes+2,
       cNAxes+3, cNAxes+4);
+    for (int iaxis = 0; iaxis < 5; iaxis++) cNAxis[iaxis] = 0;
+    sscanf(dataxed, "(%ld,%ld,%ld,%ld,%ld)", cNAxis, cNAxis+1, cNAxis+2,
+      cNAxis+3, cNAxis+4);
     for (int iaxis = 4; iaxis > -1; iaxis--) {
       if (cNAxes[iaxis] == 0) cNAxis = iaxis;
+      if (cNAxis[iaxis] == 0) cNAxes = iaxis;
+    }
+  }
 …
   // Find required DATA array axes.
   char ctype[5][72];
   for (int iaxis = 0; iaxis < cNAxis; iaxis++) {
+  for (int iaxis = 0; iaxis < cNAxes; iaxis++) {
     strcpy(ctype[iaxis], "");
     readParm(CTYPE[iaxis], TSTRING, ctype[iaxis]);      // Core.
 …
   if (cStatus) {
     reportError();
+    log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE);
     close();
     return 1;
+  }
-  char *fqCRPIX  = 0;
   char *fqCRVAL  = 0;
   char *fqCDELT  = 0;
+  char *fqCRPIX  = 0;
   char *raCRVAL  = 0;
   char *decCRVAL = 0;
   char *timeCRVAL = 0;
+  char *timeCDELT = 0;
+  char *timeCRPIX = 0;
   char *beamCRVAL = 0;
+  for (int iaxis = 0; iaxis < cNAxis; iaxis++) {
+  char *polCRVAL = 0;
+  cFreqAxis   = -1;
+  cStokesAxis = -1;
+  cRaAxis     = -1;
+  cDecAxis    = -1;
+  cTimeAxis   = -1;
+  cBeamAxis   = -1;
+  for (int iaxis = 0; iaxis < cNAxes; iaxis++) {
     if (strncmp(ctype[iaxis], "FREQ", 4) == 0) {
       cReqax[0] = iaxis;
       fqCRPIX  = CRPIX[iaxis];
       fqCRVAL  = CRVAL[iaxis];
       fqCDELT  = CDELT[iaxis];
+      cFreqAxis = iaxis;
+      fqCRVAL   = CRVAL[iaxis];
+      fqCDELT   = CDELT[iaxis];
+      fqCRPIX   = CRPIX[iaxis];
     } else if (strncmp(ctype[iaxis], "STOKES", 6) == 0) {
+      cReqax[1] = iaxis;
+      cStokesAxis = iaxis;
+      polCRVAL = CRVAL[iaxis];
     } else if (strncmp(ctype[iaxis], "RA", 2) == 0) {
       cReqax[2] = iaxis;
       raCRVAL  = CRVAL[iaxis];
+      cRaAxis   = iaxis;
+      raCRVAL   = CRVAL[iaxis];
     } else if (strncmp(ctype[iaxis], "DEC", 3) == 0) {
       cReqax[3] = iaxis;
       decCRVAL = CRVAL[iaxis];
+      cDecAxis  = iaxis;
+      decCRVAL  = CRVAL[iaxis];
     } else if (strcmp(ctype[iaxis], "TIME") == 0) {
+      // TIME (UTC seconds since midnight) can be a keyword or axis type.
+      // TIME (UTC seconds since midnight); axis type, if present, takes
+      // precedence over keyword.
+      cTimeAxis = iaxis;
       timeCRVAL = CRVAL[iaxis];
+      // Check for non-degeneracy.
+      if ((cNAxisTime = cNAxis[iaxis]) > 1) {
+        timeCDELT = CDELT[iaxis];
+        timeCRPIX = CRPIX[iaxis];
+        sprintf(cMsg, "DATA array contains a TIME axis of length %ld.",
+          cNAxisTime);
+        //logMsg(cMsg);
+        log(LogOrigin( className, methodName, WHERE ), LogIO::NORMAL, cMsg);
+      }
     } else if (strcmp(ctype[iaxis], "BEAM") == 0) {
       // BEAM can be a keyword or axis type.
+      cBeamAxis = iaxis;
       beamCRVAL = CRVAL[iaxis];
+    }
 …
   if (cALFA_BD) {
     // Fixed in ALFA CIMAFITS.
     cReqax[2] = 2;
+    cRaAxis = 2;
     raCRVAL = "CRVAL2A";
     cReqax[3] = 3;
+    cDecAxis = 3;
     decCRVAL = "CRVAL3A";
+  }
+  // Check that all are present.
+  for (int iaxis = 0; iaxis < 4; iaxis++) {
+    if (cReqax[iaxis] < 0) {
+      cerr << "Could not find required DATA array axes." << endl;
+      close();
+      return 1;
+    }
+  // Check that required axes are present.
+  if (cFreqAxis < 0 || cStokesAxis < 0 || cRaAxis < 0 || cDecAxis < 0) {
+    log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE, "Could not find required DATA array axes.");
+    close();
+    return 1;
+  }
 …
   findData(CYCLE,    "CYCLE",    TINT);         // Additional.
   findData(DATE_OBS, "DATE-OBS", TSTRING);      // Core.
+  findData(TIME,     "TIME",     TDOUBLE);      // Core.
+  if (cTimeAxis >= 0) {
+    // The DATA array has a TIME axis.
+    if (cNAxisTime > 1) {
+      // Non-degenerate.
+      findData(TimeRefVal, timeCRVAL, TDOUBLE); // Time reference value.
+      findData(TimeDelt,   timeCDELT, TDOUBLE); // Time increment.
+      findData(TimeRefPix, timeCRPIX, TFLOAT);  // Time reference pixel.
+    } else {
+      // Degenerate, treat its like a simple TIME keyword.
+      findData(TIME, timeCRVAL,  TDOUBLE);
+    }
+  } else {
+    findData(TIME,   "TIME",     TDOUBLE);      // Core.
+  }
   findData(EXPOSURE, "EXPOSURE", TFLOAT);       // Core.
   findData(OBJECT,   "OBJECT",   TSTRING);      // Core.
 …
   findData(BEAM,     "BEAM",     TSHORT);       // Additional.
   findData(IF,       "IF",       TSHORT);       // Additional.
-  findData(FqRefPix,  fqCRPIX,   TFLOAT);       // Frequency reference pixel.
   findData(FqRefVal,  fqCRVAL,   TDOUBLE);      // Frequency reference value.
   findData(FqDelt,    fqCDELT,   TDOUBLE);      // Frequency increment.
+  findData(FqRefPix,  fqCRPIX,   TFLOAT);       // Frequency reference pixel.
   findData(RA,        raCRVAL,   TDOUBLE);      // Right ascension.
   findData(DEC,      decCRVAL,   TDOUBLE);      // Declination.
 …
   findData(WINDDIRE, "WINDDIRE", TFLOAT);       // Shared.
+  findData(STOKES,    polCRVAL,  TINT);
+  findData(SIG,       "SIG",     TSTRING);
+  findData(CAL,       "CAL",     TSTRING);
+  findData(RVSYS,     "RVSYS",   TDOUBLE);
+  findData(VFRAME,    "VFRAME",  TDOUBLE);
+  findData(VELDEF,    "VELDEF",  TSTRING);
   if (cStatus) {
     reportError();
+    log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE);
     close();
     return 1;
 …
     cALFAscan = 0;
     cScanNo = 0;
+    if (cALFA_BD) {
+    if (cALFA_CIMA) {
+      findData(SCAN,  "SCAN_ID", TINT);
+      if (cALFA_CIMA > 1) {
+        // Note that RECNUM increases by cNAxisTime per row.
+        findData(CYCLE, "RECNUM", TINT);
+      } else {
+        findData(CYCLE, "SUBSCAN", TINT);
+      }
+    } else if (cALFA_BD) {
       findData(SCAN,  "SCAN_NUMBER", TINT);
       findData(CYCLE, "PATTERN_NUMBER", TINT);
-    } else if (cALFA_CIMA) {
-      findData(SCAN,  "SCAN_ID", TINT);
-      findData(CYCLE, "SUBSCAN", TINT);
+    }
   } else {
 …
   cCycleNo = 0;
   cLastUTC = 0.0;
+  for ( int i = 0 ; i < 4 ; i++ ) {
+    cGLastUTC[i] = 0.0 ;
+    cGLastScan[i] = -1 ;
+    cGCycleNo[i] = 0 ;
+  }
   // Beam number, 1-relative by default.
   cBeam_1rel = 1;
+  if (cData[BEAM].colnum < 0) {
+  if (cALFA) {
+    // ALFA INPUT_ID, 0-relative (overrides BEAM column if present).
+    findData(BEAM, "INPUT_ID", TSHORT);
+    cBeam_1rel = 0;
+  } else if (cData[BEAM].colnum < 0) {
     if (beamCRVAL) {
       // There is a BEAM axis.
       findData(BEAM, beamCRVAL, TDOUBLE);
     } else {
+      if (cALFA) {
+        // ALFA data, 0-relative.
+        findData(BEAM, "INPUT_ID", TSHORT);
+      } else {
+        // ms2sdfits output, 0-relative "feed" number.
+        findData(BEAM, "MAIN_FEED1", TSHORT);
+      }
+      // ms2sdfits output, 0-relative "feed" number.
+      findData(BEAM, "MAIN_FEED1", TSHORT);
       cBeam_1rel = 0;
+    }
 …
   if (cALFA && cData[IF].colnum < 0) {
     // ALFA data, 0-relative.
+    findData(IF, "IFVAL", TSHORT);
+    if (cALFA_CIMA > 1) {
+      findData(IF, "IFN", TSHORT);
+    } else {
+      findData(IF, "IFVAL", TSHORT);
+    }
     cIF_1rel = 0;
+  }
-  if (cData[TIME].colnum < 0) {
-    if (timeCRVAL) {
-      // There is a TIME axis.
-      findData(TIME, timeCRVAL, TDOUBLE);
+    }
+  }
 …
   fits_get_num_rows(cSDptr, &cNRow, &cStatus);
   if (!cNRow) {
     cerr << "Table contains no entries." << endl;
+    log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE, "Table contains no entries.");
     close();
     return 1;
 …
     if (fits_read_col(cSDptr, TSHORT, cData[BEAM].colnum, 1, 1, cNRow,
                       &beamNul, beamCol, &anynul, &cStatus)) {
-      reportError();
       delete [] beamCol;
+      log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE);
       close();
       return 1;
 …
       // Check validity.
       if (beamCol[irow] < cBeam_1rel) {
-        cerr << "SDFITS file contains invalid beam number." << endl;
         delete [] beamCol;
+        log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE, "SDFITS file contains invalid beam number.");
         close();
         return 1;
 …
     if (fits_read_col(cSDptr, TSHORT, cData[IF].colnum, 1, 1, cNRow,
                       &IFNul, IFCol, &anynul, &cStatus)) {
-      reportError();
       delete [] IFCol;
+      log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE);
       close();
       return 1;
 …
       // Check validity.
       if (IFCol[irow] < cIF_1rel) {
-        cerr << "SDFITS file contains invalid IF number." << endl;
         delete [] IFCol;
+        log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE, "SDFITS file contains invalid IF number.");
         close();
         return 1;
 …
           if (cData[DATA].nelem < 0) {
             // Variable dimension array.
             if (readDim(DATA, irow+1, &cNAxis, cNAxes)) {
               reportError();
+            if (readDim(DATA, irow+1, &cNAxes, cNAxis)) {
+              log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE);
               close();
               return 1;
 …
             readParm("DATAXED", TSTRING, dataxed);
             sscanf(dataxed, "(%ld,%ld,%ld,%ld,%ld)", cNAxes, cNAxes+1,
               cNAxes+2, cNAxes+3, cNAxes+4);
+            sscanf(dataxed, "(%ld,%ld,%ld,%ld,%ld)", cNAxis, cNAxis+1,
+              cNAxis+2, cNAxis+3, cNAxis+4);
+          }
+        }
         // Number of channels and polarizations.
         cNChan[iIF]    = cNAxes[cReqax[0]];
         cNPol[iIF]     = cNAxes[cReqax[1]];
+        cNChan[iIF]    = cNAxis[cFreqAxis];
+        cNPol[iIF]     = cNAxis[cStokesAxis];
         cHaveXPol[iIF] = 0;
 …
           if (readDim(XPOLDATA, irow+1, &nAxis, nAxes)) {
             reportError();
+            log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE );
             close();
             return 1;
 …
     // Number of channels and polarizations.
     cNChan[0] = cNAxes[cReqax[0]];
     cNPol[0]  = cNAxes[cReqax[1]];
+    cNChan[0] = cNAxis[cFreqAxis];
+    cNPol[0]  = cNAxis[cStokesAxis];
     cHaveXPol[0] = 0;
+  }
   if (cALFA) {
     // ALFA labels each polarization as a separate IF.
+  if (cALFA && cALFA_CIMA < 2) {
+    // Older ALFA data labels each polarization as a separate IF.
     cNPol[0] = cNIF;
     cNIF = 1;
+  }
+  // For GBT data that stores spectra for each polarization in separate rows
+  if ( cData[STOKES].colnum > 0 ) {
+    int *stokesCol = new int[cNRow];
+    int stokesNul = 1;
+    int   anynul;
+    if (fits_read_col(cSDptr, TINT, cData[STOKES].colnum, 1, 1, cNRow,
+                      &stokesNul, stokesCol, &anynul, &cStatus)) {
+      delete [] stokesCol;
+      log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE);
+      close();
+      return 1;
+    }
+    vector<int> pols ;
+    pols.push_back( stokesCol[0] ) ;
+    for ( int i = 0 ; i < cNRow ; i++ ) {
+      bool pmatch = false ;
+      for ( uint j = 0 ; j < pols.size() ; j++ ) {
+        if ( stokesCol[i] == pols[j] ) {
+          pmatch = true ;
+          break ;
+        }
+      }
+      if ( !pmatch ) {
+        pols.push_back( stokesCol[i] ) ;
+      }
+    }
+    cPols = new int[pols.size()] ;
+    for ( uint i = 0 ; i < pols.size() ; i++ ) {
+      cPols[i] = pols[i] ;
+    }
+    for ( int i = 0 ; i < cNIF ; i++ ) {
+      cNPol[i] = pols.size() ;
+    }
+    delete [] stokesCol ;
+  }
 …
   extraSysCal = cExtraSysCal;
+  // Extras for ALFA data.
+  cALFAacc = 0.0f;
+  if (cALFA_CIMA > 1) {
+    // FFTs per second when the Mock correlator operates in RFI blanking mode.
+    readData("PHFFTACC", TFLOAT, 0, &cALFAacc);
+  }
+  cRow = 0;
+  cTimeIdx = cNAxisTime;
   return 0;
+}
 …
         double antPos[3],
         char   obsMode[32],
+        char   bunit[32],
         float  &equinox,
         char   radecsys[32],
 …
         double &bandwidth)
+{
+  const string methodName = "getHeader()" ;
   // Has the file been opened?
   if (!cSDptr) {
 …
   readData(OBSMODE, 1, obsMode);                        // Shared.
+  // Brightness unit.
+  if (cData[DATAXED].colnum >= 0) {
+    strcpy(bunit, "Jy");
+  } else {
+    strcpy(bunit, cData[DATA].units);
+  }
+  if (strcmp(bunit, "JY") == 0) {
+    bunit[1] = 'y';
+  } else if (strcmp(bunit, "JY/BEAM") == 0) {
+    strcpy(bunit, "Jy/beam");
+  }
   readParm("EQUINOX",  TFLOAT,  &equinox);              // Shared.
   if (cStatus == 405) {
 …
     // Look for VELFRAME, written by earlier versions of Livedata.
+    //
+    // Added few more codes currently (as of 2009 Oct) used in the GBT
+    // SDFITS (based io_sdfits_define.pro of GBTIDL). - TT
     if (readParm("VELFRAME", TSTRING, dopplerFrame)) {  // Additional.
       // No, try digging it out of the CTYPE card (AIPS convention).
       char keyw[9], ctype[9];
       sprintf(keyw, "CTYPE%ld", cReqax[0]+1);
+      sprintf(keyw, "CTYPE%ld", cFreqAxis+1);
       readParm(keyw, TSTRING, ctype);
 …
           // LSR unqualified usually means LSR (kinematic).
           strcpy(dopplerFrame, "LSRK");
+        } else if (strcmp(dopplerFrame, "LSD") == 0) {
+          // LSR as a dynamical defintion
+          strcpy(dopplerFrame, "LSRD");
         } else if (strcmp(dopplerFrame, "HEL") == 0) {
           // Almost certainly barycentric.
           strcpy(dopplerFrame, "BARYCENT");
+        } else if (strcmp(dopplerFrame, "BAR") == 0) {
+          // barycentric.
+          strcpy(dopplerFrame, "BARYCENT");
+        } else if (strcmp(dopplerFrame, "OBS") == 0) {
+          // observed or topocentric.
+          strcpy(dopplerFrame, "TOPO");
+        } else if (strcmp(dopplerFrame, "GEO") == 0) {
+          // geocentric
+          strcpy(dopplerFrame, "GEO");
+        } else if (strcmp(dopplerFrame, "GAL") == 0) {
+          // galactic
+          strcpy(dopplerFrame, "GAL");
+        } else if (strcmp(dopplerFrame, "LGR") == 0) {
+          // Local group
+          strcpy(dopplerFrame, "LGROUP");
+        } else if (strcmp(dopplerFrame, "CMB") == 0) {
+          // Cosimic Microwave Backgroup
+          strcpy(dopplerFrame, "CMB");
+        }
       } else {
 …
+      }
+    }
     // Translate to FITS standard names.
     if (strncmp(dopplerFrame, "TOP", 3) == 0) {
 …
     } else if (strncmp(dopplerFrame, "BARY", 4) == 0) {
       strcpy(dopplerFrame, "BARYCENT");
+    }
+  }
+    } else if (strncmp(dopplerFrame, "GAL", 3) == 0) {
+      strcpy(dopplerFrame, "GALACTOC");
+    } else if (strncmp(dopplerFrame, "LGROUP", 6) == 0) {
+      strcpy(dopplerFrame, "LOCALGRP");
+    } else if (strncmp(dopplerFrame, "CMB", 3) == 0) {
+      strcpy(dopplerFrame, "CMBDIPOL");
+    }
+  }
   if (cStatus) {
     reportError();
+    log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE);
     return 1;
+  }
   // Get parameters from first row of table.
+  readData(DATE_OBS, 1, datobs);
+  readData(TIME,     1, &utc);
+  readTime(1, 1, datobs, utc);
   readData(FqRefVal, 1, &refFreq);
   readParm("BANDWID", TDOUBLE, &bandwidth);             // Core.
-  if (cALFA_BD) utc *= 3600.0;
   if (cStatus) {
     reportError();
+    log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE);
     return 1;
+  }
-  // Check DATE-OBS format.
-  if (datobs[2] == '/') {
-    // Translate an old-format DATE-OBS.
-    datobs[9] = datobs[1];
-    datobs[8] = datobs[0];
-    datobs[2] = datobs[6];
-    datobs[5] = datobs[3];
-    datobs[3] = datobs[7];
-    datobs[6] = datobs[4];
-    datobs[7] = '-';
-    datobs[4] = '-';
-    datobs[1] = '9';
-    datobs[0] = '1';
-    datobs[10] = '\0';
-  } else if (datobs[10] == 'T' && cData[TIME].colnum < 0) {
-    // Dig UTC out of a new-format DATE-OBS.
-    int   hh, mm;
-    float ss;
-    sscanf(datobs+11, "%d:%d:%f", &hh, &mm, &ss);
-    utc = (hh*60 + mm)*60 + ss;
-    datobs[10] = '\0';
+  }
 …
         double* &endFreq)
+{
+  const string methodName = "getFreqInfo()" ;
   float  fqRefPix;
   double fqDelt, fqRefVal;
 …
     if (fits_read_col(cSDptr, TSHORT, cData[IF].colnum, 1, 1, cNRow,
                       &IFNul, IFCol, &anynul, &cStatus)) {
-      reportError();
       delete [] IFCol;
+      log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE);
       close();
       return 1;
 …
         double* &positions)
+{
   int anynul;
+  const string methodName = "findRange()" ;
   // Has the file been opened?
 …
   // Find the number of rows selected.
   short *sel = new short[nRow];
   for (int irow = 0; irow < nRow; irow++) {
+  short *sel = new short[cNRow];
+  for (int irow = 0; irow < cNRow; irow++) {
     sel[irow] = 1;
+  }
+  int anynul;
   if (cData[BEAM].colnum > 0) {
     short *beamCol = new short[cNRow];
 …
     if (fits_read_col(cSDptr, TSHORT, cData[BEAM].colnum, 1, 1, cNRow,
                       &beamNul, beamCol, &anynul, &cStatus)) {
-      reportError();
       delete [] beamCol;
       delete [] sel;
+      log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE);
       return 1;
+    }
     for (int irow = 0; irow < nRow; irow++) {
+    for (int irow = 0; irow < cNRow; irow++) {
       if (!cBeams[beamCol[irow]-cBeam_1rel]) {
         sel[irow] = 0;
 …
     if (fits_read_col(cSDptr, TSHORT, cData[IF].colnum, 1, 1, cNRow,
                       &IFNul, IFCol, &anynul, &cStatus)) {
-      reportError();
       delete [] IFCol;
       delete [] sel;
+      log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE);
       return 1;
+    }
     for (int irow = 0; irow < nRow; irow++) {
+    for (int irow = 0; irow < cNRow; irow++) {
       if (!cIFs[IFCol[irow]-cIF_1rel]) {
         sel[irow] = 0;
 …
   nSel = 0;
   for (int irow = 0; irow < nRow; irow++) {
+  for (int irow = 0; irow < cNRow; irow++) {
     nSel += sel[irow];
+  }
 …
   // Find the time range assuming the data is in chronological order.
+  readData(DATE_OBS, 1,    dateSpan[0]);
+  readData(DATE_OBS, nRow, dateSpan[1]);
+  readData(TIME, 1,    utcSpan);
+  readData(TIME, nRow, utcSpan+1);
+  if (cALFA_BD) {
+    utcSpan[0] *= 3600.0;
+    utcSpan[1] *= 3600.0;
+  }
+  // Check DATE-OBS format.
+  for (int i = 0; i < 2; i++) {
+    if (dateSpan[0][2] == '/') {
+      // Translate an old-format DATE-OBS.
+      dateSpan[i][9] = dateSpan[i][1];
+      dateSpan[i][8] = dateSpan[i][0];
+      dateSpan[i][2] = dateSpan[i][6];
+      dateSpan[i][5] = dateSpan[i][3];
+      dateSpan[i][3] = dateSpan[i][7];
+      dateSpan[i][6] = dateSpan[i][4];
+      dateSpan[i][7] = '-';
+      dateSpan[i][4] = '-';
+      dateSpan[i][1] = '9';
+      dateSpan[i][0] = '1';
+      dateSpan[i][10] = '\0';
+    }
+    if (dateSpan[i][10] == 'T' && cData[TIME].colnum < 0) {
+      // Dig UTC out of a new-format DATE-OBS.
+      int   hh, mm;
+      float ss;
+      sscanf(dateSpan[i]+11, "%d:%d:%f", &hh, &mm, &ss);
+      utcSpan[i] = (hh*60 + mm)*60 + ss;
+    }
+  }
+  readTime(1, 1, dateSpan[0], utcSpan[0]);
+  readTime(cNRow, cNAxisTime, dateSpan[1], utcSpan[1]);
   // Retrieve positions for selected data.
-  double *ra  = new double[cNRow];
-  double *dec = new double[cNRow];
-  fits_read_col(cSDptr, TDOUBLE, cData[RA].colnum,  1, 1, nRow, 0, ra,
-                &anynul, &cStatus);
-  fits_read_col(cSDptr, TDOUBLE, cData[DEC].colnum, 1, 1, nRow, 0, dec,
-                &anynul, &cStatus);
-  if (cALFA_BD) {
-    for (int irow = 0; irow < nRow; irow++) {
-      // Convert hours to degrees.
-      ra[irow] *= 15.0;
+    }
+  }
   int isel = 0;
   positions = new double[2*nSel];
+  // Parameters needed to compute feed-plane coordinates.
+  double *srcRA, *srcDec;
+  float  *par, *rot;
+  if (cGetFeedPos) {
+    srcRA  = new double[cNRow];
+    srcDec = new double[cNRow];
+    par    = new float[cNRow];
+    rot    = new float[cNRow];
+    fits_read_col(cSDptr, TDOUBLE, cData[OBJ_RA].colnum,   1, 1, nRow, 0,
+                  srcRA,  &anynul, &cStatus);
+    fits_read_col(cSDptr, TDOUBLE, cData[OBJ_DEC].colnum,  1, 1, nRow, 0,
+                  srcDec, &anynul, &cStatus);
+    fits_read_col(cSDptr, TFLOAT,  cData[PARANGLE].colnum, 1, 1, nRow, 0,
+                  par,    &anynul, &cStatus);
+    fits_read_col(cSDptr, TFLOAT,  cData[FOCUSROT].colnum, 1, 1, nRow, 0,
+                  rot,    &anynul, &cStatus);
+    for (int irow = 0; irow < nRow; irow++) {
+      if (sel[irow]) {
+        // Convert to feed-plane coordinates.
+        Double dist, pa;
+        distPA(ra[irow]*D2R, dec[irow]*D2R, srcRA[irow]*D2R, srcDec[irow]*D2R,
+               dist, pa);
+        Double spin = (par[irow] + rot[irow])*D2R - pa + PI;
+        if (spin > 2.0*PI) spin -= 2.0*PI;
+        Double squint = PI/2.0 - dist;
+        positions[isel++] = spin;
+        positions[isel++] = squint;
+      }
+    }
+    delete [] srcRA;
+    delete [] srcDec;
+    delete [] par;
+    delete [] rot;
+  if (cCoordSys == 1) {
+    // Horizontal (Az,El).
+    if (cData[AZIMUTH].colnum  < 0 ||
+        cData[ELEVATIO].colnum < 0) {
+      log(LogOrigin( className, methodName, WHERE ), LogIO::WARN, "Azimuth/elevation information absent.");
+      cStatus = -1;
+    } else {
+      float *az = new float[cNRow];
+      float *el = new float[cNRow];
+      readCol(AZIMUTH,  az);
+      readCol(ELEVATIO, el);
+      if (!cStatus) {
+        for (int irow = 0; irow < cNRow; irow++) {
+          if (sel[irow]) {
+            positions[isel++] = az[irow] * D2R;
+            positions[isel++] = el[irow] * D2R;
+          }
+        }
+      }
+      delete [] az;
+      delete [] el;
+    }
+  } else if (cCoordSys == 3) {
+    // ZPA-EL.
+    if (cData[BEAM].colnum < 0 ||
+        cData[FOCUSROT].colnum < 0 ||
+        cData[ELEVATIO].colnum < 0) {
+      log(LogOrigin( className, methodName, WHERE ), LogIO::WARN, "ZPA/elevation information absent.");
+      cStatus = -1;
+    } else {
+      short *beam = new short[cNRow];
+      float *rot  = new float[cNRow];
+      float *el   = new float[cNRow];
+      readCol(BEAM,     beam);
+      readCol(FOCUSROT, rot);
+      readCol(ELEVATIO, el);
+      if (!cStatus) {
+        for (int irow = 0; irow < cNRow; irow++) {
+          if (sel[irow]) {
+            Int beamNo = beam[irow];
+            Double zpa = rot[irow];
+            if (beamNo > 1) {
+              // Beam geometry for the Parkes multibeam.
+              if (beamNo < 8) {
+                zpa += -60.0 + 60.0*(beamNo-2);
+              } else {
+                zpa += -90.0 + 60.0*(beamNo-8);
+              }
+              if (zpa < -180.0) {
+                zpa += 360.0;
+              } else if (zpa > 180.0) {
+                zpa -= 360.0;
+              }
+            }
+            positions[isel++] = zpa * D2R;
+            positions[isel++] = el[irow] * D2R;
+          }
+        }
+      }
+      delete [] beam;
+      delete [] rot;
+      delete [] el;
+    }
   } else {
+    for (int irow = 0; irow < nRow; irow++) {
+      if (sel[irow]) {
+        positions[isel++] =  ra[irow] * D2R;
+        positions[isel++] = dec[irow] * D2R;
+      }
+    }
+  }
+    double *ra  = new double[cNRow];
+    double *dec = new double[cNRow];
+    readCol(RA,  ra);
+    readCol(DEC, dec);
+    if (cStatus) {
+      delete [] ra;
+      delete [] dec;
+      goto cleanup;
+    }
+    if (cALFA_BD) {
+      for (int irow = 0; irow < cNRow; irow++) {
+        // Convert hours to degrees.
+        ra[irow] *= 15.0;
+      }
+    }
+    if (cCoordSys == 0) {
+      // Equatorial (RA,Dec).
+      for (int irow = 0; irow < cNRow; irow++) {
+        if (sel[irow]) {
+          positions[isel++] =  ra[irow] * D2R;
+          positions[isel++] = dec[irow] * D2R;
+        }
+      }
+    } else if (cCoordSys == 2) {
+      // Feed-plane.
+      if (cData[OBJ_RA].colnum   < 0 ||
+          cData[OBJ_DEC].colnum  < 0 ||
+          cData[PARANGLE].colnum < 0 ||
+          cData[FOCUSROT].colnum < 0) {
+        log( LogOrigin( className, methodName, WHERE ), LogIO::WARN,
+             "Insufficient information to compute feed-plane\n"
+             "         coordinates.");
+        cStatus = -1;
+      } else {
+        double *srcRA  = new double[cNRow];
+        double *srcDec = new double[cNRow];
+        float  *par = new float[cNRow];
+        float  *rot = new float[cNRow];
+        readCol(OBJ_RA,   srcRA);
+        readCol(OBJ_DEC,  srcDec);
+        readCol(PARANGLE, par);
+        readCol(FOCUSROT, rot);
+        if (!cStatus) {
+          for (int irow = 0; irow < cNRow; irow++) {
+            if (sel[irow]) {
+              // Convert to feed-plane coordinates.
+              Double dist, pa;
+              distPA(ra[irow]*D2R, dec[irow]*D2R, srcRA[irow]*D2R,
+                     srcDec[irow]*D2R, dist, pa);
+              Double spin = (par[irow] + rot[irow])*D2R - pa;
+              if (spin > 2.0*PI) spin -= 2.0*PI;
+              Double squint = PI/2.0 - dist;
+              positions[isel++] = spin;
+              positions[isel++] = squint;
+            }
+          }
+        }
+        delete [] srcRA;
+        delete [] srcDec;
+        delete [] par;
+        delete [] rot;
+      }
+    }
+    delete [] ra;
+    delete [] dec;
+  }
+cleanup:
   delete [] sel;
+  delete [] ra;
+  delete [] dec;
+  return cStatus;
+  if (cStatus) {
+    nSel = 0;
+    delete [] positions;
+    log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE);
+    cStatus = 0;
+    return 1;
+  }
+  return 0;
+}
 …
 int SDFITSreader::read(
         PKSMBrecord &mbrec)
+        MBrecord &mbrec)
+{
+  const string methodName = "read()" ;
   // Has the file been opened?
   if (!cSDptr) {
     return 1;
+  }
   // Find the next selected beam and IF.
   short iBeam = 0, iIF = 0;
+  while (++cRow <= cNRow) {
+  int iPol = -1 ;
+  while (1) {
+    if (++cTimeIdx > cNAxisTime) {
+      if (++cRow > cNRow) break;
+      cTimeIdx = 1;
+    }
     if (cData[BEAM].colnum > 0) {
       readData(BEAM, cRow, &iBeam);
 …
           char chars[32];
           readData(OBSMODE, cRow, chars);
+          if (strcmp(chars, "CAL") == 0) {
+            // iIF is really the polarization in ALFA data.
+            alfaCal(iBeam, iIF);
+          if (strcmp(chars, "DROP") == 0) {
+            // Completely flagged integration.
             continue;
+          } else if (strcmp(chars, "CAL") == 0) {
+            sReset = 1;
+            if (cALFA_CIMA > 1) {
+              for (short iPol = 0; iPol < cNPol[iIF]; iPol++) {
+                alfaCal(iBeam, iIF, iPol);
+              }
+              continue;
+            } else {
+              // iIF is really the polarization in older ALFA data.
+              alfaCal(iBeam, 0, iIF);
+              continue;
+            }
+          } else {
+            // Reset for the next CAL record.
+            if (sReset) {
+              for (short iPol = 0; iPol < cNPol[iIF]; iPol++) {
+                sALFAcalNon[iBeam][iPol]  = 0;
+                sALFAcalNoff[iBeam][iPol] = 0;
+                sALFAcalOn[iBeam][iPol]   = 0.0f;
+                sALFAcalOff[iBeam][iPol]  = 0.0f;
+              }
+              sReset = 0;
+              sprintf(cMsg, "ALFA cal factors for beam %d: %.3e, %.3e",
+                iBeam+1, sALFAcal[iBeam][0], sALFAcal[iBeam][1]);
+              log(LogOrigin( className, methodName, WHERE ), LogIO::NORMAL, cMsg);
+              //logMsg(cMsg);
+            }
+          }
+        }
+        // for GBT SDFITS
+        if (cData[STOKES].colnum > 0 ) {
+          readData(STOKES, cRow, &iPol ) ;
+          for ( int i = 0 ; i < cNPol[iIF] ; i++ ) {
+            if ( cPols[i] == iPol ) {
+              iPol = i ;
+              break ;
+            }
+          }
+        }
         break;
+      }
 …
   // Times.
   char datobs[32];
+  readData(DATE_OBS, cRow,  datobs);
+  readData(TIME,     cRow, &mbrec.utc);
+  if (cALFA_BD) mbrec.utc *= 3600.0;
+  if (datobs[2] == '/') {
+    // Translate an old-format DATE-OBS.
+    datobs[9] = datobs[1];
+    datobs[8] = datobs[0];
+    datobs[2] = datobs[6];
+    datobs[5] = datobs[3];
+    datobs[3] = datobs[7];
+    datobs[6] = datobs[4];
+    datobs[7] = '-';
+    datobs[4] = '-';
+    datobs[1] = '9';
+    datobs[0] = '1';
+  } else if (datobs[10] == 'T' && cData[TIME].colnum < 0) {
+    // Dig UTC out of a new-format DATE-OBS.
+    int   hh, mm;
+    float ss;
+    sscanf(datobs+11, "%d:%d:%f", &hh, &mm, &ss);
+    mbrec.utc = (hh*60 + mm)*60 + ss;
+  }
+  datobs[10] = '\0';
+  readTime(cRow, cTimeIdx, datobs, mbrec.utc);
   strcpy(mbrec.datobs, datobs);
   if (cData[CYCLE].colnum > 0) {
     readData(CYCLE, cRow, &mbrec.cycleNo);
+    mbrec.cycleNo += cTimeIdx - 1;
     if (cALFA_BD) mbrec.cycleNo++;
   } else {
 …
+  }
+  if ( iPol != -1 ) {
+    if ( mbrec.scanNo != cGLastScan[iPol] ) {
+      cGLastScan[iPol] = mbrec.scanNo ;
+      cGCycleNo[iPol] = 0 ;
+      mbrec.cycleNo = ++cGCycleNo[iPol] ;
+    }
+    else {
+      mbrec.cycleNo = ++cGCycleNo[iPol] ;
+    }
+  }
   readData(EXPOSURE, cRow, &mbrec.exposure);
   // Source identification.
+  readData(OBJECT,  cRow,  mbrec.srcName);
+  readData(OBJECT, cRow, mbrec.srcName);
+  if ( iPol != -1 ) {
+    char obsmode[32] ;
+    readData( OBSMODE, cRow, obsmode ) ;
+    char sig[1] ;
+    char cal[1] ;
+    readData( SIG, cRow, sig ) ;
+    readData( CAL, cRow, cal ) ;
+    if ( strstr( obsmode, "PSWITCH" ) != NULL ) {
+      // position switch
+      strcat( mbrec.srcName, "_p" ) ;
+      if ( strstr( obsmode, "PSWITCHON" ) != NULL ) {
+        strcat( mbrec.srcName, "s" ) ;
+      }
+      else if ( strstr( obsmode, "PSWITCHOFF" ) != NULL ) {
+        strcat( mbrec.srcName, "r" ) ;
+      }
+    }
+    else if ( strstr( obsmode, "Nod" ) != NULL ) {
+      // nod
+      strcat( mbrec.srcName, "_n" ) ;
+      if ( sig[0] == 'T' ) {
+        strcat( mbrec.srcName, "s" ) ;
+      }
+      else {
+        strcat( mbrec.srcName, "r" ) ;
+      }
+    }
+    else if ( strstr( obsmode, "FSWITCH" ) != NULL ) {
+      // frequency switch
+      strcat( mbrec.srcName, "_f" ) ;
+      if ( sig[0] == 'T' ) {
+        strcat( mbrec.srcName, "s" ) ;
+      }
+      else {
+        strcat( mbrec.srcName, "r" ) ;
+      }
+    }
+    if ( cal[0] == 'T' ) {
+      strcat( mbrec.srcName, "c" ) ;
+    }
+    else {
+      strcat( mbrec.srcName, "o" ) ;
+    }
+  }
   readData(OBJ_RA,  cRow, &mbrec.srcRA);
 …
     mbrec.decRate = scanrate[1] * D2R;
+  }
+  mbrec.paRate = 0.0f;
   // IF-dependent parameters.
 …
   int nPol = cNPol[iIF];
+  if ( cData[STOKES].colnum > 0 )
+    nPol = 1 ;
   if (cGetSpectra || cGetXPol) {
     int nxpol = cGetXPol ? 2*nChan : 0;
 …
   mbrec.nChan[0] = nChan;
   mbrec.nPol[0]  = nPol;
+  mbrec.polNo = iPol ;
   readData(FqRefPix, cRow, mbrec.fqRefPix);
 …
   if (cStatus) {
     reportError();
+    log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE);
     return 1;
+  }
 …
   if (cStatus) {
     reportError();
+    log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE);
     return 1;
+  }
   // Read data, sectioning and transposing it in the process.
   long *blc = new long[cNAxis+1];
   long *trc = new long[cNAxis+1];
   long *inc = new long[cNAxis+1];
   for (int iaxis = 0; iaxis <= cNAxis; iaxis++) {
+  long *blc = new long[cNAxes+1];
+  long *trc = new long[cNAxes+1];
+  long *inc = new long[cNAxes+1];
+  for (int iaxis = 0; iaxis <= cNAxes; iaxis++) {
     blc[iaxis] = 1;
     trc[iaxis] = 1;
 …
+  }
+  blc[cReqax[0]] = std::min(startChan, endChan);
+  trc[cReqax[0]] = std::max(startChan, endChan);
+  blc[cNAxis] = cRow;
+  trc[cNAxis] = cRow;
+  blc[cFreqAxis] = std::min(startChan, endChan);
+  trc[cFreqAxis] = std::max(startChan, endChan);
+  if (cTimeAxis >= 0) {
+    blc[cTimeAxis] = cTimeIdx;
+    trc[cTimeAxis] = cTimeIdx;
+  }
+  blc[cNAxes] = cRow;
+  trc[cNAxes] = cRow;
   mbrec.haveSpectra = cGetSpectra;
 …
     int  anynul;
     for (int ipol = 0; ipol < nPol; ipol++) {
       blc[cReqax[1]] = ipol+1;
       trc[cReqax[1]] = ipol+1;
       if (cALFA) {
+    for (int iPol = 0; iPol < nPol; iPol++) {
+      blc[cStokesAxis] = iPol+1;
+      trc[cStokesAxis] = iPol+1;
+      if (cALFA && cALFA_CIMA < 2) {
         // ALFA data: polarizations are stored in successive rows.
         blc[cReqax[1]] = 1;
         trc[cReqax[1]] = 1;
         if (ipol) {
+        blc[cStokesAxis] = 1;
+        trc[cStokesAxis] = 1;
+        if (iPol) {
           if (++cRow > cNRow) {
             return -1;
+          }
           blc[cNAxis] = cRow;
           trc[cNAxis] = cRow;
+          blc[cNAxes] = cRow;
+          trc[cNAxes] = cRow;
+        }
       } else if (cData[DATA].nelem < 0) {
         // Variable dimension array; get axis lengths.
         int  naxis = 5, status;
         if ((status = readDim(DATA, cRow, &naxis, cNAxes))) {
           reportError();
         } else if ((status = (naxis != cNAxis))) {
           cerr << "DATA array dimensions changed." << endl;
+        int naxes = 5, status;
+        if ((status = readDim(DATA, cRow, &naxes, cNAxis))) {
+          log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE);
+        } else if ((status = (naxes != cNAxes))) {
+          log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE, "DATA array dimensions changed.");
+        }
 …
+      }
       if (fits_read_subset_flt(cSDptr, cData[DATA].colnum, cNAxis, cNAxes,
           blc, trc, inc, 0, mbrec.spectra[0] + ipol*nChan, &anynul,
+      if (fits_read_subset_flt(cSDptr, cData[DATA].colnum, cNAxes, cNAxis,
+          blc, trc, inc, 0, mbrec.spectra[0] + iPol*nChan, &anynul,
           &cStatus)) {
         reportError();
+        log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE);
         delete [] blc;
         delete [] trc;
 …
       if (endChan < startChan) {
         // Reverse the spectrum.
         float *iptr = mbrec.spectra[0] + ipol*nChan;
+        float *iptr = mbrec.spectra[0] + iPol*nChan;
         float *jptr = iptr + nChan - 1;
         float *mid  = iptr + nChan/2;
 …
       if (cALFA) {
         // ALFA data, rescale the spectrum.
+        float *chan  = mbrec.spectra[0] + ipol*nChan;
+        float el, zd;
+        readData(ELEVATIO, cRow, &el);
+        zd = 90.0f - el;
+        float factor = sALFAcal[iBeam][iPol] / alfaGain(zd);
+        if (cALFA_CIMA > 1) {
+          // Rescale according to the number of unblanked accumulations.
+          int colnum, naccum;
+          findCol("STAT", &colnum);
+          fits_read_col(cSDptr, TINT, colnum, cRow, 10*(cTimeIdx-1)+2, 1, 0,
+                        &naccum, &anynul, &cStatus);
+          factor *= cALFAacc / naccum;
+        }
+        float *chan  = mbrec.spectra[0] + iPol*nChan;
         float *chanN = chan + nChan;
         while (chan < chanN) {
           // Approximate conversion to Jy.
           *(chan++) *= cALFAcal[iBeam][iIF];
+          *(chan++) *= factor;
+        }
+      }
       if (mbrec.tsys[0][ipol] == 0.0) {
+      if (mbrec.tsys[0][iPol] == 0.0) {
         // Compute Tsys as the average across the spectrum.
         float *chan  = mbrec.spectra[0] + ipol*nChan;
+        float *chan  = mbrec.spectra[0] + iPol*nChan;
         float *chanN = chan + nChan;
         float *tsys = mbrec.tsys[0] + ipol;
+        float *tsys = mbrec.tsys[0] + iPol;
         while (chan < chanN) {
           *tsys += *(chan++);
 …
       // Read data flags.
       if (cData[FLAGGED].colnum > 0) {
         if (fits_read_subset_byt(cSDptr, cData[FLAGGED].colnum, cNAxis,
             cNAxes, blc, trc, inc, 0, mbrec.flagged[0] + ipol*nChan, &anynul,
+        if (fits_read_subset_byt(cSDptr, cData[FLAGGED].colnum, cNAxes,
+            cNAxis, blc, trc, inc, 0, mbrec.flagged[0] + iPol*nChan, &anynul,
             &cStatus)) {
           reportError();
+          log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE);
           delete [] blc;
           delete [] trc;
 …
         if (endChan < startChan) {
           // Reverse the flag vector.
           unsigned char *iptr = mbrec.flagged[0] + ipol*nChan;
+          unsigned char *iptr = mbrec.flagged[0] + iPol*nChan;
           unsigned char *jptr = iptr + nChan - 1;
           for (int ichan = 0; ichan < nChan/2; ichan++) {
 …
       } else {
         // All channels are unflagged by default.
         unsigned char *iptr = mbrec.flagged[0] + ipol*nChan;
+        unsigned char *iptr = mbrec.flagged[0] + iPol*nChan;
         for (int ichan = 0; ichan < nChan; ichan++) {
           *(iptr++) = 0;
 …
     if (fits_read_subset_flt(cSDptr, cData[XPOLDATA].colnum, nAxis, nAxes,
         blc, trc, inc, 0, mbrec.xpol[0], &anynul, &cStatus)) {
       reportError();
+      log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE);
       delete [] blc;
       delete [] trc;
 …
   if (cStatus) {
     reportError();
+    log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE);
     return 1;
+  }
 …
   readData(TCAL,     cRow, &mbrec.tcal[0]);
   readData(TCALTIME, cRow,  mbrec.tcalTime);
   readData(AZIMUTH,  cRow, &mbrec.azimuth);
   readData(ELEVATIO, cRow, &mbrec.elevation);
   readData(PARANGLE, cRow, &mbrec.parAngle);
   readData(FOCUSAXI, cRow, &mbrec.focusAxi);
   readData(FOCUSTAN, cRow, &mbrec.focusTan);
   readData(FOCUSROT, cRow, &mbrec.focusRot);
   readData(TAMBIENT, cRow, &mbrec.temp);
   readData(PRESSURE, cRow, &mbrec.pressure);
 …
   mbrec.windAz    *= D2R;
+  // For GBT data, source velocity can be evaluated
+  if ( cData[RVSYS].colnum > 0 && cData[VFRAME].colnum > 0 ) {
+    float vframe;
+    readData(VFRAME, cRow, &vframe);
+    float rvsys;
+    readData(RVSYS,  cRow, &rvsys);
+    //mbrec.srcVelocity = rvsys - vframe ;
+    mbrec.srcVelocity = rvsys ;
+  }
   if (cStatus) {
     reportError();
+    log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE);
     return 1;
+  }
   return 0;
+}
-//------------------------------------------------------ SDFITSreader::alfaCal
-// Process ALFA calibration data.
-int SDFITSreader::alfaCal(
-        short iBeam,
-        short iPol)
+{
-  int  calOn;
-  char chars[32];
-  if (cALFA_BD) {
-    readData("OBS_NAME", TSTRING, cRow, chars);
-  } else {
-    readData("SCANTYPE", TSTRING, cRow, chars);
+  }
-  if (strcmp(chars, "ON") == 0) {
-    calOn = 1;
-  } else if (strcmp(chars, "OFF") == 0) {
-    calOn = 0;
-  } else {
-    return 1;
+  }
-  // Read cal data.
-  long *blc = new long[cNAxis+1];
-  long *trc = new long[cNAxis+1];
-  long *inc = new long[cNAxis+1];
-  for (int iaxis = 0; iaxis <= cNAxis; iaxis++) {
-    blc[iaxis] = 1;
-    trc[iaxis] = 1;
-    inc[iaxis] = 1;
+  }
-  // User channel selection.
-  int startChan = cStartChan[0];
-  int endChan   = cEndChan[0];
-  blc[cNAxis] = cRow;
-  trc[cNAxis] = cRow;
-  blc[cReqax[0]] = std::min(startChan, endChan);
-  trc[cReqax[0]] = std::max(startChan, endChan);
-  blc[cReqax[1]] = 1;
-  trc[cReqax[1]] = 1;
-  float spectrum[endChan];
-  int anynul;
-  if (fits_read_subset_flt(cSDptr, cData[DATA].colnum, cNAxis, cNAxes,
-      blc, trc, inc, 0, spectrum, &anynul, &cStatus)) {
-    reportError();
-    delete [] blc;
-    delete [] trc;
-    delete [] inc;
-    return 1;
+  }
-  // Average the spectrum.
-  float mean = 1e9f;
-  for (int k = 0; k < 2; k++) {
-    float discrim = 2.0f * mean;
-    int nChan = 0;
-    float sum = 0.0f;
-    float *chanN = spectrum + abs(endChan - startChan) + 1;
-    for (float *chan = spectrum; chan < chanN; chan++) {
-      // Simple discriminant that eliminates strong radar interference.
-      if (*chan < discrim) {
-        nChan++;
-        sum += *chan;
+      }
+    }
-    mean = sum / nChan;
+  }
-  if (calOn) {
-    cALFAcalOn[iBeam][iPol]  += mean;
-  } else {
-    cALFAcalOff[iBeam][iPol] += mean;
+  }
-  if (cALFAcalOn[iBeam][iPol] != 0.0f &&
-      cALFAcalOff[iBeam][iPol] != 0.0f) {
-    // Tcal should come from the TCAL table, it varies weakly with beam,
-    // polarization, and frequency.  However, TCAL is not written properly.
-    float Tcal = 12.0f;
-    cALFAcal[iBeam][iPol] = Tcal / (cALFAcalOn[iBeam][iPol] -
-                                    cALFAcalOff[iBeam][iPol]);
-    // Scale from K to Jy; the gain also varies weakly with beam,
-    // polarization, frequency, and zenith angle.
-    float fluxCal = 10.0f;
-    cALFAcal[iBeam][iPol] /= fluxCal;
-    cALFAcalOn[iBeam][iPol]  = 0.0f;
-    cALFAcalOff[iBeam][iPol] = 0.0f;
+  }
-  return 0;
+}
-//-------------------------------------------------- SDFITSreader::reportError
-// Print the error message corresponding to the input status value and all the
-// messages on the CFITSIO error stack to stderr.
-void SDFITSreader::reportError()
+{
-  fits_report_error(stderr, cStatus);
+}
 …
     int status = 0;
     fits_close_file(cSDptr, &status);
     cSDptr = 0;
+    cSDptr = 0x0;
     if (cBeams)     delete [] cBeams;
 …
     if (cRefChan)   delete [] cRefChan;
+  }
+}
+//------------------------------------------------------- SDFITSreader::log
+// Log a message.  If the current CFITSIO status value is non-zero, also log
+// the corresponding error message and the CFITSIO message stack.
+void SDFITSreader::log(LogOrigin origin, LogIO::Command cmd, const char *msg)
+{
+  LogIO os( origin ) ;
+  os << msg << endl ;
+  if (cStatus > 0) {
+    fits_get_errstatus(cStatus, cMsg);
+    os << cMsg << endl ;
+    while (fits_read_errmsg(cMsg)) {
+      os << cMsg << endl ;
+    }
+  }
+  os << LogIO::POST ;
+}
 …
     long nelem, width;
     fits_get_coltype(cSDptr, colnum, &coltype, &nelem, &width, &cStatus);
+    fits_get_bcolparms(cSDptr, colnum, 0x0, cData[iData].units, 0x0, 0x0, 0x0,
+x0, 0x0, 0x0, &cStatus);
     // Look for a TDIMnnn keyword or column.
 …
+}
+//------------------------------------------------------ SDFITSreader::findCol
+// Locate a parameter in the SDFITS file.
+void SDFITSreader::findCol(
+        char *name,
+        int *colnum)
+{
+  *colnum = 0;
+  int status = 0;
+  fits_get_colnum(cSDptr, CASESEN, name, colnum, &status);
+  if (status) {
+    // Not a real column - maybe it's virtual.
+    char card[81];
+    status = 0;
+    fits_read_card(cSDptr, name, card, &status);
+    if (status) {
+      // Not virtual either.
+      *colnum = -1;
+    }
+    // Clear error messages.
+    fits_clear_errmsg();
+  }
+}
 //------------------------------------------------------ SDFITSreader::readDim
 …
         int  iData,
         long iRow,
         int *naxis,
         long naxes[])
+        int *naxes,
+        long naxis[])
+{
   int colnum = cData[iData].colnum;
 …
+  }
   int maxdim = *naxis;
+  int maxdim = *naxes;
   if (cData[iData].tdimcol < 0) {
     // No TDIMnnn column for this array.
     if (cData[iData].nelem < 0) {
       // Variable length array; read the array descriptor.
       *naxis = 1;
+      *naxes = 1;
       long dummy;
       if (fits_read_descript(cSDptr, colnum, iRow, naxes, &dummy, &cStatus)) {
+      if (fits_read_descript(cSDptr, colnum, iRow, naxis, &dummy, &cStatus)) {
         return 1;
+      }
 …
     } else {
       // Read the repeat count from TFORMnnn.
       if (fits_read_tdim(cSDptr, colnum, maxdim, naxis, naxes, &cStatus)) {
+      if (fits_read_tdim(cSDptr, colnum, maxdim, naxes, naxis, &cStatus)) {
         return 1;
+      }
 …
     tp++;
     *naxis = 0;
+    *naxes = 0;
     for (size_t j = 1; j < strlen(tdimval); j++) {
       if (tdimval[j] == ',' || tdimval[j] == ')') {
         sscanf(tp, "%ld", naxes + (*naxis)++);
+        sscanf(tp, "%ld", naxis + (*naxes)++);
         if (tdimval[j] == ')') break;
         tp = tdimval + j + 1;
 …
   findCol(name, &colnum);
   if (colnum > 0) {
+  if (colnum > 0 && iRow > 0) {
     // Read the first value from the specified row of the table.
     int  coltype;
 …
         void *value)
+{
-  char *name  = cData[iData].name;
   int  type   = cData[iData].type;
   int  colnum = cData[iData].colnum;
+  long nelem  = cData[iData].nelem;
+  if (colnum > 0) {
+  if (colnum > 0 && iRow > 0) {
     // Read the required number of values from the specified row of the table.
+    long nelem = cData[iData].nelem;
     int anynul;
     if (type == TSTRING) {
 …
   } else if (colnum == 0) {
     // Read keyword value.
+    char *name  = cData[iData].name;
     fits_read_key(cSDptr, type, name, value, 0, &cStatus);
 …
+}
 //------------------------------------------------------ SDFITSreader::findCol
 // Locate a parameter in the SDFITS file.
 void SDFITSreader::findCol(
         char *name,
         int *colnum)
+//------------------------------------------------------ SDFITSreader::readCol
+// Read a scalar column from the SDFITS file.
+int SDFITSreader::readCol(
+        int  iData,
+        void *value)
+{
+  *colnum = 0;
+  int status = 0;
+  fits_get_colnum(cSDptr, CASESEN, name, colnum, &status);
+  if (status) {
+    // Not a real column - maybe it's virtual.
+    char card[81];
+    status = 0;
+    fits_read_card(cSDptr, name, card, &status);
+    if (status) {
+      // Not virtual either.
+      *colnum = -1;
+    }
+    // Clear error messages.
+    fits_clear_errmsg();
+  }
+  int type = cData[iData].type;
+  if (cData[iData].colnum > 0) {
+    // Table column.
+    int anynul;
+    fits_read_col(cSDptr, type, cData[iData].colnum, 1, 1, cNRow, 0,
+                  value, &anynul, &cStatus);
+  } else {
+    // Header keyword.
+    readData(iData, 0, value);
+    for (int irow = 1; irow < cNRow; irow++) {
+      if (type == TSHORT) {
+        ((short *)value)[irow] = *((short *)value);
+      } else if (type == TINT) {
+        ((int *)value)[irow] = *((int *)value);
+      } else if (type == TFLOAT) {
+        ((float *)value)[irow] = *((float *)value);
+      } else if (type == TDOUBLE) {
+        ((double *)value)[irow] = *((double *)value);
+      }
+    }
+  }
+  return cData[iData].colnum < 0;
+}
+//----------------------------------------------------- SDFITSreader::readTime
+// Read the time from the SDFITS file.
+int SDFITSreader::readTime(
+        long iRow,
+        int  iPix,
+        char   *datobs,
+        double &utc)
+{
+  readData(DATE_OBS, iRow, datobs);
+  if (cData[TIME].colnum >= 0) {
+    readData(TIME, iRow, &utc);
+  } else if (cGBT) {
+    Int yy, mm ;
+    Double dd, hour, min, sec ;
+    sscanf( datobs, "%d-%d-%lfT%lf:%lf:%lf", &yy, &mm, &dd, &hour, &min, &sec ) ;
+    dd = dd + ( hour * 3600.0 + min * 60.0 + sec ) / 86400.0 ;
+    MVTime mvt( yy, mm, dd ) ;
+    dd = mvt.day() ;
+    utc = fmod( dd, 1.0 ) * 86400.0 ;
+  } else if (cNAxisTime > 1) {
+    double timeDelt, timeRefPix, timeRefVal;
+    readData(TimeRefVal, iRow, &timeRefVal);
+    readData(TimeDelt,   iRow, &timeDelt);
+    readData(TimeRefPix, iRow, &timeRefPix);
+    utc = timeRefVal + (iPix - timeRefPix) * timeDelt;
+  }
+  if (cALFA_BD) utc *= 3600.0;
+  // Check DATE-OBS format.
+  if (datobs[2] == '/') {
+    // Translate an old-format DATE-OBS.
+    datobs[9] = datobs[1];
+    datobs[8] = datobs[0];
+    datobs[2] = datobs[6];
+    datobs[5] = datobs[3];
+    datobs[3] = datobs[7];
+    datobs[6] = datobs[4];
+    datobs[7] = '-';
+    datobs[4] = '-';
+    datobs[1] = '9';
+    datobs[0] = '1';
+  } else if (datobs[10] == 'T' && cData[TIME].colnum < 0) {
+    // Dig UTC out of a new-format DATE-OBS.
+    int   hh, mm;
+    float ss;
+    sscanf(datobs+11, "%d:%d:%f", &hh, &mm, &ss);
+    utc = (hh*60 + mm)*60 + ss;
+  }
+  datobs[10] = '\0';
+  return 0;
+}
+//------------------------------------------------------ SDFITSreader::alfaCal
+// Process ALFA calibration data.
+int SDFITSreader::alfaCal(
+        short iBeam,
+        short iIF,
+        short iPol)
+{
+  const string methodName = "alfaCal()" ;
+  int  calOn;
+  char chars[32];
+  if (cALFA_BD) {
+    readData("OBS_NAME", TSTRING, cRow, chars);
+  } else {
+    readData("SCANTYPE", TSTRING, cRow, chars);
+  }
+  if (strcmp(chars, "ON") == 0) {
+    calOn = 1;
+  } else if (strcmp(chars, "OFF") == 0) {
+    calOn = 0;
+  } else {
+    return 1;
+  }
+  // Read cal data.
+  long *blc = new long[cNAxes+1];
+  long *trc = new long[cNAxes+1];
+  long *inc = new long[cNAxes+1];
+  for (int iaxis = 0; iaxis <= cNAxes; iaxis++) {
+    blc[iaxis] = 1;
+    trc[iaxis] = 1;
+    inc[iaxis] = 1;
+  }
+  // User channel selection.
+  int startChan = cStartChan[iIF];
+  int endChan   = cEndChan[iIF];
+  blc[cFreqAxis] = std::min(startChan, endChan);
+  trc[cFreqAxis] = std::max(startChan, endChan);
+  if (cALFA_CIMA > 1) {
+    // CIMAFITS 2.x has a legitimate STOKES axis...
+    blc[cStokesAxis] = iPol+1;
+    trc[cStokesAxis] = iPol+1;
+  } else {
+    // ...older ALFA data does not.
+    blc[cStokesAxis] = 1;
+    trc[cStokesAxis] = 1;
+  }
+  if (cTimeAxis >= 0) {
+    blc[cTimeAxis] = cTimeIdx;
+    trc[cTimeAxis] = cTimeIdx;
+  }
+  blc[cNAxes] = cRow;
+  trc[cNAxes] = cRow;
+  float spectrum[endChan];
+  int anynul;
+  if (fits_read_subset_flt(cSDptr, cData[DATA].colnum, cNAxes, cNAxis,
+      blc, trc, inc, 0, spectrum, &anynul, &cStatus)) {
+    log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE);
+    delete [] blc;
+    delete [] trc;
+    delete [] inc;
+    return 1;
+  }
+  // Factor to rescale according to the number of unblanked accumulations.
+  float factor = 1.0f;
+  if (cALFA_CIMA > 1) {
+    int   colnum, naccum;
+    findCol("STAT", &colnum);
+    fits_read_col(cSDptr, TINT, colnum, cRow, 2, 1, 0, &naccum, &anynul,
+                  &cStatus);
+    factor = cALFAacc / naccum;
+  }
+  // Average the spectrum.
+  float mean = 1e9f;
+  for (int k = 0; k < 2; k++) {
+    float discrim = 2.0f * mean;
+    int nChan = 0;
+    float sum = 0.0f;
+    float *chanN = spectrum + abs(endChan - startChan) + 1;
+    for (float *chan = spectrum; chan < chanN; chan++) {
+      // Simple discriminant that eliminates strong radar interference.
+      if (*chan < discrim) {
+        nChan++;
+        sum += *chan * factor;
+      }
+    }
+    mean = sum / nChan;
+  }
+  if (calOn) {
+    sALFAcalOn[iBeam][iPol]  *= sALFAcalNon[iBeam][iPol];
+    sALFAcalOn[iBeam][iPol]  += mean;
+    sALFAcalOn[iBeam][iPol]  /= ++sALFAcalNon[iBeam][iPol];
+  } else {
+    sALFAcalOff[iBeam][iPol] *= sALFAcalNoff[iBeam][iPol];
+    sALFAcalOff[iBeam][iPol] += mean;
+    sALFAcalOff[iBeam][iPol] /= ++sALFAcalNoff[iBeam][iPol];
+  }
+  if (sALFAcalNon[iBeam][iPol] && sALFAcalNoff[iBeam][iPol]) {
+    // Tcal should come from the TCAL table, it varies weakly with beam,
+    // polarization, and frequency.  However, TCAL is not written properly.
+    float Tcal = 12.0f;
+    sALFAcal[iBeam][iPol] = Tcal / (sALFAcalOn[iBeam][iPol] -
+                                    sALFAcalOff[iBeam][iPol]);
+    // Scale from K to Jy; the gain also varies weakly with beam,
+    // polarization, frequency, and zenith angle.
+    float fluxCal = 10.0f;
+    sALFAcal[iBeam][iPol] /= fluxCal;
+  }
+  return 0;
+}
+//----------------------------------------------------- SDFITSreader::alfaGain
+// ALFA gain factor.
+float SDFITSreader::alfaGain(
+        float zd)
+{
+  // Gain vs zenith distance table from Robert Minchin, 2008/12/08.
+  const int nZD = 37;
+  const float zdLim[] = {1.5f, 19.5f};
+  const float zdInc = (nZD - 1) / (zdLim[1] - zdLim[0]);
+  float zdGain[] = {                                       1.00723708,
+.16644573,  1.15003645,  1.07117307,  1.02532673,
+.01788402,  1.01369524,  1.00000000,  0.989855111,
+.990888834, 0.993996620, 0.989964068, 0.982213855,
+.978662670, 0.979349494, 0.978478372, 0.974631131,
+.972126007, 0.972835243, 0.972742677, 0.968671739,
+.963891327, 0.963452935, 0.966831207, 0.969585896,
+.970700860, 0.972644389, 0.973754644, 0.967344403,
+.952168941, 0.937160134, 0.927843094, 0.914048433,
+.886700928, 0.864701211, 0.869126320, 0.854309499};
+  float gain;
+  // Do table lookup by linear interpolation.
+  float lambda = zdInc * (zd - zdLim[0]);
+  int j = int(lambda);
+  if (j < 0) {
+    gain = zdGain[0];
+  } else if (j >= nZD-1) {
+    gain = zdGain[nZD-1];
+  } else {
+    gain = zdGain[j] + (lambda - j) * (zdGain[j+1] - zdGain[j]);
+  }
+  return gain;
+}

branches/alma/external/atnf/PKSIO/SDFITSreader.h

-              r1453
+              r1757
 //# SDFITSreader.h: ATNF CFITSIO interface class for SDFITS input.
 //#---------------------------------------------------------------------------
 //# Copyright (C) 2000-2006
 //# Associated Universities, Inc. Washington DC, USA.
+//# livedata - processing pipeline for single-dish, multibeam spectral data.
+//# Copyright (C) 2000-2009, Australia Telescope National Facility, CSIRO
 //#
+//# This library is free software; you can redistribute it and/or modify it
+//# under the terms of the GNU Library General Public License as published by
+//# the Free Software Foundation; either version 2 of the License, or (at your
+//# option) any later version.
+//# This file is part of livedata.
 //#
+//# This library is distributed in the hope that it will be useful, but WITHOUT
+//# livedata is free software: you can redistribute it and/or modify it under
+//# the terms of the GNU General Public License as published by the Free
+//# Software Foundation, either version 3 of the License, or (at your option)
+//# any later version.
+//#
+//# livedata is distributed in the hope that it will be useful, but WITHOUT
 //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 //# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
 //# License for more details.
+//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+//# more details.
 //#
+//# You should have received a copy of the GNU Library General Public License
+//# along with this library; if not, write to the Free Software Foundation,
+//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
+//# You should have received a copy of the GNU General Public License along
+//# with livedata.  If not, see <http://www.gnu.org/licenses/>.
 //#
+//# Correspondence concerning this software should be addressed as follows:
+//#        Internet email: aips2-request@nrao.edu.
+//#        Postal address: AIPS++ Project Office
+//#                        National Radio Astronomy Observatory
+//#                        520 Edgemont Road
+//#                        Charlottesville, VA 22903-2475 USA
+//# Correspondence concerning livedata may be directed to:
+//#        Internet email: mcalabre@atnf.csiro.au
+//#        Postal address: Dr. Mark Calabretta
+//#                        Australia Telescope National Facility, CSIRO
+//#                        PO Box 76
+//#                        Epping NSW 1710
+//#                        AUSTRALIA
 //#
+//# $Id$
+//# http://www.atnf.csiro.au/computing/software/livedata.html
+//# $Id: SDFITSreader.h,v 19.22 2009-09-29 07:33:39 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# The SDFITSreader class reads single dish FITS files such as those written
 …
 #include <atnf/PKSIO/FITSreader.h>
+#include <atnf/PKSIO/PKSMBrecord.h>
+#include <atnf/PKSIO/MBrecord.h>
+#include <casa/Logging/LogIO.h>
 #include <fitsio.h>
+using namespace std;
+using namespace casa;
 // <summary>
 …
         double antPos[3],
         char   obsMode[32],
+        char   bunit[32],
         float  &equinox,
         char   radecsys[32],
 …
     // Read the next data record.
+    virtual int read(PKSMBrecord &record);
+    // Print out CFITSIO error messages.
+    void reportError(void);
+    virtual int read(MBrecord &record);
     // Close the SDFITS file.
 …
   private:
+    int      cCycleNo, cExtraSysCal, cNAxis, cStatus;
+    long     cNAxes[5], cNRow, cReqax[4], cRow;
+    int      cCycleNo, cExtraSysCal, cNAxes, cStatus;
+    long     cBeamAxis, cDecAxis, cFreqAxis, cNAxis[5], cNAxisTime, cNRow,
+             cRaAxis, cRow, cStokesAxis, cTimeAxis, cTimeIdx;
     double   cLastUTC;
     fitsfile *cSDptr;
 …
     int  cBeam_1rel, cIF_1rel;
+    // for GBT
+    int *cPols ;
     enum {SCAN, CYCLE, DATE_OBS, TIME, EXPOSURE, OBJECT, OBJ_RA, OBJ_DEC,
+          RESTFRQ, OBSMODE, BEAM, IF, FqRefPix, FqRefVal, FqDelt, RA, DEC,
+          SCANRATE, TSYS, CALFCTR, XCALFCTR, BASELIN, BASESUB, DATA, FLAGGED,
+          DATAXED, XPOLDATA, REFBEAM, TCAL, TCALTIME, AZIMUTH, ELEVATIO,
+          PARANGLE, FOCUSAXI, FOCUSTAN, FOCUSROT, TAMBIENT, PRESSURE,
+          HUMIDITY, WINDSPEE, WINDDIRE, NDATA};
+          RESTFRQ, OBSMODE, BEAM, IF, FqRefVal, FqDelt, FqRefPix, RA, DEC,
+          TimeRefVal, TimeDelt, TimeRefPix, SCANRATE, TSYS, CALFCTR, XCALFCTR,
+          BASELIN, BASESUB, DATA, FLAGGED, DATAXED, XPOLDATA, REFBEAM, TCAL,
+          TCALTIME, AZIMUTH, ELEVATIO, PARANGLE, FOCUSAXI, FOCUSTAN, FOCUSROT,
+          TAMBIENT, PRESSURE, HUMIDITY, WINDSPEE, WINDDIRE, STOKES, SIG, CAL,
+          VFRAME, RVSYS, VELDEF, NDATA};
+    // Message handling.
+    void log(LogOrigin origin, LogIO::Command cmd, const char *msg = 0x0);
     void findData(int iData, char *name, int type);
+    void  findCol(char *name, int *colnum);
     int   readDim(int iData, long iRow, int *naxis, long naxes[]);
     int  readParm(char *name, int type, void *value);
     int  readData(char *name, int type, long iRow, void *value);
     int  readData(int iData, long iRow, void *value);
+    void  findCol(char *name, int *colnum);
+    int  readCol(int iData, void *value);
+    int  readTime(long iRow, int iPix, char *datobs, double &utc);
+    // These are for ALFA data, "BDFITS" or "CIMAFITS".
+    // These are for ALFA data: "BDFITS" or "CIMAFITS".  Statics are required
+    // for CIMAFITS v2.0 because CAL ON/OFF data is split into separate files.
+    static int  sInit, sReset;
+    static int  (*sALFAcalNon)[2], (*sALFAcalNoff)[2];
+    static float (*sALFAcal)[2], (*sALFAcalOn)[2], (*sALFAcalOff)[2];
     int   cALFA, cALFA_BD, cALFA_CIMA, cALFAscan, cScanNo;
+    float cALFAcal[8][2], cALFAcalOn[8][2], cALFAcalOff[8][2];
+    int   alfaCal(short iBeam, short iIF);
+    float cALFAacc;
+    int   alfaCal(short iBeam, short iIF, short iPol);
+    float alfaGain(float zd);
     // These are for GBT data.
     int   cGBT, cFirstScanNo;
+    double cGLastUTC[4] ;
+    int cGLastScan[4] ;
+    int cGCycleNo[4] ;
 };

branches/alma/external/atnf/PKSIO/SDFITSwriter.cc

-              r1453
+              r1757
 //# SDFITSwriter.cc: ATNF CFITSIO interface class for SDFITS output.
 //#---------------------------------------------------------------------------
 //# Copyright (C) 2000-2006
 //# Mark Calabretta, ATNF
+//# livedata - processing pipeline for single-dish, multibeam spectral data.
+//# Copyright (C) 2000-2009, Australia Telescope National Facility, CSIRO
 //#
+//# This library is free software; you can redistribute it and/or modify it
+//# under the terms of the GNU Library General Public License as published by
+//# the Free Software Foundation; either version 2 of the License, or (at your
+//# option) any later version.
+//# This file is part of livedata.
 //#
+//# This library is distributed in the hope that it will be useful, but WITHOUT
+//# livedata is free software: you can redistribute it and/or modify it under
+//# the terms of the GNU General Public License as published by the Free
+//# Software Foundation, either version 3 of the License, or (at your option)
+//# any later version.
+//#
+//# livedata is distributed in the hope that it will be useful, but WITHOUT
 //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 //# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
 //# License for more details.
+//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+//# more details.
 //#
+//# You should have received a copy of the GNU Library General Public License
+//# along with this library; if not, write to the Free Software Foundation,
+//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
+//# You should have received a copy of the GNU General Public License along
+//# with livedata.  If not, see <http://www.gnu.org/licenses/>.
 //#
 //# Correspondence concerning this software should be addressed as follows:
 //#        Internet email: mcalabre@atnf.csiro.au.
 //#        Postal address: Dr. Mark Calabretta,
 //#                        Australia Telescope National Facility,
 //#                        P.O. Box 76,
 //#                        Epping, NSW, 2121,
+//# Correspondence concerning livedata may be directed to:
+//#        Internet email: mcalabre@atnf.csiro.au
+//#        Postal address: Dr. Mark Calabretta
+//#                        Australia Telescope National Facility, CSIRO
+//#                        PO Box 76
+//#                        Epping NSW 1710
 //#                        AUSTRALIA
 //#
+//# $Id$
+//# http://www.atnf.csiro.au/computing/software/livedata.html
+//# $Id: SDFITSwriter.cc,v 19.18 2009-09-29 07:33:39 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# Original: 2000/07/24, Mark Calabretta, ATNF
 //#---------------------------------------------------------------------------
+#include <atnf/PKSIO/MBrecord.h>
+#include <atnf/PKSIO/SDFITSwriter.h>
+#include <casa/Logging/LogIO.h>
+#include <casa/iostream.h>
 #include <algorithm>
 #include <math.h>
+// AIPS++ includes.
+#include <casa/iostream.h>
+// ATNF includes.
+#include <atnf/PKSIO/PKSMBrecord.h>
+#include <atnf/PKSIO/SDFITSwriter.h>
+#include <cstring>
 using namespace std;
 …
 // Factor to convert radians to degrees.
 const double R2D = 180.0 / PI;
+// Class name
+const string className = "SDFITSwriter" ;
 //------------------------------------------------- SDFITSwriter::SDFITSwriter
 …
+{
   // Default constructor.
   cSDptr = 0;
+  cSDptr = 0x0;
+}
 …
         double antPos[3],
         char*  obsMode,
+        char*  bunit,
         float  equinox,
         char*  dopplerFrame,
 …
         int    extraSysCal)
+{
+  const string methodName = "create()" ;
+  if (cSDptr) {
+    log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE, "Output file already open, close it first.");
+    return 1;
+  }
   // Prepend an '!' to the output name to force it to be overwritten.
   char sdname[80];
 …
   cStatus = 0;
   if (fits_create_file(&cSDptr, sdname, &cStatus)) {
+    sprintf(cMsg, "Failed to create SDFITS file\n       %s", sdName);
+    log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE, cMsg);
     return cStatus;
+  }
 …
       break;
+    }
     if (cNChan[iIF] != cNChan[0] || cNPol[iIF] != cNPol[0]) {
       // Varying channels and/or polarizations, need a TDIM column at least.
 …
   // Write required primary header keywords.
   if (fits_write_imghdr(cSDptr, 8, 0, 0, &cStatus)) {
+    log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE, "Failed to write required primary header keywords.");
     return cStatus;
+  }
 …
   char version[7];
   char date[11];
   sscanf("$Revision: 19.10 $", "%*s%s", version);
   sscanf("$Date: 2006/07/05 05:44:52 $", "%*s%s", date);
+  sscanf("$Revision: 19.18 $", "%*s%s", version);
+  sscanf("$Date: 2009-09-29 07:33:39 $", "%*s%s", date);
   sprintf(text, "SDFITSwriter (v%s, %s)", version, date);
   fits_write_key_str(cSDptr, "ORIGIN", text, "output class", &cStatus);
 …
   fits_write_comment(cSDptr, text, &cStatus);
+  if (cStatus) {
+    log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE, "Failed in writing primary header.");
+    return cStatus;
+  }
   // Create an SDFITS extension.
   long nrow = 0;
 …
   if (fits_create_tbl(cSDptr, BINARY_TBL, nrow, ncol, NULL, NULL, NULL,
       "SINGLE DISH", &cStatus)) {
+    log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE, "Failed to create a binary table extension.");
     return 1;
+  }
 …
   // CYCLE (additional, real).
   fits_insert_col(cSDptr, ++ncol, "CYCLE", "1I", &cStatus);
+  fits_insert_col(cSDptr, ++ncol, "CYCLE", "1J", &cStatus);
   // DATE-OBS (core, real).
 …
   fits_insert_col(cSDptr, ++ncol, "TSYS", tform, &cStatus);
   sprintf(tunit, "TUNIT%d", ncol);
   fits_write_key_str(cSDptr, tunit, "Jy", "units of field", &cStatus);
+  fits_write_key_str(cSDptr, tunit, bunit, "units of field", &cStatus);
   // CALFCTR (additional, real).
 …
     // BASESUB (additional, real).
     sprintf(tform, "%dE", 9*maxNPol);
+    sprintf(tform, "%dE", 24*maxNPol);
     fits_insert_col(cSDptr, ++ncol, "BASESUB", tform, &cStatus);
     tdim[0] = 9;
+    tdim[0] = 24;
     fits_write_tdim(cSDptr, ncol, 2, tdim, &cStatus);
+  }
 …
   sprintf(tunit, "TUNIT%d", ncol);
   fits_write_key_str(cSDptr, tunit, "Jy", "units of field", &cStatus);
+  fits_write_key_str(cSDptr, tunit, bunit, "units of field", &cStatus);
   // FLAGGED (additional, logical).
 …
     sprintf(tunit, "TUNIT%d", ncol);
     fits_write_key_str(cSDptr, tunit, "Jy", "units of field", &cStatus);
+    fits_write_key_str(cSDptr, tunit, bunit, "units of field", &cStatus);
+  }
 …
+  }
+  if (cStatus) {
+    log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE, "Failed in writing binary table header.");
+  }
   return cStatus;
+}
 …
 // Write a record to the SDFITS file.
 int SDFITSwriter::write(PKSMBrecord &mbrec)
+int SDFITSwriter::write(MBrecord &mbrec)
+{
+  const string methodName = "write()" ;
+  LogIO os( LogOrigin( className, methodName, WHERE ) ) ;
   char *cptr;
 …
   int IFno = mbrec.IFno[0];
   if (IFno < 1 || cNIF < IFno) {
+    cerr << "SDFITSwriter::write: "
+         << "Invalid IF number " << IFno
+         << " (maximum " << cNIF << ")." << endl;
+    os << LogIO::WARN
+       << "SDFITSwriter::write: "
+       << "Invalid IF number " << IFno
+       << " (maximum " << cNIF << ")." << LogIO::POST ;
     return 1;
+  }
 …
   int nChan = cNChan[iIF];
   if (mbrec.nChan[0] != nChan) {
+    cerr << "SDFITSriter::write: "
+         << "Wrong number of channels for IF " << IFno << "," << endl
+         << "                    "
+         << "got " << nChan << " should be " << mbrec.nChan[0] << "." << endl;
+    os << LogIO::WARN
+       << "SDFITSriter::write: "
+       << "Wrong number of channels for IF " << IFno << "," << endl
+       << "                    "
+       << "got " << nChan << " should be " << mbrec.nChan[0] << "." << endl;
+    os << LogIO::POST ;
     return 1;
+  }
 …
   int nPol = cNPol[iIF];
   if (mbrec.nPol[0] != nPol) {
+    cerr << "SDFITSriter::write: "
+         << "Wrong number of polarizations for IF " << IFno << "," << endl
+         << "                    "
+         << "got " << nPol << " should be " << mbrec.nPol[0] << "." << endl;
+    os << LogIO::WARN
+       << "SDFITSriter::write: "
+       << "Wrong number of polarizations for IF " << IFno << "," << endl
+       << "                    "
+       << "got " << nPol << " should be " << mbrec.nPol[0] << "." << endl;
+    os << LogIO::POST ;
     return 1;
+  }
 …
     // BASESUB.
     fits_write_col_flt(cSDptr, ++icol, cRow, 1, 9*nPol, mbrec.baseSub[0][0],
+    fits_write_col_flt(cSDptr, ++icol, cRow, 1, 24*nPol, mbrec.baseSub[0][0],
                        &cStatus);
+  }
 …
+  }
+  if (cStatus) {
+    log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE, "Failed in writing binary table entry.");
+  }
   return cStatus;
+}
 //-------------------------------------------------- SDFITSwriter::reportError
 // Print the error message corresponding to the input status value and all the
+// messages on the CFITSIO error stack to stderr.
+void SDFITSwriter::reportError()
+//------------------------------------------------------ SDFITSwriter::history
+// Write a history record.
+int SDFITSwriter::history(char *text)
+{
+  fits_report_error(stderr, cStatus);
+  const string methodName = "history()" ;
+  if (!cSDptr) {
+    return 1;
+  }
+  if (fits_write_history(cSDptr, text, &cStatus)) {
+    log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE, "Failed in writing HISTORY records.");
+  }
+  return cStatus;
+}
 …
 void SDFITSwriter::close()
+{
+  const string methodName = "close()" ;
   if (cSDptr) {
     cStatus = 0;
+    fits_close_file(cSDptr, &cStatus);
+    if (fits_close_file(cSDptr, &cStatus)) {
+      log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE, "Failed to close file.");
+    }
     cSDptr = 0;
+  }
 …
 void SDFITSwriter::deleteFile()
+{
+  const string methodName = "deleteFile()" ;
   if (cSDptr) {
     cStatus = 0;
+    fits_delete_file(cSDptr, &cStatus);
+    if (fits_delete_file(cSDptr, &cStatus)) {
+      log(LogOrigin( className, methodName, WHERE ), LogIO::SEVERE, "Failed to close and delete file.");
+    }
     cSDptr = 0;
+  }
+}
+//------------------------------------------------------- SDFITSwriter::log
+// Log a message.  If the current CFITSIO status value is non-zero, also log
+// the corresponding error message and dump the CFITSIO message stack.
+void SDFITSwriter::log(LogOrigin origin, LogIO::Command cmd, const char *msg)
+{
+  LogIO os( origin ) ;
+  os << cmd << msg << endl ;
+  if (cStatus) {
+    fits_get_errstatus(cStatus, cMsg);
+    os << cMsg << endl ;
+    while (fits_read_errmsg(cMsg)) {
+      os << cMsg << endl ;
+    }
+  }
+  os << LogIO::POST ;
+}

branches/alma/external/atnf/PKSIO/SDFITSwriter.h

-              r1453
+              r1757
 //# SDFITSwriter.h: ATNF CFITSIO interface class for SDFITS output.
 //#---------------------------------------------------------------------------
 //# Copyright (C) 2000-2006
 //# Mark Calabretta, ATNF
+//# livedata - processing pipeline for single-dish, multibeam spectral data.
+//# Copyright (C) 2000-2009, Australia Telescope National Facility, CSIRO
 //#
+//# This library is free software; you can redistribute it and/or modify it
+//# under the terms of the GNU Library General Public License as published by
+//# the Free Software Foundation; either version 2 of the License, or (at your
+//# option) any later version.
+//# This file is part of livedata.
 //#
+//# This library is distributed in the hope that it will be useful, but WITHOUT
+//# livedata is free software: you can redistribute it and/or modify it under
+//# the terms of the GNU General Public License as published by the Free
+//# Software Foundation, either version 3 of the License, or (at your option)
+//# any later version.
+//#
+//# livedata is distributed in the hope that it will be useful, but WITHOUT
 //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 //# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
 //# License for more details.
+//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+//# more details.
 //#
+//# You should have received a copy of the GNU Library General Public License
+//# along with this library; if not, write to the Free Software Foundation,
+//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
+//# You should have received a copy of the GNU General Public License along
+//# with livedata.  If not, see <http://www.gnu.org/licenses/>.
 //#
 //# Correspondence concerning this software should be addressed as follows:
 //#        Internet email: mcalabre@atnf.csiro.au.
 //#        Postal address: Dr. Mark Calabretta,
 //#                        Australia Telescope National Facility,
 //#                        P.O. Box 76,
 //#                        Epping, NSW, 2121,
+//# Correspondence concerning livedata may be directed to:
+//#        Internet email: mcalabre@atnf.csiro.au
+//#        Postal address: Dr. Mark Calabretta
+//#                        Australia Telescope National Facility, CSIRO
+//#                        PO Box 76
+//#                        Epping NSW 1710
 //#                        AUSTRALIA
 //#
+//# $Id$
+//# http://www.atnf.csiro.au/computing/software/livedata.html
+//# $Id: SDFITSwriter.h,v 19.10 2009-09-29 07:33:39 cal103 Exp $
 //#---------------------------------------------------------------------------
 //# Original: 2000/07/24, Mark Calabretta, ATNF
 …
 #define ATNF_SDFITSWRITER_H
+#include <atnf/PKSIO/PKSMBrecord.h>
+#include <atnf/PKSIO/MBrecord.h>
+#include <casa/Logging/LogIO.h>
 #include <fitsio.h>
+using namespace std;
+using namespace casa;
 // <summary>
 …
     // Destructor.
     ~SDFITSwriter();
+    virtual ~SDFITSwriter();
     // Create a new SDFITSwriter and store static data.
 …
         double antPos[3],
         char*  obsMode,
+        char*  bunit,
         float  equinox,
         char*  dopplerFrame,
 …
     // Store time-variable data.
     int write(PKSMBrecord &record);
+    int write(MBrecord &record);
     // Print out CFITSIO error messages.
     void reportError();
+    // Write a history record.
+    int history(char* text);
     // Close the SDFITS file.
 …
          *cNChan, cNIF, *cNPol, cStatus;
     long cRow;
+    // Message handling.
+    char cMsg[256];
+    void log(LogOrigin origin, LogIO::Command cmd, const char *msg = 0x0);
 };

branches/alma/external/atnf/PKSIO/makefile

-              r1325
+              r1757
 # $Id: makefile,v 19.0 2003/07/16 03:34:05 aips2adm Exp $
+# $Id$
 XLIBLIST := CFITSIO RPFITS
 …
 # Use the generic AIPS++ class implementation makefile.
 #------------------------------------------------------
 include $(word 1, $(AIPSPATH))/code/install/makefile.imp
+include $(word 1, $(CASAPATH))/code/install/makefile.imp

Context Navigation

Legend:

branches/alma

branches/alma/external/atnf/PKSIO/FITSreader.cc

branches/alma/external/atnf/PKSIO/FITSreader.h

branches/alma/external/atnf/PKSIO/MBFITSreader.cc

branches/alma/external/atnf/PKSIO/MBFITSreader.h

branches/alma/external/atnf/PKSIO/MBrecord.cc

branches/alma/external/atnf/PKSIO/MBrecord.h

branches/alma/external/atnf/PKSIO/PKSFITSreader.cc

branches/alma/external/atnf/PKSIO/PKSFITSreader.h

branches/alma/external/atnf/PKSIO/PKSMS2reader.cc

branches/alma/external/atnf/PKSIO/PKSMS2reader.h

branches/alma/external/atnf/PKSIO/PKSMS2writer.cc

branches/alma/external/atnf/PKSIO/PKSMS2writer.h

branches/alma/external/atnf/PKSIO/PKSSDwriter.cc

branches/alma/external/atnf/PKSIO/PKSSDwriter.h

branches/alma/external/atnf/PKSIO/PKSreader.cc

branches/alma/external/atnf/PKSIO/PKSreader.h

branches/alma/external/atnf/PKSIO/PKSrecord.h

branches/alma/external/atnf/PKSIO/PKSwriter.h

branches/alma/external/atnf/PKSIO/SDFITSreader.cc

branches/alma/external/atnf/PKSIO/SDFITSreader.h

branches/alma/external/atnf/PKSIO/SDFITSwriter.cc

branches/alma/external/atnf/PKSIO/SDFITSwriter.h

branches/alma/external/atnf/PKSIO/makefile

Download in other formats: