Changeset 1757

branches/alma

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

branches/alma/COPYING

r1042	r1757
1		Copyright (C) 2004~~,2005,2006~~
2		ATNF
	1	Copyright (C) 2004-2009
	2	CSIRO
3	3
4	4	This program is free software; you can redistribute it and/or modify it

branches/alma/INSTALL

-              r1194
+              r1757
 ============
+* scons
+* scons >= 1.1
+* rpfits >= 2.19
+* cfitso >= 2
+* python >= 2.4
+* boost >= 1.37
+* casacore >= 1.0
 Installation
 …
 scons has several targets. It is recommended to execute them sequentially.
+The normal install procedure is as follows:
+   . <path_to_casa_asap>/aipsinit.sh
+The normal install procedure is as follows
+.. code::
    scons
    # Do this if you haven't got a data directory already
+   # Do this if you haven't got a measures data directory already
    export ASAPDATA=.
    ./bin/asap_update_data
 …
 Obtaining the data directory
 ============================
+The data repository can be obtained seperately after installing ASAP.
+Before you run asap for the first time simply run
+The data repository can be obtained separately after installing ASAP.
+Before you run asap for the first time simply run::
     asap_update_data
 This will install the data repository into the correct location.
 There are several ways to do this.
+a) If you already hae the 'data' directory, copy it to the root directory and run the normal install procedure.
+a) If you already have the 'data' directory, copy it to the root directory and run the normal install procedure::
    scons
    scons install
 b) You can obtain the data repository from the ftp site.
+   Simply run
+   Simply run::
         export ASAPDATA=.
         ./bin/asap_update_data
    This will retrieve and unpack the data directory.
+   After this run:
+   After this run::
         scons install
 …
 ==============================
 after building using 'scons', you can create a compressed tarball of the binaries. This is done via the target 'makedist='. The argument should be an obvious identifier for the system you want to support, e.g. 'sarge' or 'fc5-x86_64'
+after building using 'scons', you can create a compressed tarball of the binaries. This is done via the target 'makedist='. The argument should be an obvious identifier for the system you want to support, e.g. 'sarge' or 'fc5-x86_64'::
     scons makedist=sarge

branches/alma/SConstruct

-              r1377
+              r1757
 moduledir = distutils.sysconfig.get_python_lib()
+if  platform.architecture()[0] == '64bit':
+if sys.platform.startswith('linux') and platform.architecture()[0] == '64bit':
     # hack to install into /usr/lib64 if scons is in the 32bit /usr/lib/
     if moduledir.startswith("/usr/lib/"):
         moduledir = moduledir.replace("lib", "lib64")
+opts = Options("options.cfg")
+opts.AddOptions(
+EnsureSConsVersion(1,1,0)
+opts = Variables("options.cfg")
+opts.AddVariables(
                 ("FORTRAN", "The fortran compiler", None),
                 ("f2clib", "The fortran to c library", None),
                 PathOption("prefix",
+                PathVariable("prefix",
                 "The root installation path",
                            distutils.sysconfig.PREFIX),
                 PathOption("moduledir",
+                PathVariable("moduledir",
                             "The python module path (site-packages))",
                             moduledir),
                 PathOption("casacoreroot", "The location of casacore",
                                     "/usr/local"),
+                PathVariable("casacoreroot", "The location of casacore",
+                             "/usr/local"),
                 ("boostroot", "The root dir where boost is installed", None),
                 ("boostlib", "The name of the boost python library",
 …
                 ("cfitsiolib", "The cfitsio library name", "cfitsio"),
                 ("cfitsioincdir", "The cfitsio include location", None),
+                ("wcslib", "The wcs library name", "wcs"),
                 ("wcsroot",
                  "The root directory where wcs is installed", None),
 …
                  "The root directory where rpfits is installed", None),
                 ("rpfitslibdir", "The rpfits library location", None),
+#               ("rpfitsincdir", "The rpfits include location", None),
+                EnumOption("mode", "The type of build.", "debug",
+                ("pyraproot", "The root directory where libpyrap is installed",
+                 None),
+                ("pyraplib", "The name of the pyrap library", "pyrap"),
+                ("pyraplibdir", "The directory where libpyrap is installed",
+                 None),
+                ("pyrapincdir", "The pyrap include location",
+                 None),
+                BoolVariable("enable_pyrap", "Use pyrap conversion library",
+                             False),
+                EnumVariable("mode", "The type of build.", "release",
                            ["release","debug"], ignorecase=1),
                 ("makedist",
                  "Make a binary archive giving a suffix, e.g. sarge or fc5",
                  ""),
                 EnumOption("makedoc", "Build the userguide in specified format",
+                EnumVariable("makedoc", "Build the userguide in specified format",
                            "none",
+                           ["none", "pdf", "html"], ignorecase=1)
+                           ["none", "pdf", "html"], ignorecase=1),
+                BoolVariable("apps", "Build cpp apps", True),
+                BoolVariable("alma", "Enable alma specific functionality",
+                             False),
+                )
 …
 env.SConsignFile()
-if env["PLATFORM"] == "darwin":
-    env.EnsureSConsVersion(0,96,95)
 casacoretooldir = os.path.join(env["casacoreroot"],"share",
                                    "casacore")
 …
 # load casacore specific build flags
+env.Tool('casaoptions', [casacoretooldir])
+opts.Update(env)
 env.Tool('casa', [casacoretooldir])
 …
                                                "include", "casacore"))
     if not conf.CheckLib("casa_casa", language='c++'): Exit(1)
     conf.env.PrependUnique(LIBS=["casa_ms", "casa_components",
+    conf.env.PrependUnique(LIBS=["casa_images", "casa_ms", "casa_components",
                                  "casa_coordinates", "casa_lattices",
                                  "casa_fits", "casa_measures", "casa_scimath",
 …
     conf.env.AddCustomPackage('boost')
     if not conf.CheckLibWithHeader(env["boostlib"],
+    if not conf.CheckLibWithHeader(conf.env["boostlib"],
                                    'boost/python.hpp', language='c++'):
         Exit(1)
+    conf.env.AddCustomPackage('pyrap')
+    if  conf.env.get("enable_pyrap") and conf.CheckLib(conf.env["pyraplib"],
+                                                       language='c++',
+                                                       autoadd=0):
+        conf.env.Append(CPPFLAGS=['-DHAVE_PYRAP'])
+        conf.env.PrependUnique(LIBS=env['pyraplib'])
     # test for cfitsio
     if not conf.CheckLib("m"): Exit(1)
 …
         Exit(1)
     conf.env.AddCustomPackage('wcs')
+    if not conf.CheckLibWithHeader('wcs', 'wcslib/wcs.h', language='c'):
+    if not conf.CheckLibWithHeader(conf.env["wcslib"],
+                                   'wcslib/wcs.h', language='c'):
         Exit(1)
     conf.env.AddCustomPackage('rpfits')
 …
     # test for blas/lapack
+    lapackname = conf.env.get("lapacklib", "lapack")
     conf.env.AddCustomPackage("lapack")
     if not conf.CheckLib(conf.env["lapacklib"]): Exit(1)
+    if not conf.CheckLib(lapackname): Exit(1)
     blasname = conf.env.get("blaslib", "blas")
     conf.env.AddCustomPackage("blas")
     if not conf.CheckLib(conf.env["blaslib"]): Exit(1)
+    if not conf.CheckLib(blasname): Exit(1)
     conf.env.CheckFortran(conf)
     if not conf.CheckLib('stdc++', language='c++'): Exit(1)
+    if conf.env["alma"]:
+        conf.env.Append(CPPFLAGS=['-DUSE_ALMA'])
     env = conf.Finish()
 env["version"] = "2.2.x"
+env["version"] = "3.0.0"
 if env['mode'] == 'release':
 …
     env.Append(CCFLAGS=["-O2"])
 else:
     env.Append(CCFLAGS=["-g"])
+    env.Append(CCFLAGS=["-g", "-Wall"])
 # Export for SConscript files
 …
 # install targets
+somod = env.Install("$moduledir/asap", so )
+pymods = env.Install("$moduledir/asap", env.SGlob("python/*.py"))
+bins = env.Install("$prefix/bin", ["bin/asap", "bin/asap_update_data"])
+shares = env.Install("$moduledir/asap/data", "share/ipythonrc-asap")
+env.Alias('install', [somod, pymods, bins, shares])
+installs = []
+installs.append(env.Install("$moduledir/asap", so))
+installs.append(env.Install("$moduledir/asap", env.SGlob("python/*.py")))
+installs.append(env.Install("$prefix/bin",
+                            ["bin/asap", "bin/asap_update_data"]))
+installs.append(env.Install("$moduledir/asap/data", "share/ipythonrc-asap"))
+installs.append(env.Install("$moduledir/asap/data", "share/ipy_user_conf.py"))
+env.Alias('install', installs)
 # install aips++ data repos
 rootdir=None
+rootdir = None
 outdir =  os.path.join(env["moduledir"],'asap','data')
 sources = ['ephemerides','geodetic']
 …
     env.QInstall("$stagedir", ["bin/install"])
     env.QInstall("$stagedir/asap/data", "share/ipythonrc-asap")
+    env.QInstall("$stagedir/asap/data", "share/ipy_user_conf.py")
     if rootdir is not None:
         # This creates a directory Using data table... - disabled
 …
     env.SConscript("doc/SConscript")
+if env["apps"]:
+    env.SConscript("apps/SConscript")
 if env.GetOption("clean"):
     Execute(Delete(".sconf_temp"))

branches/alma/bin/asap

r1210	r1757
51	51	fi
52	52	# now execute ipython using the profile
53		$ip -ipythondir "${HOME}/.asap" ~~-p 'asap'~~ $*
	53	$ip -ipythondir "${HOME}/.asap" $*
54	54	fi

branches/alma/bin/install

-              r1232
+              r1757
     lddopts = ""
     if (sys.platform == "darwin"):
         lddcommand = "otool"
+        lddcommand = "/usr/bin/otool"
         lddopts = "-L"
     if not os.path.isfile(lddcommand):
 …
     resolved = []
     unresolved = []
+    for l in p.readlines():
+        lsp = l.split()
+        # test this to avoid fails on linux_gate, which has no library
+        if len(lsp) >= 3:
+            if lsp[2] == "not":
+                unresolved.append(lsp[0])
+    if sys.platform == "linux2":
+        for l in p.readlines():
+            lsp = l.split()
+            # test this to avoid fails on linux_gate, which has no library
+            if len(lsp) >= 3:
+                if lsp[2] == "not":
+                    unresolved.append(lsp[0])
+                else:
+                    resolved.append(lsp[2])
+    elif sys.platform == "darwin":
+        for l in p.readlines():
+            l = l.strip()
+            if l.endswith(":"):
+                continue
+            l = l.split()[0]
+            if not os.path.exists(l):
+                unresolved.append(l)
             else:
                 resolved.append(lsp[2])
+                resolved.append(l)
     return resolved, unresolved
 try:
 …
     print "Installing asap  scripts in %s" % bindir
     if moduledir != sysmoduledir:
         import sre
+        import re
         print "Changing asap startup script to use custom PYTHONPATH"
         inf = file("bin/asap")
 …
         shutil.copy2("bin/asap", bindir)
     shutil.copy2("bin/asap_update_data", bindir)
+    shutil.copy2("bin/asap2to3", bindir)
     if not os.path.exists("asap/data/ephemerides"):
         print "Warning - no data directory present"

branches/alma/doc/CHANGELOG

-              r1381
+              r1757
 =========
 Release 2.2.1 [2007-??-??]
+Release 3.0.0 [2010-05-06]
+* source direction for Hobart data - Ticket #109
+* added running median to scantable.(smooth(kernel='rmedian')
+* BEWARE: added asap2to3 which converts '.asap' files from version 2 to
+          version 3
+* Ticket #183 Added scantable.get_weather
+* Ticket #181 Added work-around for casacore bug in saving tables with
+              selection
+* Ticket #178 Added opacity_model based on  miriad's atmospheric model
+* Ticket #177 Added function skydip to determine opacities.
+* Ticket #172 Fixed non-working scantable.resample
+* Ticket #155 Better output filenames. Ignore non-existsing
+              beams/pols/ifs/scans
+* Ticket #157 numpy >= 1.1 support
+* Ticket #158 fixed plotter.set_font
+* Ticket #160 Aspect ratio of plotter is customisable now
+* Ticket #163 fixed for scantable.set_sourcetype
+* Ticket #164 Upgrade note in wiki FAQ
+* Ticket #165 Handle non-parallactified polarimtery data (if supported in
+              rpfits)
+* Ticket #167 Added running polynomial filter to scantable.smooth
+* Ticket #168 Data exported via scantable.save now contains correct frequency
+              or velocity information
+* Ticket #169 Simplified selection of data
+* Ticket #46  Interactive lag flagging
+* Ticket #170 Provided access to frequency coordinate information via
+              scantable.get_coordinate
+* Added OS X 10.5 Disk image installer
+* Added support for OS X 10.6
+* Interactive plotting annotations via optional argument interactive=True
+* Interactive creation of masks on the plotter - plotter.create_mask
+* Tidy up date range in asapplotter.plotazel/plotpointings
+* support for gcc-4.4
+Release 2.3.1 [2009-03-25]
+* Ticket #154 Flagged data wasn't hnoured in fitting
+* Ticket #153 plotter.plot_lines fixed for matplotlib >= 0.98
+* Ticket #90  Support integer values for frequencies/errors/intensities
+Release 2.3.0 [2009-03-13]
+* Ticket #150 fix in casacore for frequency frame conversions
+* Ticket #151 added rc parameter and function set_sourcetype to identify
+              on/off scans
+* Ticket #78/#112 Resolved the issue with random errors occuring under linux
+                  for large
+   data files, which corrupted the identifaction of off scans
+* Ticket #149 Fixed the bug causing spectral line search to go into an
+              infinite loop in some rare circumstances
+* Ticket #110 Added export to CLASS readable FITS files
+   scantable.save("myfile.fits", "CLASS")
+* Ticket #142 Fix of the frequency alignment for long observations
+* Ticket #133 allow supression of history in the scantable via rc parameters
+* Ticket #109 source direction for Hobart data
+* Ticket #115 added running median to scantable.(smooth(kernel='rmedian')
+* Ticket #148 opacity correction wasn't applied to TSYS
+* Ticket #135 quotient detection failure for specific source names
+* Ticket #140 NaN values not handled - added scantable.flag_nans to ensure
+              that the NaN are flagged
+* added python iterator access to scantable rows
+* made functions available to directly manipulate spectra
+  scantable.get/set_spectrum
+* upgrade to support ipython >= 0.8.1
+* support gcc-4.3
+* use scons >= 1.1.0
+* update to latest livedata I/O functions
+* add WCS info to the exported text files
 Release 2.2.0 [2007-05-02]
 …
 * fix for Ticket #88 - numpy masks
 * better TAB completion for ipython (handles quotes, don't list private members)
 * Fix for Ticket #81 = scanatble.stats output as list
+* Fix for Ticket #81 = scanatble.stats output as list
 * ticket #64 - speed up of auto_poly_baseline
 * fix for ticket #89 - export of IF sub-selections

branches/alma/doc/userguide.tex

-              r1347
+              r1757
 \setlength{\parskip}{1ex}
 \title{ATNF Spectral Analysis Package\\User Guide v2.1\\DRAFT }
+\title{ATNF Spectral Analysis Package\\User Guide v2.3 }
 \author{Chris Phillips}
 …
 package.
 This userguide has been updated for the ASAP 2.1. Please report any
+This userguide has been updated for the ASAP 2.3. Please report any
 mistakes you find.
 …
 \item Epping - use hosts {\tt draco} or {\tt hydra}
 \item Narrabri - use host {\tt kaputar}
 \item Parkes - use host {\tt bourbon}
 \item Mopra - use host {\tt minos}
+\item Parkes - use host {\tt ?}
+\item Mopra - use host {\tt minos} or {\tt kaputar} if at Narrabri
 \end{itemize}
 Or use your own Linux desktop.
 {\em Note. ASAP2.1 only runs on ATNF Linux machines which have been
+{\em Note. ASAP2.2 only runs on ATNF Linux machines which have been
 updated to Debian Sarge and are using the ``DEBIANSarge''
 /usr/local. If your favourite machine has not been upgraded, send a
+request to your friendly IT support. At the time of writing asap 2.1
+does not run on hydra, bourbon or kaputar.}
+request to your friendly IT support.}
 \index{Running}To start asap log onto one of these Linux hosts and enter
 …
 is un-ambiguous, or a list of possibilities will be
 given. Auto-completion works for the user object names as well as
 function names. It does not work for filenames, nor for function
+function names and even file names It does not work for for function
 arguments.
 …
   ASAP>ls
   ASAP>cd /my/data/directory
   ASAP>! mozilla&
+  ASAP>! firefox&
 \end{verbatim}
 …
   # Equivalent to brief summary function call
   ASAP>print scan
+  ASAP>print scans
 \end{verbatim}
 …
   ASAP>selection.reset()              # Turn off selection
   ASAP>scans.set_selection(selection) # Apply the reset selection
+  ASAP>scans.set_selection() # alternative to reset selection
 \end{verbatim}
 …
 \begin{verbatim}
   ASAP>scans = scantable('2004-11-23_1841-P484.rpf') # Read in the data
   ASAP>scans.set_freqframe('LSRK')  # Use the LSR velocity frame
+  ASAP>scans.set_freqframe('LSRK')   # Use the LSR velocity frame
   ASAP>scans.set_unit('km/s')        # Use velocity for plots etc from now on
   ASAP>scans.set_doppler('OPTICAL')  # Use the optical velocity convention
 …
   # Select channel range for baselining
   ASAP>scans.set_unit('channels')
+  ASAP>scans.set_unit('channel')
   ASAP>msk = scans.create_mask([100,400],[600,800])
 …
 Example :
 \begin{verbatim}
   ASAP>scans.set_unit('channels')
+  ASAP>scans.set_unit('channel')
   ASAP>msk = scans.create_mask([0,100],[900-1023], invert=True)
 \end{verbatim}
 …
 \begin{verbatim}
   ASAP>scans.set_unit('channels')
+  ASAP>scans.set_unit('channel')
   ASAP>msk1 = q.create_mask([0,100],[511,511],[900,1023],invert=True)
   ASAP>scans.set_unit('km/s')
 …
 \subsection{Reader object}
 \index{Reader object}\index{Scantable!reader object}For more control
 when reading data into ASAP, the reader object should be used.  This
 has the option of only reading in a range of integrations, only a
 specified beam or IF and does not perform any scan averaging of the
 data, allowing analysis of the individual integrations.  Note that due
 to limitation of the RPFITS library, only one reader object can be
 open at one time reading RPFITS files.  To read multiple RPFITS files,
 the old reader must be destroyed before the new file is opened.
 However, multiple readers can be created and attached to SDFITS files.
 Example usage:
 \begin{verbatim}
   ASAP>r = reader('2003-03-16_082048_t0002.rpf')
   ASAP>r.summary()
   ASAP>scan = r.read()
   ASAP>del r
 \end{verbatim}
+%\subsection{Reader object}
+%\index{Reader object}\index{Scantable!reader object}For more control
+%when reading data into ASAP, the reader object should be used.  This
+%has the option of only reading in a range of integrations, only a
+%specified beam or IF and does not perform any scan averaging of the
+%data, allowing analysis of the individual integrations.  Note that due
+%to limitation of the RPFITS library, only one reader object can be
+%open at one time reading RPFITS files.  To read multiple RPFITS files,
+%the old reader must be destroyed before the new file is opened.
+%However, multiple readers can be created and attached to SDFITS files.
+%
+%
+%Example usage:
+%
+%\begin{verbatim}
+%  ASAP>r = reader('2003-03-16_082048_t0002.rpf')
+%  ASAP>r.summary()
+%  ASAP>scan = r.read()
+%  ASAP>del r
+%\end{verbatim}
 \section{Basic Processing}
 …
 have a trailing ``\_R'' in the source name for data from Parkes and
 Mopra, and a trailing ``e'' or ``w'' for data from Tidbinbilla.
 This functions has two \cmd{mode}s. \cmd{paired} (the deafault), which assumes
+This functions has two \cmd{mode}s. \cmd{paired} (the default), which assumes
 matching adjacent pairs of source/reference scans and \cmd{time}, which finds
 the closest reference scan in time.
 …
 telescope is wrong due to an incorrect noise diode calibration. This
 can easily be corrected for with the scale function. By default,
 \cmd{scale} only scans the spectra and not the corresponding Tsys.
+\cmd{scale} only scaless the spectra and not the corresponding Tsys.
 \begin{verbatim}
 …
 \begin{verbatim}
   ASAP>scans.recalc_azel()                # recalculate az/el
                                                                   # based on pointing
+                                          # based on pointing
 \end{verbatim}
 …
 \end{verbatim}
+One can also apply the inverse of \cmd{get\_scan} \cmd{drop\_scan}
 To copy a scantable the following does not work:
 …
   it.
+%\item[FITS] This uses simple ``image'' fits to save the data, each row
+%  being written to a separate fits file. This format is suitable for
+%  importing the data into CLASS.
+\item[FITS] This uses simple ``image'' fits to save the data, each row
+  being written to a separate fits file.
+\item[CLASS] This uses simple ``image'' fits to save the data, each row
+  being written to a separate fits file. This format has modification so it
+  is suitable for importing the data into CLASS.
 \item[ASCII] A simple text based format suitable for the user to
 …
 \end{verbatim}
 For data with many IFs, such as from MOPS, the user it is recommended
 that the user creates their own line cstalog for the data and use this
+For data with many IFs, such as from MOPS, it is recommended
+that users creates their own line catalog table for the data and use this
 to set the rest frequency for each IF.
 …
 size of the dataset which can be loaded. ASAP can use ``disk based''
 scan tables which cache the bulk of the scantable on disk and require
 significantly less memory usage.
+significantly less memory usage. This should be used for all MOPS data!
 To use disk based tables you either need to change the default in your
 …
 {\bf NOTE: } Currently a bug in ipython means temporary files are not
 cleaned up properly when you exit ASAP. If you use disk based scan
 tables your directory will be left with 'tabXXXXX\_X' directories. These can
+tables your directory will be left with 'tmpXXXXX\_X' directories. These can
 be safely removed if ASAP is not running.
 …
 {\em Currently mathematics between two scantables is not available }
-%  ASAP>sum = scan1+scan2
 \begin{verbatim}
   ASAP>scan2 = scan1+2.0
   ASAP>scan *= 1.05
+  ASAP>sum = scan1+scan2
 \end{verbatim}
 …
 \hspace{1cm} http://www.python.org/doc/Introduction.html
+\hspace{1cm} http:/ipython.scipy.org
 \subsection{Running scripts}

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

branches/alma/external/atnf/pks/makefile

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

branches/alma/external/atnf/pks/pks_maths.cc

-              r1325
+              r1757
 //# pks_maths.cc: Mathematical functions for Parkes single-dish data reduction
 //#---------------------------------------------------------------------------
+//# Copyright (C) 1994-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) 2004-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
+//#
+//# Original: Mark Calabretta
+//# $Id: pks_maths.cc,v 1.5 2006/05/19 00:12:35 mcalabre Exp $
+//----------------------------------------------------------------------------
+//# 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: pks_maths.cc,v 1.7 2009-09-29 07:45:02 cal103 Exp $
+//#---------------------------------------------------------------------------
+//# Original: 2004/07/16 Mark Calabretta
+//#---------------------------------------------------------------------------
 // AIPS++ includes.
 …
 //----------------------------------------------------------------------- azel
+// Convert (ra,dec) to (az,el), from
+// http://aa.usno.navy.mil/faq/docs/Alt_Az.html.  Position as a Cartesian
+// triplet in m, UT1 in MJD form, and all angles in radian.
+// Convert (ra,dec) to (az,el).  Position as a Cartesian triplet in m, UT1 in
+// MJD form, and all angles in radian.
 void azel(const Vector<Double> position, Double ut1, Double ra, Double dec,
           Double &az, Double &el)
+{
   // Get gocentric longitude and latitude (rad).
+  // Get geocentric longitude and latitude (rad).
   Double x = position(0);
   Double y = position(1);
 …
   // Azimuth and elevation (rad).
+  az = atan2(cos(dec)*sin(ha), cos(dec)*sin(lat)*cos(ha) - sin(dec)*cos(lat));
+  az = atan2(cos(dec)*sin(ha),
+             cos(dec)*sin(lat)*cos(ha) - sin(dec)*cos(lat));
   if (az < 0.0) az += C::_2pi;
+  el = asin(cos(dec)*cos(lat)*cos(ha) + sin(dec)*sin(lat));
+  el = asin(sin(dec)*sin(lat) + cos(dec)*cos(lat)*cos(ha));
+}

branches/alma/external/atnf/pks/pks_maths.h

-              r1325
+              r1757
 //----------------------------------------------------------------------------
+//#---------------------------------------------------------------------------
 //# pks_maths.h: Mathematical functions for Parkes single dish data reduction
 //----------------------------------------------------------------------------
 //# Copyright (C) 1994-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
 //#
+//# Original: Mark Calabretta
+//# $Id: pks_maths.h,v 1.6 2006/05/19 00:12:06 mcalabre Exp $
+//----------------------------------------------------------------------------
+//# http://www.atnf.csiro.au/computing/software/livedata.html
+//# $Id: pks_maths.h,v 1.7 2009-09-29 07:45:02 cal103 Exp $
+//#---------------------------------------------------------------------------
+//# Original: 2004/07/16 Mark Calabretta
+//#---------------------------------------------------------------------------
 #ifndef ATNF_PKS_MATHS_H
 #define ATNF_PKS_MATHS_H

branches/alma/monitor/cgi-bin/asapconfig.py

-              r712
+              r1757
                'lines' : {} }
+asapmonhome = "/var/www/htdocs"
+asapmonrel = "/asapmon/"
 import os,sys
-# This is where asap lives
-sys.path.insert(2,'/opt/lib/python2.3/site-packages')
-os.environ["AIPSPATH"]="/opt/share/asap linux_gnu somewhere localhost"
-#overwrite /usr/local/... as default
-sys.path.insert(2,'/usr/lib/python2.3/site-packages')
-# This is needed for plotting with matplotlib
-# where matplotlib data is located
-os.environ["MATPLOTLIBDATA"]="/opt/share/matplotlib"
 # where matplotlib puts it temporary font files
 # this location can also have a custom .matplotlibrc
 os.environ["HOME"]="/var/www/asapmon/tmp"
+os.environ["HOME"]="/var/www/htdocs/asapmon/tmp"

branches/alma/monitor/cgi-bin/asapmon.py

-              r1295
+              r1757
 from simpletal import simpleTAL, simpleTALES
-#absolute home
-abspath= "/var/www/asapmon/"
-cgiloc = "/cgi-bin/asapmon/"
-tmppath = os.path.join(abspath,"tmp/")
-htmlloc = "/asapmon/"
-tmploc = "/asapmon/tmp/"
 from obsconfig import *
+tmppath = os.path.join(asapmonhome,"tmp/")
+tmppath = os.path.join(asapmonrel,"tmp/")
 # a redirection object for stdout/stderr
 …
 sys.stderr = logsink2
 import asap
+asap.rc('scantable', storage="memory")
 sys.stdout = sys.__stdout__
 sys.stderr = sys.__stderr__
 …
     def decodeWindow(self,window):
         if not len(window.strip()): return None,None
         x = window.split(", ")
+        x = window.split(",")
         return [float(x[0].strip()), float(x[1].strip())]
 …
             else:
                 # get only the last source in the table if not averaging
+                s = s.get_scan(self.fields['sourcenames'][-1])
+                #self.fields['debug'] = "DEBUG"
+                # This doesn't work anymore, but works on the command-line??
+                # Use explict selection
+                #s = s.get_scan(str(self.fields['sourcenames'][-1]))
+                sel = asap.selector()
+                sel.set_name(str(self.fields['sourcenames'][-1]))
+                s.set_selection(sel)
+                s = s.copy()
                 self.fields['csource'] = s.get_sourcename()[-1]
             if self.fields['cunit'] == 1:
+                srest = s._getrestfreqs()
+                if isinstance(srest, tuple) and len(srest) != s.nif():
+                    s.set_restfreqs(restfs, unit="GHz")
+                s.set_restfreqs(restfs, unit="GHz")
             s.set_unit(self.fields['units'][self.fields['cunit']])
             s.set_freqframe(self.form.getfirst("frame", "LSRK"))
 …
             rcp['figure.subplot.wspace'] = 0.3
             rcp['figure.subplot.hspace'] = 0.3
             del asap.plotter
+            #del asap.plotter
             # plotter without GUI
             asap.plotter = asap.asapplotter(False)
 …
         self.setDefaultFields()
         title = "ASAP %s Online Monitor" % (observatory['name'])
         tmplname = abspath+"asapmon.html.template"
+        tmplname = asapmonhome+"asapmon.html.template"
         if ( self.form.has_key("plot")):
             self.plotForm()

branches/alma/monitor/cgi-bin/obsconfig.py

-              r712
+              r1757
 # Append observing directories
+observatory['rpfpath'].append("/u/mar637/brage/singledish/data")
+observatory['rpfpath'].append("/u/mar637/brage/singledish/data/mopra200505")
+observatory['rpfpath'].append("/u/mar637/brage/singledish/data/mopra/phoenix")
+observatory['rpfpath'].append("/DATA/MPCCC1_1/corr/dat/")
 # Restfrequencies in GHz

branches/alma/monitor/htdocs/asapmon.html.template

r711	r1757
4	4	<head>
5	5	<title tal:content="title">ASAP Online Monitor</title>
6		<link rel="stylesheet" href="/asap~~test/fields~~.css" type="text/css">
	6	<link rel="stylesheet" href="/asapmon/asapmon.css" type="text/css">
7	7	<script type="text/javascript" src="/asapmon/prototype.js"></script>
8	8	<script type="text/javascript" src="/asapmon/asapmon.js"></script>

branches/alma/python/init.py

-              r1729
+              r1757
 """
 import os,sys,shutil, platform
+try:
+    from functools import wraps as wraps_dec
+except ImportError:
+    from asap.compatibility import wraps as wraps_dec
 # Set up CASAPATH and first time use of asap i.e. ~/.asap/*
 …
     #shutil.copyfile(asapdata+"/data/ipythonrc-asap", userdir+"/ipythonrc-asap")
     # commented out by TT on 2009.06.23 for casapy use
     ##shutil.copyfile(asapdata+"/data/ipy_user_conf.py",
+    ##shutil.copyfile(asapdata+"/data/ipy_user_conf.py",
     ##                userdir+"/ipy_user_conf.py")
     f = file(userdir+"/asapuserfuncs.py", "w")
 …
     # upgrade to support later ipython versions
     ##if not os.path.exists(userdir+"/ipy_user_conf.py"):
     ##    shutil.copyfile(asapdata+"/data/ipy_user_conf.py",
+    ##    shutil.copyfile(asapdata+"/data/ipy_user_conf.py",
     ##                    userdir+"/ipy_user_conf.py")
 …
     """
     fname = os.path.join( os.getcwd(), '.asaprc')
     if os.path.exists(fname): return fname
 …
     'plotter.histogram'  : [False, _validate_bool],
     'plotter.papertype'  : ['A4', str],
+    'plotter.xaxisformatting' : ['asap', str],
+    ## for older Matplotlib version
+    #'plotter.axesformatting' : ['mpl', str],
+    'plotter.axesformatting' : ['asap', str],
     # scantable
 …
     'scantable.storage'   : ['memory', str],
     'scantable.history'   : [True, _validate_bool],
+    'scantable.reference'      : ['.*(e|w|_R)$', str]
+    'scantable.reference'      : ['.*(e|w|_R)$', str],
+    'scantable.parallactify'   : [False, _validate_bool]
     # fitter
+    }
 …
 plotter.panelling          : scan
 # push panels together, to share axislabels
+# push panels together, to share axis labels
 plotter.ganged             : True
 …
 # The formatting style of the xaxis
 plotter.xaxisformatting    : 'asap' or 'mpl'
+plotter.axesformatting    : 'mpl' (default) or 'asap' (for old versions of matplotlib)
 # scantable
 …
 # Control the identification of reference (off) scans
 # This is has to be a regular expression
+scantable.reference         : .*(e|w|_R)$
+scantable.reference        : .*(e|w|_R)$
+# Indicate whether the data was parallactified (total phase offest == 0.0)
+scantable.parallactify     : False
 # Fitter
 """
 …
 def _n_bools(n, val):
     return [ val for i in xrange(n) ]
+    return [ val for i in xrange(n) ]
 def _is_sequence_or_number(param, ptype=int):
 …
     asaplog.disable()
+def print_log_dec(f):
+    @wraps_dec(f)
+    def wrap_it(*args, **kw):
+        val = f(*args, **kw)
+        print_log()
+        return val
+    return wrap_it
 def print_log(level='INFO'):
     from taskinit import casalog
 …
 from scantable import scantable
 from asaplinefind import linefinder
+from simplelinefinder import simplelinefinder
 from linecatalog import linecatalog
 from interactivemask import interactivemask
+from opacity import skydip
+from opacity import model as opacity_model
 if rcParams['useplotter']:
 …
             import matplotlib
             if not matplotlib.sys.modules['matplotlib.backends']: matplotlib.use("TkAgg")
         import pylab
+        from matplotlib import pylab
         xyplotter = pylab
         plotter = asapplotter(gui)
 …
 __date__ = '$Date$'.split()[1]
 __version__  = '2.3.1 alma'
+__version__  = '3.0.0 alma'
 # nrao casapy specific, get revision number
 #__revision__ = ' unknown '
 …
 def is_ipython():
     return '__IP' in dir(sys.modules["__main__"])
+    return 'IPython' in sys.modules.keys()
 if is_ipython():
     def version(): print  "ASAP %s(%s)"% (__version__, __date__)
     def list_scans(t = scantable):
+        import types
+        globs = sys.modules['__main__'].__dict__.iteritems()
+        print "The user created scantables are:"
+        sts = map(lambda x: x[0], filter(lambda x: isinstance(x[1], t), globs))
+        print filter(lambda x: not x.startswith('_'), sts)
+        return
+        import inspect
+        print "The user created scantables are: ",
+        globs=inspect.currentframe().f_back.f_locals.copy()
+        out = [ k for k,v in globs.iteritems() \
+                     if isinstance(v, scantable) and not k.startswith("_") ]
+        print out
+        return out
     def commands():
 …
             get_elevation   - get the elevation of the scans
             get_parangle    - get the parallactic angle of the scans
+            get_coordinate  - get the spectral coordinate for the given row,
+                              which can be used for coordinate conversions
+            get_weather     - get the weather condition parameters
             get_unit        - get the current unit
             set_unit        - set the abcissa unit to be used from this
 …
             mx_quotient     - Form a quotient using MX data (off beams)
             scale, *, /     - return a scan scaled by a given factor
+            add, +, -       - return a scan with given value added
+            add, +          - return a scan with given value added
+            sub, -          - return a scan with given value subtracted
             bin             - return a scan with binned channels
             resample        - return a scan with resampled channels
 …
             stddev          - Determine the standard deviation of the current
                               beam/if/pol
+            get_row_selector - get the selection object for a specified row
+                               number
      [Selection]
          selector              - a selection object to set a subset of a scantable
 …
             plot            - plot a scantable
             plot_lines      - plot a linecatalog overlay
+            plotazel        - plot azimuth and elevation versus time
+            plotpointing    - plot telescope pointings
             save            - save the plot to a file ('png' ,'ps' or 'eps')
             set_mode        - set the state of the plotter, i.e.
 …
             axhline,axvline - draw horizontal/vertical lines
             axhspan,axvspan - draw horizontal/vertical regions
+            annotate        - draw an arrow with label
+            create_mask     - create a scnatble mask interactively
         xyplotter           - matplotlib/pylab plotting functions
-    [Reading files]
-        reader              - access rpfits/sdfits files
-            open            - attach reader to a file
-            close           - detach reader from file
-            read            - read in integrations
-            summary         - list info about all integrations
     [General]
         commands            - this command
         print               - print details about a variable
         list_scans          - list all scantables created bt the user
+        list_scans          - list all scantables created by the user
         list_files          - list all files readable by asap (default rpf)
         del                 - delete the given variable from memory
 …
         mask_not            - boolean operations on masks created with
                               scantable.create_mask
+        skydip              - gain opacity values from a sky dip observation
+        opacity_model       - compute opacities fro given frequencies based on
+                              atmospheric model
     Note:

branches/alma/python/asapfitter.py

-              r1701
+              r1757
 import _asap
 from asap import rcParams
 from asap import print_log
+from asap import print_log, print_log_dec
 from asap import _n_bools
 from asap import mask_and
 …
         Set the function to be fit.
         Parameters:
             poly:    use a polynomial of the order given with nonlinear least squares fit
+            poly:    use a polynomial of the order given with nonlinear least squares fit
             lpoly:   use polynomial of the order given with linear least squares fit
             gauss:   fit the number of gaussian specified
 …
             n = kwargs.get('poly')
             self.components = [n]
             self.uselinear = False
+            self.uselinear = False
         elif kwargs.has_key('lpoly'):
             self.fitfunc = 'poly'
 …
             self.fitfuncs = [ 'gauss' for i in range(n) ]
             self.components = [ 3 for i in range(n) ]
             self.uselinear = False
+            self.uselinear = False
         elif kwargs.has_key('lorentz'):
             n = kwargs.get('lorentz')
 …
             self.fitfuncs = [ 'lorentz' for i in range(n) ]
             self.components = [ 3 for i in range(n) ]
             self.uselinear = False
+            self.uselinear = False
         else:
             msg = "Invalid function type."
 …
         return
+    #@print_log_dec
     def fit(self, row=0, estimate=False):
         """
 …
                                                                       self.data.getbeam(i),
                                                                       self.data.getif(i),
                                                                       self.data.getpol(i),
+                                                                      self.data.getpol(i),
                                                                       self.data.getcycle(i))
                 asaplog.push(out,False)
 …
                 self.data._addfit(fit,self._fittedrow)
     #def set_parameters(self, params, fixed=None, component=None):
+    #@print_log_dec
     def set_parameters(self,*args,**kwargs):
         """
 …
         return self.fitter.getfit()
+    #@print_log_dec
     def commit(self):
         """
 …
         return scan
+    def plot(self, residual=False, components=None, plotparms=False, filename=None):
+    #@print_log_dec
+    def plot(self, residual=False, components=None, plotparms=False,
+             filename=None):
         """
         Plot the last fit.
 …
         xlab = 'Abcissa'
         ylab = 'Ordinate'
         from matplotlib.numerix import ma,logical_not,logical_and,array
+        from numpy import ma,logical_not,logical_and,array
         m = self.mask
         if self.data:
 …
                              array(self.data._getmask(self._fittedrow),
                                    copy=False))
             ylab = self.data._get_ordinate_label()
 …
         print_log()
+    #@print_log_dec
     def auto_fit(self, insitu=None, plot=False):
         """
 …
                                                                    scan.getbeam(r),
                                                                    scan.getif(r),
                                                                    scan.getpol(r),
+                                                                   scan.getpol(r),
                                                                    scan.getcycle(r))
             asaplog.push(out, False)
 …
         print_log()
         return scan

branches/alma/python/asaplinefind.py

-              r929
+              r1757
     def set_options(self,threshold=1.7320508075688772,min_nchan=3,
         avg_limit=8,box_size=0.2):
+        avg_limit=8,box_size=0.2,noise_box='all',noise_stat='mean80'):
         """
         Set the parameters of the algorithm
 …
                           this parameter can be averaged to search for
                           broad lines. Default is 8.
              box_size     A running mean box size specified as a fraction
+             box_size     A running mean/median box size specified as a fraction
                           of the total spectrum length. Default is 1/5
+             noise_box    Area of the spectrum used to estimate noise stats
+                          Both string values and numbers are allowed
+                          Allowed string values:
+                             'all' use all the spectrum (default)
+                             'box' noise box is the same as running mean/median
+                                   box
+                          Numeric values are defined as a fraction from the
+                          spectrum size. Values should be positive.
+                          (noise_box == box_size has the same effect as
+                           noise_box = 'box')
+             noise_stat   Statistics used to estimate noise, allowed values:
+                              'mean80' use the 80% of the lowest deviations
+                                       in the noise box (default)
+                              'median' median of deviations in the noise box
         Note:  For bad baselines threshold should be increased,
                and avg_limit decreased (or even switched off completely by
 …
                undulations instead of real lines.
         """
+        self.finder.setoptions(threshold,min_nchan,avg_limit,box_size)
+        if noise_stat.lower() not in ["mean80",'median']:
+           raise RuntimeError, "noise_stat argument in linefinder.set_options can only be mean80 or median"
+        nStat = (noise_stat.lower() == "median")
+        nBox = -1.
+        if isinstance(noise_box,str):
+           if noise_box.lower() not in ['all','box']:
+              raise RuntimeError, "string-valued noise_box in linefinder.set_options can only be all or box"
+           if noise_box.lower() == 'box':
+              nBox = box_size
+        else:
+           nBox = float(noise_box)
+        self.finder.setoptions(threshold,min_nchan,avg_limit,box_size,nBox,nStat)
         return

branches/alma/python/asaplot.py

r708	r1757
11	11	ASAP plotting class based on matplotlib.
12	12	"""
13		def __init__(self, rows=1, cols=0, title='', size=~~(8,4)~~, buffering=False):
	13	def __init__(self, rows=1, cols=0, title='', size=None, buffering=False):
14	14	"""
15	15	Create a new instance of the ASAPlot plotting class.

branches/alma/python/asaplotbase.py

-              r1723
+              r1757
 from matplotlib.figure import Figure, Text
 from matplotlib.font_manager import FontProperties as FP
 from matplotlib.numerix import sqrt
+from numpy import sqrt
 from matplotlib import rc, rcParams
 from asap import rcParams as asaprcParams
 from matplotlib.ticker import OldScalarFormatter
-from matplotlib.ticker import NullLocator
 # API change in mpl >= 0.98
 …
     from matplotlib.transforms import blended_transform_factory
 except ImportError:
     from matplotlib.transforms import blend_xy_sep_transform  as blended_transform_factory
+    from matplotlib.transforms import blend_xy_sep_transform as blended_transform_factory
 from asap import asaplog
 …
     print_log( 'WARN' )
-#class MyFormatter(OldScalarFormatter):
-#    def __call__(self, x, pos=None):
-#        last = len(self.locs)-2
-#        if pos==0:
-#            return ''
-#        else: return OldScalarFormatter.__call__(self, x, pos)
 class asaplotbase:
     """
 …
     """
     def __init__(self, rows=1, cols=0, title='', size=(8,6), buffering=False):
+    def __init__(self, rows=1, cols=0, title='', size=None, buffering=False):
         """
         Create a new instance of the ASAPlot plotting class.
 …
         fmt is the line style as in plot().
         """
         from matplotlib.numerix import array
         from matplotlib.numerix.ma import MaskedArray
+        from numpy import array
+        from numpy.ma import MaskedArray
         if x is None:
             if y is None: return
 …
         self.register('button_press', position_disable)
+#     def get_region(self):
+#         pos = []
+#         print "Please select the bottom/left point"
+#         pos.append(self.figure.ginput(n=1, show_clicks=False)[0])
+#         print "Please select the top/right point"
+#         pos.append(self.figure.ginput(n=1, show_clicks=False)[0])
+#         return pos
+#     def get_point(self):
+#         print "Please select the point"
+#         pt = self.figure.ginput(n=1, show_clicks=False)
+#         if pt:
+#             return pt[0]
+#         else:
+#             return None
     def region(self):
 …
                     self.subplots[i]['axes'] = self.figure.add_subplot(rows,
                                                 cols, i+1)
                     if asaprcParams['plotter.xaxisformatting'] == 'mpl':
+                    if asaprcParams['plotter.axesformatting'] != 'mpl':
                         self.subplots[i]['axes'].xaxis.set_major_formatter(OldScalarFormatter())
                 else:
 …
                         self.subplots[i]['axes'] = self.figure.add_subplot(rows,
                                                 cols, i+1)
                         if asaprcParams['plotter.xaxisformatting'] != 'mpl':
+                        if asaprcParams['plotter.axesformatting'] != 'mpl':
                             self.subplots[i]['axes'].xaxis.set_major_formatter(OldScalarFormatter())
 …
             from matplotlib.artist import setp
+            fp = FP(size=rcParams['xtick.labelsize'])
+            xts = fp.get_size_in_points()- (self.cols)/2
+            fp = FP(size=rcParams['ytick.labelsize'])
+            yts = fp.get_size_in_points() - (self.rows)/2
+            fpx = FP(size=rcParams['xtick.labelsize'])
+            xts = fpx.get_size_in_points()- (self.cols)/2
+            fpy = FP(size=rcParams['ytick.labelsize'])
+            yts = fpy.get_size_in_points() - (self.rows)/2
+            fpa = FP(size=rcParams['axes.labelsize'])
+            fpat = FP(size=rcParams['axes.titlesize'])
+            axsize =  fpa.get_size_in_points()
+            tsize =  fpat.get_size_in_points()-(self.cols)/2
             for sp in self.subplots:
                 ax = sp['axes']
-                #s = ax.title.get_size()
-                #tsize = s-(self.cols+self.rows)
-                s=FP(size=rcParams['axes.titlesize'])
-                tsize = s.get_size_in_points()-(self.cols)/2
                 ax.title.set_size(tsize)
-                fp = FP(size=rcParams['axes.labelsize'])
                 setp(ax.get_xticklabels(), fontsize=xts)
                 setp(ax.get_yticklabels(), fontsize=yts)
-                origx =  fp.get_size_in_points()
-                origy = origx
                 off = 0
                 if self.cols > 1: off = self.cols
+                xfsize = origx-off
+                ax.xaxis.label.set_size(xfsize)
+                ax.xaxis.label.set_size(axsize-off)
                 off = 0
                 if self.rows > 1: off = self.rows
+                yfsize = origy-off
+                ax.yaxis.label.set_size(yfsize)
+                ax.yaxis.label.set_size(axsize-off)
     def subplot(self, i=None, inc=None):

branches/alma/python/asaplotgui.py

r1699	r1757
16	16	"""
17	17
18		def __init__(self, rows=1, cols=0, title='', size=~~(8,6)~~, buffering=False):
	18	def __init__(self, rows=1, cols=0, title='', size=None, buffering=False):
19	19	"""
20	20	Create a new instance of the ASAPlot plotting class.

branches/alma/python/asaplotgui_gtk.py

r1619	r1757
18	18	"""
19	19
20		def __init__(self, rows=1, cols=0, title='', size=~~(8,6)~~, buffering=False):
	20	def __init__(self, rows=1, cols=0, title='', size=None, buffering=False):
21	21	"""
22	22	Create a new instance of the ASAPlot plotting class.

branches/alma/python/asaplotgui_qt4.py

r1640	r1757
18	18	"""
19	19
20		def __init__(self, rows=1, cols=0, title='', size=~~(8,6)~~, buffering=False):
	20	def __init__(self, rows=1, cols=0, title='', size=None, buffering=False):
21	21	"""
22	22	Create a new instance of the ASAPlot plotting class.

branches/alma/python/asapmath.py

-              r1693
+              r1757
 from asap.scantable import scantable
 from asap import rcParams
 from asap import print_log
+from asap import print_log, print_log_dec
 from asap import selector
 from asap import asaplog
 from asap import asaplotgui
+#@print_log_dec
 def average_time(*args, **kwargs):
     """
 …
         # without using a mask
         scanav = average_time(scana,scanb)
         # or equivalent
         # scanav = average_time([scana, scanb])
+        # or equivalent
+        # scanav = average_time([scana, scanb])
         # return the (time) averaged scan, i.e. the average of
         # all correlator cycles
 …
     return s
+#@print_log_dec
 def dototalpower(calon, caloff, tcalval=0.0):
     """
 …
     return s
+#@print_log_dec
 def dosigref(sig, ref, smooth, tsysval=0.0, tauval=0.0):
     """
 …
     return s
+#@print_log_dec
 def calps(scantab, scannos, smooth=1, tsysval=0.0, tauval=0.0, tcalval=0.0, verify=False):
     """
 …
     return ress
+#@print_log_dec
 def calnod(scantab, scannos=[], smooth=1, tsysval=0.0, tauval=0.0, tcalval=0.0, verify=False):
     """
 …
     return resspec
+#@print_log_dec
 def calfs(scantab, scannos=[], smooth=1, tsysval=0.0, tauval=0.0, tcalval=0.0, verify=False):
     """
 …
     return resspec
+def simple_math(left, right, op='add', tsys=True):
+    """
+    Apply simple mathematical binary operations to two
+    scan tables,  returning the result in a new scan table.
+    The operation is applied to both the correlations and the TSys data
+    The cursor of the output scan is set to 0
+    Parameters:
+        left:          the 'left' scan
+        right:         the 'right' scan
+        op:            the operation: 'add' (default), 'sub', 'mul', 'div'
+        tsys:          if True (default) then apply the operation to Tsys
+                       as well as the data
+    """
+    #print "simple_math is deprecated use +=/* instead."
+    asaplog.push( "simple_math is deprecated use +=/* instead." )
+    print_log('WARN')
+#@print_log_dec
 def merge(*args):
     """
 …
     Example:
         myscans = [scan1, scan2]
         allscans = merge(myscans)
         # or equivalent
         sameallscans = merge(scan1, scan2)
+        allscans = merge(myscans)
+        # or equivalent
+        sameallscans = merge(scan1, scan2)
     """
     varlist = vars()

branches/alma/python/asapplotter.py

-              r1732
+              r1757
+from asap import rcParams, print_log, selector
+from asap import rcParams, print_log, print_log_dec
+from asap import selector, scantable
 from asap import asaplog
 import matplotlib.axes
+from matplotlib.font_manager import FontProperties
+from matplotlib.text import Text
 import re
 …
         other variables.
     """
     def __init__(self, visible=None):
+    def __init__(self, visible=None , **kwargs):
         self._visible = rcParams['plotter.gui']
         if visible is not None:
             self._visible = visible
         self._plotter = self._newplotter()
+        self._plotter = self._newplotter(**kwargs)
         if self._visible and matplotlib.get_backend() == "TkAgg":
             from asap.casatoolbar import CustomToolbarTkAgg
 …
         self._selection = selector()
         self._hist = rcParams['plotter.histogram']
+        self._fp = FontProperties()
         self._panellayout = self.set_panellayout(refresh=False)
 …
         return None
     def _newplotter(self):
+    def _newplotter(self, **kwargs):
         backend=matplotlib.get_backend()
         if not self._visible:
 …
         else:
             from asap.asaplot import asaplot
         return asaplot()
+        return asaplot(**kwargs)
+    #@print_log_dec
     def plot(self, scan=None):
         """
 …
         return
+    def gca(self):
+        return self._plotter.figure.gca()
+    def refresh(self):
+        """Do a soft refresh"""
+        self._plotter.figure.show()
+    def create_mask(self, nwin=1, panel=0, color=None):
+        """
+        Interactively define a mask.It retruns a mask that is equivalent to
+        the one created manually with scantable.create_mask.
+        Parameters:
+            nwin:       The number of mask windows to create interactively
+                        default is 1.
+            panel:      Which panel to use for mask selection. This is useful
+                        if different IFs are spread over panels (default 0)
+        """
+        if self._data is None:
+            return []
+        outmask = []
+        self._plotter.subplot(panel)
+        xmin, xmax = self._plotter.axes.get_xlim()
+        marg = 0.05*(xmax-xmin)
+        self._plotter.axes.set_xlim(xmin-marg, xmax+marg)
+        self.refresh()
+        def cleanup(lines=False, texts=False, refresh=False):
+            if lines:
+                del self._plotter.axes.lines[-1]
+            if texts:
+                del self._plotter.axes.texts[-1]
+            if refresh:
+                self.refresh()
+        for w in xrange(nwin):
+            wpos = []
+            self.text(0.05,1.0, "Add start boundary",
+                      coords="relative", fontsize=10)
+            point = self._plotter.get_point()
+            cleanup(texts=True)
+            if point is None:
+                continue
+            wpos.append(point[0])
+            self.axvline(wpos[0], color=color)
+            self.text(0.05,1.0, "Add end boundary", coords="relative", fontsize=10)
+            point = self._plotter.get_point()
+            cleanup(texts=True, lines=True)
+            if point is None:
+                self.refresh()
+                continue
+            wpos.append(point[0])
+            self.axvspan(wpos[0], wpos[1], alpha=0.1,
+                         edgecolor=color, facecolor=color)
+            ymin, ymax = self._plotter.axes.get_ylim()
+            outmask.append(wpos)
+        self._plotter.axes.set_xlim(xmin, xmax)
+        self.refresh()
+        if len(outmask) > 0:
+            return self._data.create_mask(*outmask)
+        return []
     # forwards to matplotlib axes
     def text(self, *args, **kwargs):
+        if kwargs.has_key("interactive"):
+            #if kwargs.pop("interactive"):
+            #    pos = self._plotter.get_point()
+            #    args = tuple(pos)+args
+            kwargs.pop("interactive")
         self._axes_callback("text", *args, **kwargs)
     text.__doc__ = matplotlib.axes.Axes.text.__doc__
     def arrow(self, *args, **kwargs):
+        if kwargs.has_key("interactive"):
+            #if kwargs.pop("interactive"):
+            #    pos = self._plotter.get_region()
+            #    dpos = (pos[0][0], pos[0][1],
+            #            pos[1][0]-pos[0][0],
+            #            pos[1][1] - pos[0][1])
+            #    args = dpos + args
+            kwargs.pop("interactive")
         self._axes_callback("arrow", *args, **kwargs)
     arrow.__doc__ = matplotlib.axes.Axes.arrow.__doc__
+    def annotate(self, text, xy=None, xytext=None, **kwargs):
+        if kwargs.has_key("interactive"):
+            #if kwargs.pop("interactive"):
+            #    xy = self._plotter.get_point()
+            #    xytext = self._plotter.get_point()
+            kwargs.pop("interactive")
+        if not kwargs.has_key("arrowprops"):
+            kwargs["arrowprops"] = dict(arrowstyle="->")
+        self._axes_callback("annotate", text, xy, xytext, **kwargs)
+    annotate.__doc__ = matplotlib.axes.Axes.annotate.__doc__
     def axvline(self, *args, **kwargs):
+        if kwargs.has_key("interactive"):
+            #if kwargs.pop("interactive"):
+            #    pos = self._plotter.get_point()
+            #    args = (pos[0],)+args
+            kwargs.pop("interactive")
         self._axes_callback("axvline", *args, **kwargs)
     axvline.__doc__ = matplotlib.axes.Axes.axvline.__doc__
     def axhline(self, *args, **kwargs):
+        if kwargs.has_key("interactive"):
+            #if kwargs.pop("interactive"):
+            #    pos = self._plotter.get_point()
+            #    args = (pos[1],)+args
+            kwargs.pop("interactive")
         self._axes_callback("axhline", *args, **kwargs)
     axhline.__doc__ = matplotlib.axes.Axes.axhline.__doc__
     def axvspan(self, *args, **kwargs):
+        if kwargs.has_key("interactive"):
+            #if kwargs.pop("interactive"):
+            #    pos = self._plotter.get_region()
+            #    dpos = (pos[0][0], pos[1][0])
+            #    args = dpos + args
+            kwargs.pop("interactive")
         self._axes_callback("axvspan", *args, **kwargs)
         # hack to preventy mpl from redrawing the patch
         # it seem to convert the patch into lines on every draw.
         # This doesn't happen in a test script???
+        del self._plotter.axes.patches[-1]
+        #del self._plotter.axes.patches[-1]
     axvspan.__doc__ = matplotlib.axes.Axes.axvspan.__doc__
     def axhspan(self, *args, **kwargs):
+        if kwargs.has_key("interactive"):
+            #if kwargs.pop("interactive"):
+            #    pos = self._plotter.get_region()
+            #    dpos = (pos[0][1], pos[1][1])
+            #    args = dpos + args
+            kwargs.pop("interactive")
         self._axes_callback("axhspan", *args, **kwargs)
         # hack to preventy mpl from redrawing the patch
         # it seem to convert the patch into lines on every draw.
         # This doesn't happen in a test script???
+        del self._plotter.axes.patches[-1]
+        #del self._plotter.axes.patches[-1]
     axhspan.__doc__ = matplotlib.axes.Axes.axhspan.__doc__
 …
         if refresh and self._data: self.plot(self._data)
     def set_font(self, family=None, style=None, weight=None, size=None, refresh=True):
+    def set_font(self, refresh=True,**kwargs):
         """
         Set font properties.
 …
         """
         from matplotlib import rc as rcp
+        if isinstance(family, str):
+            rcp('font', family=family)
+        if isinstance(style, str):
+            rcp('font', style=style)
+        if isinstance(weight, str):
+            rcp('font', weight=weight)
+        if isinstance(size, float) or isinstance(size, int):
+            rcp('font', size=size)
+        fdict = {}
+        for k,v in kwargs.iteritems():
+            if v:
+                fdict[k] = v
+        self._fp = FontProperties(**fdict)
         if refresh and self._data: self.plot(self._data)
 …
         if not self._data.get_unit().endswith("Hz"):
             raise RuntimeError("Can only overlay linecatalogs when data is in frequency.")
         from matplotlib.numerix import ma
+        from numpy import ma
         for j in range(len(self._plotter.subplots)):
             self._plotter.subplot(j)
 …
         if isinstance(nstack0, int): nstack = nstack0
         else: nstack = len(nstack0)
         maxpanel, maxstack = 16,8
+        maxpanel, maxstack = 16,16
         if n > maxpanel or nstack > maxstack:
             maxn = 0
 …
                 ylab = self._ordinate and self._ordinate[panelcount] \
                        or scan._get_ordinate_label()
                 self._plotter.set_axes('xlabel',xlab)
                 self._plotter.set_axes('ylabel',ylab)
+                self._plotter.set_axes('xlabel', xlab)
+                self._plotter.set_axes('ylabel', ylab)
                 lbl = self._get_label(scan, r, self._panelling, self._title)
                 if isinstance(lbl, list) or isinstance(lbl, tuple):
 …
                     y = scan._getspectrum(r)
                 m = scan._getmask(r)
                 from matplotlib.numerix import logical_not, logical_and
+                from numpy import logical_not, logical_and
                 if self._maskselection and len(self._usermask) == len(m):
                     if d[self._stacking](r) in self._maskselection[self._stacking]:
                         m = logical_and(m, self._usermask)
                 x = scan._getabcissa(r)
                 from matplotlib.numerix import ma, array
+                from numpy import ma, array
                 y = ma.masked_array(y,mask=logical_not(array(m,copy=False)))
                 if self._minmaxx is not None:
 …
         #reset the selector to the scantable's original
         scan.set_selection(savesel)
+    def set_selection(self, selection=None, refresh=True):
+        #temporary switch-off for older matplotlib
+        #if self._fp is not None:
+        if self._fp is not None and getattr(self._plotter.figure,'findobj',False):
+            for o in self._plotter.figure.findobj(Text):
+                o.set_fontproperties(self._fp)
+    def set_selection(self, selection=None, refresh=True, **kw):
         """
         Parameters:
 …
                         Otherwise,the parameter(s) are set without replotting.
         """
+        self._selection = isinstance(selection,selector) and selection or selector()
+        if selection is None:
+            # reset
+            if len(kw) == 0:
+                self._selection = selector()
+            else:
+                # try keywords
+                for k in kw:
+                    if k not in selector.fields:
+                        raise KeyError("Invalid selection key '%s', valid keys are %s" % (k, selector.fields))
+                self._selection = selector(**kw)
+        elif isinstance(selection, selector):
+            self._selection = selection
+        else:
+            raise TypeError("'selection' is not of type selector")
         d0 = {'s': 'SCANNO', 'b': 'BEAMNO', 'i':'IFNO',
               'p': 'POLNO', 'c': 'CYCLENO', 't' : 'TIME' }
 …
     def plotazel(self, scan=None, outfile=None):
+        """
+        plot azimuth and elevation  versus time of a scantable
+        """
+        import pylab as PL
+        from matplotlib.dates import DateFormatter, timezone, HourLocator, MinuteLocator, DayLocator
+    #def plotazel(self):
+        """
+        plot azimuth and elevation versus time of a scantable
+        """
+        from matplotlib import pylab as PL
+        from matplotlib.dates import DateFormatter, timezone
+        from matplotlib.dates import HourLocator, MinuteLocator,SecondLocator, DayLocator
         from matplotlib.ticker import MultipleLocator
         from matplotlib.numerix import array, pi
+        from numpy import array, pi
         self._data = scan
         self._outfile = outfile
 …
         tz = timezone('UTC')
         PL.cla()
         #PL.ioff()
+        PL.ioff()
         PL.clf()
         # Adjust subplot layouts
 …
             minloc = HourLocator(range(0,23,12))
             timefmt = DateFormatter("%b%d")
+        elif tdel > 24./60.:
+            timefmt = DateFormatter('%H:%M')
+            majloc = HourLocator()
+            minloc = MinuteLocator(30)
         else:
+            timefmt = DateFormatter('%H')
+            majloc = HourLocator()
+            minloc = MinuteLocator(20)
+            timefmt = DateFormatter('%H:%M')
+            majloc = MinuteLocator(interval=5)
+            minloc = SecondLocator(30)
         PL.title(dstr)
         if tdel == 0.0:
             th = (t - PL.floor(t))*24.0
 …
                 if az[irow] < 0: az[irow] += 360.0
         ax = PL.subplot(2,1,2)
+        ax2 = PL.subplot(2,1,2)
         #PL.xlabel('Time (UT [hour])')
         PL.ylabel('Az [deg.]')
 …
         else:
             PL.plot_date(t,az,'o', markersize=2,markeredgecolor='b',markerfacecolor='b',tz=tz)
             ax.xaxis.set_major_formatter(timefmt)
             ax.xaxis.set_major_locator(majloc)
             ax.xaxis.set_minor_locator(minloc)
         #ax.grid(True)
         ax.set_ylim(0,360)
         ax.yaxis.grid(True)
+            ax2.xaxis.set_major_formatter(timefmt)
+            ax2.xaxis.set_major_locator(majloc)
+            ax2.xaxis.set_minor_locator(minloc)
+        #ax2.grid(True)
+        ax2.set_ylim(0,360)
+        ax2.yaxis.grid(True)
         #hfmt = DateFormatter('%H')
         #hloc = HourLocator()
         yloc = MultipleLocator(60)
         ax.yaxis.set_major_locator(yloc)
+        ax2.yaxis.set_major_locator(yloc)
         if tdel > 1.0:
             labels = ax.get_xticklabels()
+            labels = ax2.get_xticklabels()
             PL.setp(labels, fontsize=10)
             PL.xlabel('Time (UT [day])')
 …
             PL.xlabel('Time (UT [hour])')
         #PL.ion()
+        PL.ion()
         PL.draw()
         if (self._outfile is not None):
 …
     def plotpointing(self, scan=None, outfile=None):
+    #def plotpointing(self):
         """
         plot telescope pointings
         """
+        import pylab as PL
+        from matplotlib.dates import DateFormatter, timezone
+        from matplotlib.ticker import MultipleLocator
+        from matplotlib.numerix import array, pi, zeros
+        from matplotlib import pylab as PL
+        from numpy import array, pi
         self._data = scan
         self._outfile = outfile
 …
         #ax = PL.axes([0.1,0.1,0.8,0.8])
         ax.set_aspect('equal')
         PL.plot(ra,dec, 'b,')
+        PL.plot(ra, dec, 'b,')
         PL.xlabel('RA [deg.]')
         PL.ylabel('Declination [deg.]')
 …
         # Print Observation header to the upper-left corner of plot
         if plot:
             srest=ssum[ssum.find('Rest Freqs:'):ssum.find('Abcissa:')]
             shead=ssum[ssum.find('Beams:'):ssum.find('Flux Unit:')]
             headstr=shead.split('\n\n')
             if extrastr != '': headstr[1]=extrastr+'\n'+headstr[1]
+            headstr=[ssum[ssum.find('Observer:'):ssum.find('Flux Unit:')]]
+            headstr.append(ssum[ssum.find('Beams:'):ssum.find('Observer:')]
+                         +ssum[ssum.find('Rest Freqs:'):ssum.find('Abcissa:')])
+            if extrastr != '': headstr[0]=extrastr+'\n'+headstr[0]
             #headstr[1]='Data File:     '+(filestr or 'unknown')+'\n'+headstr[1]
-            headstr[0]=headstr[0]+'\n'+srest
-            headstr.reverse()
             ssel='***Selections***\n'+(selstr+self._data.get_selection().__str__() or 'none')
             headstr.append(ssel)
 …
                             verticalalignment='bottom',fontsize=8)
             self._plotter.release()
             del srest, shead, headstr, ssel
+            del headstr, ssel
         if logger:
             asaplog.push("----------------\n  Plot Summary\n----------------")

branches/alma/python/asapreader.py

-              r1059
+              r1757
 from asap._asap import stfiller
 from asap import print_log
+from asap import print_log, print_log_dec
 class reader(stfiller):
 …
                rpfits ONLY.
     """
+    #@print_log_dec
     def __init__(self, filename, unit=None, theif=None, thebeam=None):
         self.unit = unit
 …
         print_log()
+    #@print_log_dec
     def read(self):
         """

branches/alma/python/scantable.py

-              r1701
+              r1757
+import os
+try:
+    from functools import wraps as wraps_dec
+except ImportError:
+    from asap.compatibility import wraps as wraps_dec
 from asap._asap import Scantable
 from asap import rcParams
 from asap import print_log
+from asap import print_log, print_log_dec
 from asap import asaplog
 from asap import selector
 from asap import linecatalog
+from asap.coordinate import coordinate
 from asap import _n_bools, mask_not, mask_and, mask_or
+def preserve_selection(func):
+    @wraps_dec(func)
+    def wrap(obj, *args, **kw):
+        basesel = obj.get_selection()
+        val = func(obj, *args, **kw)
+        obj.set_selection(basesel)
+        return val
+    return wrap
+def is_scantable(filename):
+    return (os.path.isdir(filename)
+            and not os.path.exists(filename+'/table.f1')
+            and os.path.exists(filename+'/table.info'))
 class scantable(Scantable):
 …
     """
+    def __init__(self, filename, average=None, unit=None, getpt=None, antenna=None):
+    #@print_log_dec
+    def __init__(self, filename, average=None, unit=None, getpt=None, antenna=None, parallactify=None):
         """
         Create a scantable from a saved one or make a reference
 …
             antenna:     Antenna selection. integer (id) or string (name
                          or id).
+            parallactify: Indcicate that the data had been parallatified.
+                          Default is taken form rc file.
         """
         if average is None:
 …
                     return
             antenna = tmpstr.rstrip(',')
+        parallactify = parallactify or rcParams['scantable.parallactify']
         varlist = vars()
         from asap._asap import stmath
 …
             Scantable.__init__(self, filename)
         else:
+            if isinstance(filename, str):# or \
+#                (isinstance(filename, list) or isinstance(filename, tuple)) \
+#                  and isinstance(filename[-1], str):
+                import os.path
+            if isinstance(filename, str):
                 filename = os.path.expandvars(filename)
                 filename = os.path.expanduser(filename)
 …
                     if rcParams['verbose']:
                         asaplog.push(s)
-                        #print asaplog.pop().strip()
                         print_log('ERROR')
                         return
                     raise IOError(s)
+                if os.path.isdir(filename) \
+                    and not os.path.exists(filename+'/table.f1'):
+                    # crude check if asap table
+                    if os.path.exists(filename+'/table.info'):
+                        ondisk = rcParams['scantable.storage'] == 'disk'
+                        Scantable.__init__(self, filename, ondisk)
+                        if unit is not None:
+                            self.set_fluxunit(unit)
+                        # do not reset to the default freqframe
+                        #self.set_freqframe(rcParams['scantable.freqframe'])
+                if is_scantable(filename):
+                    ondisk = rcParams['scantable.storage'] == 'disk'
+                    Scantable.__init__(self, filename, ondisk)
+                    if unit is not None:
+                        self.set_fluxunit(unit)
+                    # do not reset to the default freqframe
+                    #self.set_freqframe(rcParams['scantable.freqframe'])
+                elif os.path.isdir(filename) \
+                         and not os.path.exists(filename+'/table.f1'):
+                    msg = "The given file '%s'is not a valid " \
+                          "asap table." % (filename)
+                    if rcParams['verbose']:
+                        #print msg
+                        asaplog.push( msg )
+                        print_log( 'ERROR' )
+                        return
                     else:
+                        msg = "The given file '%s'is not a valid " \
+                              "asap table." % (filename)
+                        if rcParams['verbose']:
+                            #print msg
+                            asaplog.push( msg )
+                            print_log( 'ERROR' )
+                            return
+                        else:
+                            raise IOError(msg)
+                        raise IOError(msg)
                 else:
                     self._fill([filename], unit, average, getpt, antenna)
 …
                   and isinstance(filename[-1], str):
                 self._fill(filename, unit, average, getpt, antenna)
+        self.parallactify(parallactify)
         self._add_history("scantable", varlist)
         print_log()
+    #@print_log_dec
     def save(self, name=None, format=None, overwrite=False):
         """
 …
                                        'MS2' (saves as an aips++
                                               MeasurementSet V2)
                                        'FITS' (save as image FITS - not
+                                       'FITS' (save as image FITS - not
                                                readable by class)
                                        'CLASS' (save as FITS readable by CLASS)
 …
         """
         from os import path
         if format is None: format = rcParams['scantable.save']
+        format = format or rcParams['scantable.save']
         suffix = '.'+format.lower()
         if name is None or name == "":
 …
             else: raise
         try:
+            bsel = self.get_selection()
+            sel = selector()
+            sel.set_scans(allscans)
+            self.set_selection(bsel+sel)
+            scopy = self._copy()
+            self.set_selection(bsel)
+            return scantable(scopy)
+            sel = selector(scans=allscans)
+            return self._select_copy(sel)
         except RuntimeError:
             if rcParams['verbose']:
 …
                 raise
+    def _select_copy(self, selection):
+        orig = self.get_selection()
+        self.set_selection(orig+selection)
+        cp = self.copy()
+        self.set_selection(orig)
+        return cp
     def get_scan(self, scanid=None):
 …
             if type(scanid) is str:
                 sel.set_name(scanid)
+                self.set_selection(bsel+sel)
+                scopy = self._copy()
+                self.set_selection(bsel)
+                return scantable(scopy)
+                return self._select_copy(sel)
             elif type(scanid) is int:
                 sel.set_scans([scanid])
+                self.set_selection(bsel+sel)
+                scopy = self._copy()
+                self.set_selection(bsel)
+                return scantable(scopy)
+                return self._select_copy(sel)
             elif type(scanid) is list:
                 sel.set_scans(scanid)
+                self.set_selection(sel)
+                scopy = self._copy()
+                self.set_selection(bsel)
+                return scantable(scopy)
+                return self._select_copy(sel)
             else:
                 msg = "Illegal scanid type, use 'int' or 'list' if ints."
 …
             filename:    the name of a file to write the putput to
                          Default - no file output
-            verbose:     print extra info such as the frequency table
-                         The default (False) is taken from .asaprc
         """
         info = Scantable._summary(self, True)
-        #if verbose is None: verbose = rcParams['scantable.verbosesummary']
         if filename is not None:
             if filename is "":
 …
         """Return the spectrum for the current row in the scantable as a list.
         Parameters:
              rowno:   the row number to retrieve the spectrum from
+             rowno:   the row number to retrieve the spectrum from
         """
         return self._getspectrum(rowno)
 …
         """Return the mask for the current row in the scantable as a list.
         Parameters:
              rowno:   the row number to retrieve the mask from
+             rowno:   the row number to retrieve the mask from
         """
         return self._getmask(rowno)
 …
         Parameters:
              spec:   the spectrum
              rowno:    the row number to set the spectrum for
+             rowno:    the row number to set the spectrum for
         """
         assert(len(spec) == self.nchan())
         return self._setspectrum(spec, rowno)
+    def get_coordinate(self, rowno):
+        """Return the (spectral) coordinate for a a given 'rowno'.
+        NOTE:
+            * This coordinate is only valid until a scantable method modifies
+              the frequency axis.
+            * This coordinate does contain the original frequency set-up
+              NOT the new frame. The conversions however are done using the user
+              specified frame (e.g. LSRK/TOPO). To get the 'real' coordinate,
+              use scantable.freq_align first. Without it there is no closure,
+              i.e.
+              c = myscan.get_coordinate(0)
+              c.to_frequency(c.get_reference_pixel()) != c.get_reference_value()
+        Parameters:
+             rowno:    the row number for the spectral coordinate
+        """
+        return coordinate(Scantable.get_coordinate(self, rowno))
     def get_selection(self):
 …
         return selector(self._getselection())
     def set_selection(self, selection=selector()):
+    def set_selection(self, selection=None, **kw):
         """
         Select a subset of the data. All following operations on this scantable
         are only applied to thi selection.
         Parameters:
+            selection:    a selector object (default unset the selection)
+            selection:    a selector object (default unset the selection),
+            or
+            any combination of
+            "pols", "ifs", "beams", "scans", "cycles", "name", "query"
         Examples:
             sel = selector()         # create a selection object
 …
             scan.summary()           # will only print summary of scanno 0 an 3
             scan.set_selection()     # unset the selection
+        """
+            # or the equivalent
+            scan.set_selection(scans=[0,3])
+            scan.summary()           # will only print summary of scanno 0 an 3
+            scan.set_selection()     # unset the selection
+        """
+        if selection is None:
+            # reset
+            if len(kw) == 0:
+                selection = selector()
+            else:
+                # try keywords
+                for k in kw:
+                    if k not in selector.fields:
+                        raise KeyError("Invalid selection key '%s', valid keys are %s" % (k, selector.fields))
+                selection = selector(**kw)
         self._setselection(selection)
 …
             scan.stats(stat='mean', mask=m)
         """
+        if mask == None:
+            mask = []
+        axes = ['Beam', 'IF', 'Pol', 'Time']
+        mask = mask or []
         if not self._check_ifs():
             raise ValueError("Cannot apply mask as the IFs have different "
 …
         if not rtnabc: statvals = self._math._stats(self, mask, stat)
+        out = ''
+        axes = []
+        #def cb(i):
+        #    return statvals[i]
+        #return self._row_callback(cb, stat)
+        label=stat
+        #callback=cb
+        out = ""
+        #outvec = []
+        sep = '-'*50
         for i in range(self.nrow()):
-            axis = []
-            axis.append(self.getscan(i))
-            axis.append(self.getbeam(i))
-            axis.append(self.getif(i))
-            axis.append(self.getpol(i))
-            axis.append(self.getcycle(i))
-            axes.append(axis)
-            tm = self._gettime(i)
-            src = self._getsourcename(i)
             refstr = ''
             statunit= ''
 …
                 if rtnabc:
                     statvals.append(qx['value'])
-                    #refstr = '(value: %3.3f' % (qy['value'])+' ['+qy['unit']+'])'
                     refstr = ('(value: %'+form) % (qy['value'])+' ['+qy['unit']+'])'
                     statunit= '['+qx['unit']+']'
                 else:
-                    #refstr = '(@ %3.3f' % (qx['value'])+' ['+qx['unit']+'])'
                     refstr = ('(@ %'+form) % (qx['value'])+' ['+qx['unit']+'])'
+                    #statunit= ' ['+qy['unit']+']'
+            out += 'Scan[%d] (%s) ' % (axis[0], src)
+            tm = self._gettime(i)
+            src = self._getsourcename(i)
+            out += 'Scan[%d] (%s) ' % (self.getscan(i), src)
             out += 'Time[%s]:\n' % (tm)
+            if self.nbeam(-1) > 1: out +=  ' Beam[%d] ' % (axis[1])
+            if self.nif(-1) > 1: out +=  ' IF[%d] ' % (axis[2])
+            if self.npol(-1) > 1: out +=  ' Pol[%d] ' % (axis[3])
+            #out += '= %3.3f   ' % (statvals[i]) +refstr+'\n'
+            if self.nbeam(-1) > 1:
+                out +=  ' Beam[%d] ' % (self.getbeam(i))
+            if self.nif(-1) > 1: out +=  ' IF[%d] ' % (self.getif(i))
+            if self.npol(-1) > 1: out +=  ' Pol[%d] ' % (self.getpol(i))
+            #outvec.append(callback(i))
+            #out += ('= %'+form) % (outvec[i]) +'   '+refstr+'\n'
             out += ('= %'+form) % (statvals[i]) +'   '+refstr+'\n'
             out +=  "--------------------------------------------------\n"
+            out +=  sep+"\n"
         if rcParams['verbose']:
 …
             tmpfile='/tmp/tmp_'+usr+'_casapy_asap_scantable_stats'
             f=open(tmpfile,'w')
             print >> f, "--------------------------------------------------"
             print >> f, " ", stat, statunit
             print >> f, "--------------------------------------------------"
+            print >> f, sep
+            print >> f, ' %s %s' % (label, statunit)
+            print >> f, sep
             print >> f, out
             f.close()
 …
             x=f.readlines()
             f.close()
+            for xx in x:
+                asaplog.push( xx, False )
+            blanc=''
+            asaplog.push(blanc.join(x), False)
+            #for xx in x:
+            #    asaplog.push( xx, False )
             print_log()
-        #else:
-            #retval = { 'axesnames': ['scanno', 'beamno', 'ifno', 'polno', 'cycleno'],
-            #           'axes' : axes,
-            #           'data': statvals}
         return statvals
 …
         return list(Scantable.get_column_names(self))
     def get_tsys(self):
+    def get_tsys(self, row=-1):
         """
         Return the System temperatures.
 …
             a list of Tsys values for the current selection
         """
+        if row > -1:
+            return self._get_column(self._gettsys, row)
         return self._row_callback(self._gettsys, "Tsys")
+    def get_weather(self, row=-1):
+        values = self._get_column(self._get_weather, row)
+        if row > -1:
+            return {'temperature': values[0],
+                    'pressure': values[1], 'humidity' : values[2],
+                    'windspeed' : values[3], 'windaz' : values[4]
+                    }
+        else:
+            out = []
+            for r in values:
+                out.append({'temperature': r[0],
+                            'pressure': r[1], 'humidity' : r[2],
+                            'windspeed' : r[3], 'windaz' : r[4]
+                    })
+            return out
     def _row_callback(self, callback, label):
-        axes = []
-        axesnames = ['scanno', 'beamno', 'ifno', 'polno', 'cycleno']
         out = ""
         outvec = []
+        sep = '-'*50
         for i in range(self.nrow()):
-            axis = []
-            axis.append(self.getscan(i))
-            axis.append(self.getbeam(i))
-            axis.append(self.getif(i))
-            axis.append(self.getpol(i))
-            axis.append(self.getcycle(i))
-            axes.append(axis)
             tm = self._gettime(i)
             src = self._getsourcename(i)
             out += 'Scan[%d] (%s) ' % (axis[0], src)
+            out += 'Scan[%d] (%s) ' % (self.getscan(i), src)
             out += 'Time[%s]:\n' % (tm)
+            if self.nbeam(-1) > 1: out +=  ' Beam[%d] ' % (axis[1])
+            if self.nif(-1) > 1: out +=  ' IF[%d] ' % (axis[2])
+            if self.npol(-1) > 1: out +=  ' Pol[%d] ' % (axis[3])
+            if self.nbeam(-1) > 1:
+                out +=  ' Beam[%d] ' % (self.getbeam(i))
+            if self.nif(-1) > 1: out +=  ' IF[%d] ' % (self.getif(i))
+            if self.npol(-1) > 1: out +=  ' Pol[%d] ' % (self.getpol(i))
             outvec.append(callback(i))
             out += '= %3.3f\n' % (outvec[i])
             out +=  "--------------------------------------------------\n"
+            out +=  sep+'\n'
         if rcParams['verbose']:
             asaplog.push("--------------------------------------------------")
+            asaplog.push(sep)
             asaplog.push(" %s" % (label))
             asaplog.push("--------------------------------------------------")
+            asaplog.push(sep)
             asaplog.push(out)
             print_log()
-        # disabled because the vector seems more useful
-        #retval = {'axesnames': axesnames, 'axes': axes, 'data': outvec}
         return outvec
 …
             none
         """
         return self._get_column(self._getinttime, row)
+        return self._get_column(self._getinttime, row)
     def get_sourcename(self, row=-1):
 …
         """
         Get a list of Positions on the sky (direction) for the observations.
         Return a float for each integration in the scantable.
+        Return a string for each integration in the scantable.
         Parameters:
             row:    row no of integration. Default -1 return all rows
 …
         return self._get_column(self._getdirectionvec, row)
+    #@print_log_dec
     def set_unit(self, unit='channel'):
         """
 …
         self._add_history("set_unit", varlist)
+    #@print_log_dec
     def set_instrument(self, instr):
         """
 …
         print_log()
+    #@print_log_dec
     def set_feedtype(self, feedtype):
         """
 …
         print_log()
+    #@print_log_dec
     def set_doppler(self, doppler='RADIO'):
         """
 …
         print_log()
+    #@print_log_dec
     def set_freqframe(self, frame=None):
         """
 …
         Parameters:
             frame:   an optional frame type, default 'LSRK'. Valid frames are:
                      'REST', 'TOPO', 'LSRD', 'LSRK', 'BARY',
+                     'TOPO', 'LSRD', 'LSRK', 'BARY',
                      'GEO', 'GALACTO', 'LGROUP', 'CMB'
         Examples:
             scan.set_freqframe('BARY')
         """
+        if frame is None: frame = rcParams['scantable.freqframe']
+        varlist = vars()
+        valid = ['REST', 'TOPO', 'LSRD', 'LSRK', 'BARY', \
+        frame = frame or rcParams['scantable.freqframe']
+        varlist = vars()
+        # "REST" is not implemented in casacore
+        #valid = ['REST', 'TOPO', 'LSRD', 'LSRK', 'BARY', \
+        #           'GEO', 'GALACTO', 'LGROUP', 'CMB']
+        valid = ['TOPO', 'LSRD', 'LSRK', 'BARY', \
                    'GEO', 'GALACTO', 'LGROUP', 'CMB']
 …
         """
         varlist = vars()
+        if mask is None:
+            mask = []
+        mask = mask or []
         try:
             self._flag(mask, unflag)
 …
             else: raise
         self._add_history("clip", varlist)
+    def lag_flag(self, frequency, width=0.0, unit="GHz", insitu=None):
+    #@print_log_dec
+    def lag_flag(self, start, end, unit="MHz", insitu=None):
+    #def lag_flag(self, frequency, width=0.0, unit="GHz", insitu=None):
         """
         Flag the data in 'lag' space by providing a frequency to remove.
         Flagged data in the scantable gets set to 0.0 before the fft.
+        Flagged data in the scantable gets interpolated over the region.
         No taper is applied.
         Parameters:
             frequency:    the frequency (really a period within the bandwidth)
                           to remove
             width:        the width of the frequency to remove, to remove a
                           range of frequencies around the centre.
             unit:         the frequency unit (default "GHz")
+            start:    the start frequency (really a period within the
+                      bandwidth)  or period to remove
+            end:      the end frequency or period to remove
+            unit:     the frequency unit (default "MHz") or "" for
+                      explicit lag channels
         Notes:
             It is recommended to flag edges of the band or strong
+            It is recommended to flag edges of the band or strong
             signals beforehand.
         """
 …
         self._math._setinsitu(insitu)
         varlist = vars()
         base = { "GHz": 1000000000., "MHz": 1000000., "kHz": 1000., "Hz": 1. }
         if not base.has_key(unit):
+        base = { "GHz": 1000000000., "MHz": 1000000., "kHz": 1000., "Hz": 1.}
+        if not (unit == "" or base.has_key(unit)):
             raise ValueError("%s is not a valid unit." % unit)
         try:
+            s = scantable(self._math._lag_flag(self, frequency*base[unit],
+                                               width*base[unit]))
+            if unit == "":
+                s = scantable(self._math._lag_flag(self, start, end, "lags"))
+            else:
+                s = scantable(self._math._lag_flag(self, start*base[unit],
+                                                   end*base[unit], "frequency"))
         except RuntimeError, msg:
             if rcParams['verbose']:
 …
             return s
+    #@print_log_dec
     def create_mask(self, *args, **kwargs):
         """
 …
             c)
             mask only channel 400
+            msk =  scan.create_mask([400, 400])
+        """
+        row = 0
+        if kwargs.has_key("row"):
+            row = kwargs.get("row")
+            msk =  scan.create_mask([400])
+        """
+        row = kwargs.get("row", 0)
         data = self._getabcissa(row)
         u = self._getcoordinfo()[0]
 …
              and args or args[0]
         for window in ws:
+            if (len(window) != 2 or window[0] > window[1] ):
+                raise TypeError("A window needs to be defined as [min, max]")
+            if len(window) == 1:
+                window = [window[0], window[0]]
+            if len(window) == 0 or  len(window) > 2:
+                raise ValueError("A window needs to be defined as [start(, end)]")
+            if window[0] > window[1]:
+                tmp = window[0]
+                window[0] = window[1]
+                window[1] = tmp
             for i in range(n):
                 if data[i] >= window[0] and data[i] <= window[1]:
 …
             source and IF basis, use scantable.set_selection() before using
             this function.
             # provide your scantable is call scan
+            # provide your scantable is called scan
             selection = selector()
             selection.set_name("ORION*")
 …
     def shift_refpix(self, delta):
         """
+        Shift the reference pixel of the Spectra Coordinate by an
         integer amount.
         Parameters:
             delta:   the amount to shift by
+        """
+        Shift the reference pixel of the Spectra Coordinate by an
+        integer amount.
+        Parameters:
+            delta:   the amount to shift by
         Note:
             Be careful using this with broadband data.
         """
         Scantable.shift(self, delta)
+            Be careful using this with broadband data.
+        """
+        Scantable.shift_refpix(self, delta)
     def history(self, filename=None):
 …
     # Maths business
+    #
+    #@print_log_dec
     def average_time(self, mask=None, scanav=False, weight='tint', align=False):
         """
 …
         """
         varlist = vars()
+        if weight is None: weight = 'TINT'
+        if mask is None: mask = ()
+        if scanav: scanav = "SCAN"
+        else: scanav = "NONE"
+        weight = weight or 'TINT'
+        mask = mask or ()
+        scanav = (scanav and 'SCAN') or 'NONE'
         scan = (self, )
         try:
 …
         return s
+    #@print_log_dec
     def convert_flux(self, jyperk=None, eta=None, d=None, insitu=None):
         """
 …
         self._math._setinsitu(insitu)
         varlist = vars()
         if jyperk is None: jyperk = -1.0
         if d is None: d = -1.0
         if eta is None: eta = -1.0
+        jyperk = jyperk or -1.0
+        d = d or -1.0
+        eta = eta or -1.0
         s = scantable(self._math._convertflux(self, d, eta, jyperk))
         s._add_history("convert_flux", varlist)
 …
         else: return s
+    #@print_log_dec
     def gain_el(self, poly=None, filename="", method="linear", insitu=None):
         """
 …
         self._math._setinsitu(insitu)
         varlist = vars()
+        if poly is None:
+            poly = ()
+        poly = poly or ()
         from os.path import expandvars
         filename = expandvars(filename)
 …
         s._add_history("gain_el", varlist)
         print_log()
+        if insitu: self._assign(s)
+        else: return s
+        if insitu:
+            self._assign(s)
+        else:
+            return s
+    #@print_log_dec
     def freq_align(self, reftime=None, method='cubic', insitu=None):
         """
 …
         self._math._setinsitu(insitu)
         varlist = vars()
         if reftime is None: reftime = ""
+        reftime = reftime or ""
         s = scantable(self._math._freq_align(self, reftime, method))
         s._add_history("freq_align", varlist)
 …
         else: return s
+    def opacity(self, tau, insitu=None):
+    #@print_log_dec
+    def opacity(self, tau=None, insitu=None):
         """
         Apply an opacity correction. The data
         and Tsys are multiplied by the correction factor.
         Parameters:
             tau:         Opacity from which the correction factor is
+            tau:         (list of) opacity from which the correction factor is
                          exp(tau*ZD)
+                         where ZD is the zenith-distance
+                         where ZD is the zenith-distance.
+                         If a list is provided, it has to be of length nIF,
+                         nIF*nPol or 1 and in order of IF/POL, e.g.
+                         [opif0pol0, opif0pol1, opif1pol0 ...]
+                         if tau is `None` the opacities are determined from a
+                         model.
             insitu:      if False a new scantable is returned.
                          Otherwise, the scaling is done in-situ
 …
         self._math._setinsitu(insitu)
         varlist = vars()
+        if not hasattr(tau, "__len__"):
+            tau = [tau]
         s = scantable(self._math._opacity(self, tau))
         s._add_history("opacity", varlist)
 …
         else: return s
+    #@print_log_dec
     def bin(self, width=5, insitu=None):
         """
 …
         s._add_history("bin", varlist)
         print_log()
+        if insitu: self._assign(s)
+        else: return s
+        if insitu:
+            self._assign(s)
+        else:
+            return s
+    #@print_log_dec
     def resample(self, width=5, method='cubic', insitu=None):
         """
 …
         else: return s
+    #@print_log_dec
     def average_pol(self, mask=None, weight='none'):
         """
 …
         """
         varlist = vars()
+        if mask is None:
+            mask = ()
+        mask = mask or ()
         s = scantable(self._math._averagepol(self, mask, weight.upper()))
         s._add_history("average_pol", varlist)
 …
         return s
+    #@print_log_dec
     def average_beam(self, mask=None, weight='none'):
         """
 …
         """
         varlist = vars()
+        if mask is None:
+            mask = ()
+        mask = mask or ()
         s = scantable(self._math._averagebeams(self, mask, weight.upper()))
         s._add_history("average_beam", varlist)
 …
         return s
+    def parallactify(self, pflag):
+        """
+        Set a flag to inidcate whether this data should be treated as having
+        been 'parallactified' (total phase == 0.0)
+        Parameters:
+            pflag:  Bool inidcating whether to turn this on (True) or
+                    off (False)
+        """
+        varlist = vars()
+        self._parallactify(pflag)
+        self._add_history("parallactify", varlist)
+    #@print_log_dec
     def convert_pol(self, poltype=None):
         """
         Convert the data to a different polarisation type.
+        Note that you will need cross-polarisation terms for most conversions.
         Parameters:
             poltype:    The new polarisation type. Valid types are:
                         "linear", "stokes" and "circular"
+                        "linear", "circular", "stokes" and "linpol"
         """
         varlist = vars()
 …
         return s
     #def smooth(self, kernel="hanning", width=5.0, insitu=None):
     def smooth(self, kernel="hanning", width=5.0, plot=False, insitu=None):
+    #@print_log_dec
+    def smooth(self, kernel="hanning", width=5.0, order=2, plot=False, insitu=None):
         """
         Smooth the spectrum by the specified kernel (conserving flux).
         Parameters:
             kernel:     The type of smoothing kernel. Select from
                         'hanning' (default), 'gaussian', 'boxcar' and
                         'rmedian'
+                        'hanning' (default), 'gaussian', 'boxcar', 'rmedian'
+                        or 'poly'
             width:      The width of the kernel in pixels. For hanning this is
                         ignored otherwise it defauls to 5 pixels.
                         For 'gaussian' it is the Full Width Half
                         Maximum. For 'boxcar' it is the full width.
+                        For 'rmedian' it is the half width.
+                        For 'rmedian' and 'poly' it is the half width.
+            order:      Optional parameter for 'poly' kernel (default is 2), to
+                        specify the order of the polnomial. Ignored by all other
+                        kernels.
             plot:       plot the original and the smoothed spectra.
                         In this each indivual fit has to be approved, by
 …
         if plot: orgscan = self.copy()
         s = scantable(self._math._smooth(self, kernel.lower(), width))
+        s = scantable(self._math._smooth(self, kernel.lower(), width, order))
         s._add_history("smooth", varlist)
 …
         else: return s
+    def poly_baseline(self, mask=None, order=0, plot=False, uselin=False, insitu=None):
+    #@print_log_dec
+    def poly_baseline(self, mask=None, order=0, plot=False, uselin=False,
+                      insitu=None):
         """
         Return a scan which has been baselined (all rows) by a polynomial.
 …
             return workscan
+    #@print_log_dec
     def rotate_linpolphase(self, angle):
         """
 …
         return
+    #@print_log_dec
     def rotate_xyphase(self, angle):
         """
 …
         return
+    #@print_log_dec
     def swap_linears(self):
         """
         Swap the linear polarisations XX and YY, or better the first two
+        Swap the linear polarisations XX and YY, or better the first two
         polarisations as this also works for ciculars.
         """
 …
         return
+    #@print_log_dec
     def invert_phase(self):
         """
 …
         return
+    #@print_log_dec
     def add(self, offset, insitu=None):
         """
 …
             return s
+    #@print_log_dec
     def scale(self, factor, tsys=True, insitu=None):
         """
 …
         self._setsourcetype(stype)
         self.set_selection(basesel)
+        s._add_history("set_sourcetype", varlist)
+        self._add_history("set_sourcetype", varlist)
+    #@print_log_dec
     def auto_quotient(self, preserve=True, mode='paired', verify=False):
         """
 …
                             preserve: Output = Toff * (on/off) - Toff
                             remove:   Output = Toff * (on/off) - Ton
             mode:           the on/off detection mode
+            mode:           the on/off detection mode
                             'paired' (default)
                             identifies 'off' scans by the
 …
         return s
+    #@print_log_dec
     def mx_quotient(self, mask = None, weight='median', preserve=True):
         """
 …
                             remove:   Output = Toff * (on/off) - Ton
         """
         if mask is None: mask = ()
+        mask = mask or ()
         varlist = vars()
         on = scantable(self._math._mx_extract(self, 'on'))
 …
         return q
+    #@print_log_dec
     def freq_switch(self, insitu=None):
         """
 …
         else: return s
+    #@print_log_dec
     def recalc_azel(self):
         """
 …
         return
+    #@print_log_dec
     def __add__(self, other):
         """
 …
         return self._operation( other, "ADD" )
+    #@print_log_dec
     def __sub__(self, other):
         """
 …
         return self._operation( other, 'SUB' )
+    #@print_log_dec
     def __mul__(self, other):
         """
 …
         return self._operation( other, 'MUL' )
+    #@print_log_dec
     def __div__(self, other):
         """
 …
         basesel = self.get_selection()
         for i in range(self.nrow()):
+            sel = selector()+basesel
+            sel.set_scans(self.getscan(i))
+            sel.set_beams(self.getbeam(i))
+            sel.set_ifs(self.getif(i))
+            sel.set_polarisations(self.getpol(i))
+            self.set_selection(sel)
+            sel = self.get_row_selector(i)
+            self.set_selection(basesel+sel)
             nans = numpy.isnan(self._getspectrum(0))
         if numpy.any(nans):
 …
             self.flag(bnans)
         self.set_selection(basesel)
+    def get_row_selector(self, rowno):
+        return selector(beams=self.getbeam(rowno),
+                        ifs=self.getif(rowno),
+                        pols=self.getpol(rowno),
+                        scans=self.getscan(rowno),
+                        cycles=self.getcycle(rowno))
     def _add_history(self, funcname, parameters):

branches/alma/python/selector.py

-              r1693
+              r1757
     scantables to specific rows.
     """
+    def __init(self):
+        _selector.__init__(self)
+    fields = ["pols", "ifs", "beams", "scans", "cycles", "name", "query"]
+    def __init__(self, *args, **kw):
+        if len(args) == 1:
+            if isinstance(args[0], self.__class__) \
+               or isinstance(args[0], _selector):
+                _selector.__init__(self, args[0])
+            else:
+                raise TypeError("Argument can only be a selector object")
+        else:
+            _selector.__init__(self)
+            for k,v  in kw.items():
+                if k in self.fields:
+                    func = getattr(self, "set_%s" % k)
+                    func(v)
     def reset(self):
 …
         else:
             raise TypeError('Unknown pol type. Please use [0,1...] or ["XX","YY"...]')
     # for the americans
     set_polarizations = set_polarisations
 …
         Merge two selections.
         """
+        if self.is_empty():
+            return other
+        elif other.is_empty():
+            return self
         union = selector()
         gets = [[self._getscans(), other._getscans(), union._setscans],

branches/alma/scons/quietinstall.py

-              r1184
+              r1757
 import SCons
+try:
+    from SCons.Environment import installFunc
+except ImportError:
+    from SCons.Tool.install import installFunc
 def no_output(target, source, env):
 …
     quietinstaller_builder = env.Builder(
         action = env.Action(SCons.Environment.installFunc, no_output),
+        action = env.Action(installFunc, no_output),
         multi=1
+    )

branches/alma/scons/utils.py

-              r1332
+              r1757
+import sys
 import os
 import glob
+import re
+import platform
 def generate(env):
+    def SGlob(pattern):
+        path = env.GetBuildPath('SConscript').replace('SConscript', '')
+        return [ i.replace(path, '') for i in glob.glob(path + pattern) ]
+    def SGlob(pattern, excludedirs=[], recursive=False):
+        # always exclude .svn
+        excludedirs.append(".svn")
+        path = env.GetBuildPath('SConscript').replace('SConscript', '')
+        if recursive:
+            # remove '*' from pattern is accidentally specified
+            pattern=pattern.replace("*", "")
+            out = []
+            for d, ld, fls in os.walk(path):
+                # remove directorys to be excluded
+                for exd in excludedirs:
+                    if exd in ld:
+                        ld.remove(exd)
+                for f in fls:
+                    if f.endswith(pattern):
+                        drel=d.replace(path,"")
+                        out.append(os.path.join(drel,f))
+            return out
+        else:
+            return [ i.replace(path, '') for i in  glob.glob(path + pattern) ]
     env.SGlob = SGlob
     def AddCustomPath(path=""):
         if not len(path) or not os.path.exists(path):
             return
+    def AddCustomPath(path=None):
+        if path is None or not os.path.exists(path):
+            env.Exit(1)
         env.PrependUnique(CPPPATH = [os.path.join(path, "include")])
         env.PrependUnique(LIBPATH = [os.path.join(path, "lib")])
 …
     def AddCustomPackage(pkgname=None):
         if pkgname is None:
             return
         pkgroot = env.get("%sroot" % pkgname, None)
         pkgincd = env.get("%sincdir" % pkgname, None)
         pkglibd = env.get("%slibdir" % pkgname, None)
         incd = None
         libd = None
         if pkgroot is not None:
             incd = os.path.join(pkgroot, "include")
             libd = os.path.join(pkgroot, "lib")
         else:
             if pkgincd is not None:
                 incd = pkgincd
             if pkglibd is not None:
                 libd = pkglibd
         if incd is not None:
             if not os.path.exists(incd):
                 print "Custom %s include dir '%s' not found" % (pkgname, incd)
                 env.Exit(1)
             env.PrependUnique(CPPPATH = [incd])
         if libd is not None:
             if not os.path.exists(libd):
                 print "Custom %s lib dir '%s' not found" % (pkgname, libd)
                 env.Exit(1)
             env.PrependUnique(LIBPATH = [libd])
+            return
+        pkgroot = env.get("%sroot" % pkgname, None)
+        pkgincd = env.get("%sincdir" % pkgname, None)
+        pkglibd = env.get("%slibdir" % pkgname, None)
+        incd = None
+        libd = None
+        if pkgroot is not None:
+            incd = os.path.join(pkgroot, "include")
+            libd = os.path.join(pkgroot, "lib")
+        else:
+            if pkgincd is not None:
+                incd = pkgincd
+            if pkglibd is not None:
+                libd = pkglibd
+        if incd is not None:
+            if not os.path.exists(incd):
+                print "Custom %s include dir '%s' not found" % (pkgname, incd)
+                env.Exit(1)
+            env.PrependUnique(CPPPATH = [incd])
+        if libd is not None:
+            if not os.path.exists(libd):
+                print "Custom %s lib dir '%s' not found" % (pkgname, libd)
+                env.Exit(1)
+            env.PrependUnique(LIBPATH = [libd])
     env.AddCustomPackage = AddCustomPackage
+    def PlatformIdent():
+        p = sys.platform
+        # replace the trailing 2 in linux2
+        p = re.sub(re.compile("2$"), "", p)
+        return p + "_" + platform.machine()
+    env.PlatformIdent = PlatformIdent
+    def MergeFlags():
+        def _to_list(xf):
+            if xf.count(","):
+                return xf.split(",")
+            return xf.split()
+        xf=env.get("extracppflags", None)
+        if xf:
+            env.AppendUnique(CPPFLAGS=_to_list(xf))
+        xf=env.get("extralinkflags", None)
+        if xf:
+            env.AppendUnique(LINKFLAGS=_to_list(xf))
+            env.AppendUnique(SHLINKFLAGS=_to_list(xf))
+        xf=env.get("extracxxflags", None)
+        if xf:
+            env.AppendUnique(CXXFLAGS=_to_list(xf))
+        xf=env.get("extrafflags", None)
+        if xf:
+            env.AppendUnique(FORTRANFLAGS=_to_list(xf))
+            env.AppendUnique(SHFORTRANFLAGS=_to_list(xf))
+        xf=env.get("extracflags", None)
+        if xf:
+            env.AppendUnique(CCFLAGS=_to_list(xf))
+    # set the extra flags if available
+    MergeFlags()
     def CheckFortran(conf):
+        if not conf.env.has_key("FORTRAN"):
+            # auto-detect fortran
+            detect_fortran = conf.env.Detect(['gfortran', 'g77', 'f77'])
+            if not detect_fortran:
+                print "No fortran compiler found. Specify FORTRAN and f2clib."
+                conf.env.Exit(1)
+            conf.env["FORTRAN"] = detect_fortran
+        def getf2clib(fc):
             fdict = {'gfortran': 'gfortran', 'g77': 'g2c', 'f77': 'f2c'}
+            f2clib = conf.env.get("f2clib", fdict[detect_fortran])
+            if not conf.CheckLib(f2clib):
+                env.Exit(1)
+        else:
+            if not conf.env.has_key("f2clib"):
+                print "A custom fortran compiler also needs f2clib defined"
+                env.Exit(1)
+            else:
+                if not conf.CheckLib(env["f2clib"]):
+                    env.Exit(1)
+        if conf.env["FORTRAN"].startswith("g77"):
+            return fdict[fc]
+        if not conf.env.has_key("FORTRAN"):
+            # auto-detect fortran
+            detect_fortran = conf.env.Detect(['gfortran', 'g77', 'f77'])
+            conf.env["FORTRAN"] = detect_fortran
+        f2clib = conf.env.get("f2clib", getf2clib(conf.env["FORTRAN"]))
+        if not conf.CheckLib(f2clib):
+            conf.env.Exit(1)
+        if conf.env["FORTRAN"].startswith("g77"):
             fflags = ["-Wno-globals", "-fno-second-underscore"]
+            conf.env.Append(SHFORTRANFLAGS=fflags)
+            conf.env.Append(FORTRANFLAGS=fflags)
+            conf.env.AppendUnique(SHFORTRANFLAGS=fflags)
+            conf.env.AppendUnique(FORTRANFLAGS=fflags)
+        conf.env.AppendUnique(SHFORTRANFLAGS=['-fPIC'])
     env.CheckFortran = CheckFortran
 …
     env.WalkDirTree = WalkDirTree
     def null_action(target, source, env): return 0

branches/alma/src/Makefile

-              r1704
+              r1757
              STAsciiWriter.o \
              STFITSImageWriter.o \
+             STAtmosphere.o \
              Scantable.o \
              Templates.o
 …
              python_LineCatalog.o \
              python_SrcType.o \
+             python_STAtmosphere.o \
+             python_STCoordinate.o \
              python_asap.o
 …
              STWriter.h \
              STAsciiWriter.h \
+             STFITSImageWriter.h
+             STFITSImageWriter.h \
+             IndexedCompare.h \
+             STAtmosphere.h \
+             STCoordinate.h
 STATICCCLIB := libasap.a

branches/alma/src/MathUtils.cpp

-              r1603
+              r1757
 #include <scimath/Mathematics/MedianSlider.h>
 #include <casa/Exceptions/Error.h>
+#include <scimath/Fitting/LinearFit.h>
+#include <scimath/Functionals/Polynomial.h>
+#include <scimath/Mathematics/AutoDiff.h>
 #include "MathUtils.h"
 …
   MedianSlider ms(hwidth);
   Slice sl(0, fwidth-1);
   Float medval = ms.add(const_cast<Vector<Float>& >(in)(sl),
+  Float medval = ms.add(const_cast<Vector<Float>& >(in)(sl),
                   const_cast<Vector<Bool>& >(flag)(sl));
   uInt n = in.nelements();
   for (uInt i=hwidth; i<(n-hwidth); ++i) {
     // add data value
     out[i] = ms.add(in[i+hwidth], flag[i+hwidth]);
     outflag[i] = (ms.nval() == 0);
+  }
   // replicate edge values from fisrt value with full width of values
+    out[i] = ms.add(in[i+hwidth], flag[i+hwidth]);
+    outflag[i] = (ms.nval() == 0);
+  }
+  // replicate edge values from first value with full width of values
   for (uInt i=0;i<hwidth;++i) {
     out[i] = out[hwidth];
     outflag[i] = outflag[hwidth];
+    outflag[i] = outflag[hwidth];
     out[n-1-i] = out[n-1-hwidth];
+    outflag[n-1-i] = outflag[n-1-hwidth];
+  }
+}
+    outflag[n-1-i] = outflag[n-1-hwidth];
+  }
+}
+void mathutil::polyfit(Vector<Float>& out, Vector<Bool>& outmask,
+                       const Vector<Float>& in, const Vector<Bool>& mask,
+                       float width, int order)
+{
+  Int hwidth = Int(width+0.5);
+  Int fwidth = hwidth*2+1;
+  out.resize(in.nelements());
+  outmask.resize(mask.nelements());
+  LinearFit<Float> fitter;
+  Polynomial<Float> poly(order);
+  fitter.setFunction(poly);
+  Vector<Float> sigma(fwidth);
+  sigma = 1.0;
+  Vector<Float> parms;
+  Vector<Float> x(fwidth);
+  indgen(x);
+  uInt n = in.nelements();
+  for (uInt i=hwidth; i<(n-hwidth); ++i) {
+    // add data value
+    if (mask[i]) {
+      Slice sl(i-hwidth, fwidth);
+      const Vector<Float> &y = const_cast<Vector<Float>& >(in)(sl);
+      const Vector<Bool> &m = const_cast<Vector<Bool>& >(mask)(sl);
+      parms = fitter.fit(x, y, sigma, &m);
+      poly.setCoefficients(parms);
+      out[i] = poly(x[hwidth]);//cout << in[i] <<"->"<<out[i]<<endl;
+    } else {
+      out[i] = in[i];
+    }
+    outmask[i] = mask[i];
+  }
+  // replicate edge values from first value with full width of values
+  for (uInt i=0;i<hwidth;++i) {
+    out[i] = out[hwidth];
+    outmask[i] = outmask[hwidth];
+    out[n-1-i] = out[n-1-hwidth];
+    outmask[n-1-i] = outmask[n-1-hwidth];
+  }
+}

branches/alma/src/MathUtils.h

-              r1603
+              r1757
  * @param ignoreOther drop every second channel (NYI)
  */
 void hanning(casa::Vector<casa::Float>& out,
+void hanning(casa::Vector<casa::Float>& out,
              casa::Vector<casa::Bool>& outmask,
              const casa::Vector<casa::Float>& in,
+             const casa::Vector<casa::Float>& in,
              const casa::Vector<casa::Bool>& mask,
              casa::Bool relaxed=casa::False,
 …
 /**
  * Apply a running median to  a masked vector.
  * Edge solution:  The first and last hwidth channels will be replicated
+ * Edge solution:  The first and last hwidth channels will be replicated
  * from the first/last value from a full window.
  * @param out the smoothed vector
 …
  * @param hwidth half-width of the smoothing window
  */
+ void runningMedian(casa::Vector<casa::Float>& out,
+ void runningMedian(casa::Vector<casa::Float>& out,
+                   casa::Vector<casa::Bool>& outflag,
+                   const casa::Vector<casa::Float>& in,
+                   const casa::Vector<casa::Bool>& flag,
+                   float hwidth);
+ void polyfit(casa::Vector<casa::Float>& out,
                    casa::Vector<casa::Bool>& outmask,
                    const casa::Vector<casa::Float>& in,
+                   const casa::Vector<casa::Float>& in,
                    const casa::Vector<casa::Bool>& mask,
                    float hwidth);
+                   float hwidth, int order);
 // Generate specified statistic

branches/alma/src/RowAccumulator.cpp

-              r1603
+              r1757
   Float totalweight = weight;
   MaskedArray<Float> data(v,m);
   if ( weightType_ == asap::VAR ) {
+  if ( weightType_ == asap::W_VAR ) {
     if (m.nelements() == userMask_.nelements()) {
       Float fac = 1.0/variance(data(userMask_));
 …
   Float w = 1.0;
   tsysSum_ += v[0];
   if ( weightType_ == asap::TSYS  || weightType_ == asap::TINTSYS ) {
+  if ( weightType_ == asap::W_TSYS  || weightType_ == asap::W_TINTSYS ) {
     w /= (v[0]*v[0]);
+  }
 …
   Float w = 1.0;
   intervalSum_ += inter;
   if ( weightType_ == asap::TINT || weightType_ == asap::TINTSYS ) {
+  if ( weightType_ == asap::W_TINT || weightType_ == asap::W_TINTSYS ) {
     w /= Float(inter);
+  }

branches/alma/src/RowAccumulator.h

r1603	r1757
33	33	* Constructor taking a weight type as defined in @ref STDefs
34	34	*/
35		explicit RowAccumulator(WeightType wt = asap::NONE);
	35	explicit RowAccumulator(WeightType wt = asap::W_NONE);
36	36
37	37	~RowAccumulator();

branches/alma/src/STAsciiWriter.cpp

-              r1657
+              r1757
    String rootName(fileName);
-   if (rootName.length()==0) rootName = String("ascii");
   Block<String> cols(4);
 …
     String dirtype = stable.getDirectionRefString();
     ostringstream onstr;
+    onstr << "SCAN" << rec.asuInt("SCANNO")
+    << "_CYCLE" << rec.asuInt("CYCLENO")
+    << "_BEAM" << rec.asuInt("BEAMNO")
+    << "_IF" << rec.asuInt("IFNO");
+    if (rootName.length()==0) {
+      rootName = String("ascii");
+    }
+    if (tab.nrow() > 1) {
+      if (stable.nscan() > 1)
+        onstr << "_SCAN" << rec.asuInt("SCANNO");
+      if (stable.ncycle(rec.asuInt("SCANNO")) > 1)
+        onstr << "_CYCLE" << rec.asuInt("CYCLENO");
+      if (stable.nbeam(rec.asuInt("SCANNO")) > 1)
+        onstr << "_BEAM" << rec.asuInt("BEAMNO");
+      if (stable.nif(rec.asuInt("SCANNO")) > 1)
+        onstr << "_IF" << rec.asuInt("IFNO");
+    }
     String fName = rootName + String(onstr) + String(".txt");
     ofstream of(fName.chars(), ios::trunc);

branches/alma/src/STAttr.cpp

-              r1387
+              r1757
    TidGainElPoly_(2) = -3.219093e-4;
+   // 2009-09-15 - 13mm (22.2GHz) receiver
    ParkesGainElPoly_.resize(3);
    ParkesGainElPoly_(0) = 0.296759e-1;
    ParkesGainElPoly_(1) = -0.293124e-3;
    ParkesGainElPoly_(2) = 0.264295e-6;
+   ParkesGainElPoly_(0) = -0.194031;
+   ParkesGainElPoly_(1) = 0.457724e-1;
+   ParkesGainElPoly_(2) = -0.438659e-3;
+}

branches/alma/src/STDefs.h

-              r1388
+              r1757
 namespace asap {
-  enum AxisNo { BeamAxis=0,
-                IFAxis,
-                PolAxis,
-                ChanAxis,
-                nAxes};
   enum Instrument {UNKNOWNINST=0,
 …
   enum FeedPolType {UNKNOWNFEED, LINEAR, CIRCULAR, N_POL};
+  enum WeightType {NONE=0, VAR, TSYS, TINT, TINTSYS, N_WEIGHTTYPES};
+  enum TableType {MEMORY=0, PERSISTENT};
+  enum WeightType {W_NONE=0, W_VAR, W_TSYS, W_TINT, W_TINTSYS, W_N_WEIGHTTYPES};

branches/alma/src/STFITSImageWriter.cpp

-              r1604
+              r1757
   TableIterator iter(tab, cols);
   // Open data file
   while ( !iter.pastEnd() ) {
     Table t = iter.table();
 …
     String dirtype = stable.getDirectionRefString();
     ostringstream onstr;
+    onstr << "SCAN" << rec.asuInt("SCANNO")
+    << "_CYCLE" << rec.asuInt("CYCLENO")
+    << "_BEAM" << rec.asuInt("BEAMNO")
+    << "_IF" << rec.asuInt("IFNO")
+    << "_POL" << rec.asuInt("POLNO");
+    if (rootName.length()==0) {
+      rootName = "fits";
+    }
+    if (tab.nrow() > 1) {
+      if (stable.nscan() > 1)
+        onstr << "_SCAN" << rec.asuInt("SCANNO");
+      if (stable.ncycle(rec.asuInt("SCANNO")) > 1)
+        onstr << "_CYCLE" << rec.asuInt("CYCLENO");
+      if (stable.nbeam(rec.asuInt("SCANNO")) > 1)
+        onstr << "_BEAM" << rec.asuInt("BEAMNO");
+      if (stable.nif(rec.asuInt("SCANNO")) > 1)
+        onstr << "_IF" << rec.asuInt("IFNO");
+      if (stable.npol(rec.asuInt("SCANNO")) > 1)
+        onstr << "_POL" << rec.asuInt("POLNO");
+    }
     String fileName = rootName + String(onstr) + String(".fits");
     int row0 = t.rowNumbers(tab)[0];
 …
+    }
     fits_close_file(fptr, &status);
+    ostringstream oss;
+    oss << "Wrote " << fileName;
+    pushLog(String(oss));
     //pushLog(String(oss));
     ++iter;

branches/alma/src/STFiller.cpp

-              r1684
+              r1757
     freqFrame = "REST";
+  }
+  table_->frequencies().setFrame(freqFrame);
+  // set both "FRAME" and "BASEFRAME"
+  table_->frequencies().setFrame(freqFrame, false);
+  table_->frequencies().setFrame(freqFrame,true);
+  //table_->focus().setParallactify(true);
+}
 …
     if ( status != 0 ) break;
     n += 1;
     Regex filterrx(".*[SL|PA]$");
     Regex obsrx("^AT.+");
 …
     /// @todo this has to change when nchan isn't global anymore
     //id = table_->frequencies().addEntry(Double(header_->nchan/2),
     //                                        pksrec.refFreq, pksrec.freqInc);
+    //                                    pksrec.refFreq, pksrec.freqInc);
     if ( pksrec.nchan == 1 ) {
       id = table_->frequencies().addEntry(Double(0),
 …
     RecordFieldPtr<uInt> mweatheridCol(rec, "WEATHER_ID");
     *mweatheridCol = id;
     RecordFieldPtr<uInt> mfocusidCol(rec, "FOCUS_ID");
     id = table_->focus().addEntry(pksrec.focusAxi, pksrec.focusTan,
                                   pksrec.focusRot);
+    id = table_->focus().addEntry(pksrec.parAngle, pksrec.focusAxi,
+                                  pksrec.focusTan, pksrec.focusRot);
     *mfocusidCol = id;
     RecordFieldPtr<Array<Double> > dirCol(rec, "DIRECTION");
 …
     RecordFieldPtr<Float> elCol(rec, "ELEVATION");
     *elCol = pksrec.elevation;
-    RecordFieldPtr<Float> parCol(rec, "PARANGLE");
-    *parCol = pksrec.parAngle;
     RecordFieldPtr< Array<Float> > specCol(rec, "SPECTRA");
 …
+  }
   // set frame keyword of FREQUENCIES table
+  // set FRAME and BASEFRAME keyword of FREQUENCIES table
   if ( header_->freqref != "TOPO" ) {
     table_->frequencies().setFrame( header_->freqref, false ) ;
+    table_->frequencies().setFrame( header_->freqref, true ) ;
+  }

branches/alma/src/STFocus.cpp

-              r957
+              r1757
+}
+asap::STFocus::STFocus( casa::Table tab ) : STSubTable(tab, name_)
+STFocus::STFocus( casa::Table tab ) :
+  STSubTable(tab, name_)
+{
+  parangleCol_.attach(table_,"PARANGLE");
   rotationCol_.attach(table_,"ROTATION");
   axisCol_.attach(table_,"AXIS");
 …
+}
 STFocus& asap::STFocus::operator =( const STFocus & other )
+STFocus& STFocus::operator =( const STFocus & other )
+{
   if (this != &other) {
     static_cast<STSubTable&>(*this) = other;
+    parangleCol_.attach(table_,"PARANGLE");
     rotationCol_.attach(table_,"ROTATION");
     axisCol_.attach(table_,"AXIS");
 …
   return *this;
+}
 void asap::STFocus::setup( )
+void STFocus::setup( )
+{
   // add to base class table
+  table_.addColumn(ScalarColumnDesc<Float>("PARANGLE"));
   table_.addColumn(ScalarColumnDesc<Float>("ROTATION"));
   table_.addColumn(ScalarColumnDesc<Float>("AXIS"));
 …
   table_.addColumn(ScalarColumnDesc<Float>("XYPHASE"));
   table_.addColumn(ScalarColumnDesc<Float>("XYPHASEOFFSET"));
+  table_.rwKeywordSet().define("PARALLACTIFY", False);
   // new cached columns
+  parangleCol_.attach(table_,"PARANGLE");
   rotationCol_.attach(table_,"ROTATION");
   axisCol_.attach(table_,"AXIS");
 …
+}
 uInt STFocus::addEntry( Float fax, Float ftan, Float frot, Float hand,
                         Float user, Float mount,
                         Float xyphase, Float xyphaseoffset)
+  uInt STFocus::addEntry( Float pa, Float fax, Float ftan, Float frot, Float hand,
+                          Float user, Float mount,
+                          Float xyphase, Float xyphaseoffset)
+{
+  Table result = table_( near(table_.col("ROTATION"), frot)
+                    && near(table_.col("AXIS"), fax)
+                    && near(table_.col("TAN"), ftan)
+                    && near(table_.col("HAND"), hand)
+                    && near(table_.col("USERPHASE"), user)
+                    && near(table_.col("MOUNT"), mount)
+                    && near(table_.col("XYPHASE"), xyphase)
+                    && near(table_.col("XYPHASEOFFSET"), xyphaseoffset)
+                    );
+  Table result = table_(  near(table_.col("PARANGLE"), pa)
+                          && near(table_.col("ROTATION"), frot)
+                          && near(table_.col("AXIS"), fax)
+                          && near(table_.col("TAN"), ftan)
+                          && near(table_.col("HAND"), hand)
+                          && near(table_.col("USERPHASE"), user)
+                          && near(table_.col("MOUNT"), mount)
+                          && near(table_.col("XYPHASE"), xyphase)
+                          && near(table_.col("XYPHASEOFFSET"), xyphaseoffset)
+                          );
   uInt resultid = 0;
   if ( result.nrow() > 0) {
 …
       resultid++;
+    }
+    parangleCol_.put(rno, pa);
     rotationCol_.put(rno, frot);
     axisCol_.put(rno, fax);
 …
+}
 void asap::STFocus::getEntry( Float& rotation, Float& angle, Float& ftan,
                               Float& hand, Float& user, Float& mount,
                               Float& xyphase, Float& xyphaseoffset,
                               uInt id) const
+  void STFocus::getEntry( Float& pa, Float& rotation, Float& angle, Float& ftan,
+                                Float& hand, Float& user, Float& mount,
+                                Float& xyphase, Float& xyphaseoffset,
+                                uInt id) const
+{
   Table t = table_(table_.col("ID") == Int(id) );
 …
   // get first row - there should only be one matching id
   const TableRecord& rec = row.get(0);
+  pa = rec.asFloat("PARANGLE");
   rotation = rec.asFloat("ROTATION");
   angle = rec.asFloat("AXIS");
 …
 casa::Float asap::STFocus::getTotalFeedAngle( casa::uInt id ) const
+casa::Float STFocus::getTotalAngle( casa::uInt id ) const
+{
   Float total = 0.0f;
   Table t = table_(table_.col("ID") == Int(id) );
   if (t.nrow() == 0 ) {
+    throw(AipsError("STFocus::getEntry - id out of range"));
+    throw(AipsError("STFocus::getTotalAngle - id out of range"));
+  }
+  if (table_.keywordSet().asBool("PARALLACTIFY")) {
+    return 0.0f;
+  }
   ROTableRow row(t);
   // get first row - there should only be one matching id
   const TableRecord& rec = row.get(0);
+  total += rec.asFloat("PARANGLE");
   total += rec.asFloat("ROTATION");
   total += rec.asFloat("USERPHASE");
 …
   return total;
+}
+}
+casa::Float asap::STFocus::getFeedHand( casa::uInt id ) const
+casa::Float STFocus::getFeedHand( casa::uInt id ) const
+{
   Table t = table_(table_.col("ID") == Int(id) );
 …
+}
+void STFocus::setParallactify(bool istrue) {
+  table_.rwKeywordSet().define("PARALLACTIFY", Bool(istrue));
+}
+}

branches/alma/src/STFocus.h

-              r1353
+              r1757
   STFocus& operator=(const STFocus& other);
   casa::uInt addEntry( casa::Float faxis, casa::Float ftan,
+  casa::uInt addEntry( casa::Float pa, casa::Float faxis, casa::Float ftan,
                        casa::Float frot, casa::Float hand=1.0f,
                        casa::Float mount=0.0f, casa::Float user=0.0f,
+                       casa::Float xyphase=0.0f, casa::Float xyphaseoffset=0.0f);
+                       casa::Float xyphase=0.0f,
+                       casa::Float xyphaseoffset=0.0f);
   void getEntry( casa::Float& fax, casa::Float& ftan,
+  void getEntry( casa::Float& pa, casa::Float& fax, casa::Float& ftan,
                  casa::Float& frot, casa::Float& hand,
                  casa::Float& mount, casa::Float& user,
 …
                  casa::uInt id) const;
+  casa::Float getTotalFeedAngle(casa::uInt id) const;
+  casa::Float getTotalAngle(casa::uInt id) const;
+  casa::Float getParAngle(casa::uInt id) const {
+    return parangleCol_(id);
+  }
   casa::Float getFeedHand(casa::uInt id) const;
+  void setParallactify(bool istrue=false);
   const casa::String& name() const { return name_; }
 …
   static const casa::String name_;
   casa::ScalarColumn<casa::Float> rotationCol_, axisCol_,
+                                  tanCol_,handCol_,
+                                  mountCol_,userCol_,
+                                  xyphCol_,xyphoffCol_;
+    tanCol_,handCol_, parangleCol_,
+    mountCol_,userCol_, xyphCol_,xyphoffCol_,;
 };

branches/alma/src/STFrequencies.cpp

-              r1603
+              r1757
 **/
 SpectralCoordinate
   asap::STFrequencies::getSpectralCoordinate( const MDirection& md,
+  STFrequencies::getSpectralCoordinate( const MDirection& md,
                                               const MPosition& mp,
                                               const MEpoch& me,
 …
+{
   Vector<Float> offset(1,0.0);
   Vector<Float> factors(1,1.0/width);
+  Vector<Float> factors(1,width);
   Vector<Int> newshape;
   CoordinateSystem csys;
 …
         << rec.asDouble("REFVAL") << setw(7)
         << rec.asDouble("REFPIX")
         << setw(12)
+        << setw(15)
         << rec.asDouble("INCREMENT");
+  }
 …
     int f = outstr.find_first_not_of(' ');
     int l = outstr.find_last_not_of(' ', outstr.size());
     if (f < 0) {
       f = 0;
+    }
     if ( l < f  || l < f ) {
+    if (f < 0) {
+      f = 0;
+    }
+    if ( l < f  || l < f ) {
       l = outstr.size();
+    }
 …
+}
 void STFrequencies::shiftRefPix(int npix, uInt id)
+void STFrequencies::shiftRefPix(int npix, uInt id)
+{
   Table t = table_(table_.col("ID") == Int(id) );

branches/alma/src/STLineFinder.cpp

-              r1603
+              r1757
 #include "STLineFinder.h"
 #include "STFitter.h"
+#include "IndexedCompare.h"
 // STL
 …
 protected:
    // supplementary function to control running mean calculations.
    // It adds a specified channel to the running mean box and
+   // supplementary function to control running mean/median calculations.
+   // It adds a specified channel to the running box and
    // removes (ch-maxboxnchan+1)'th channel from there
    // Channels, for which the mask is false or index is beyond the
 …
                                            // last point of the detected line
                                            //
+   bool itsUseMedian;                      // true if median statistics is used
+                                           // to determine the noise level, otherwise
+                                           // it is the mean of the lowest 80% of deviations
+                                           // (default)
+   int itsNoiseSampleSize;                 // sample size used to estimate the noise statistics
+                                           // Negative value means the whole spectrum is used (default)
 public:
 …
    LFAboveThreshold(std::list<pair<int,int> > &in_lines,
                     int in_min_nchan = 3,
+                    casa::Float in_threshold = 5) throw();
+                    casa::Float in_threshold = 5,
+                    bool use_median = false,
+                    int noise_sample_size = -1) throw();
    virtual ~LFAboveThreshold() throw();
 …
 ///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+//
+// LFNoiseEstimator  a helper class designed to estimate off-line variance
+//                   using statistics depending on the distribution of
+//                   values (e.g. like a median)
+//
+//                   Two statistics are supported: median and an average of
+//                   80% of smallest values.
+//
+struct LFNoiseEstimator {
+   // construct an object
+   // size - maximum sample size. After a size number of elements is processed
+   // any new samples would cause the algorithm to drop the oldest samples in the
+   // buffer.
+   explicit LFNoiseEstimator(size_t size);
+   // add a new sample
+   // in - the new value
+   void add(float in);
+   // median of the distribution
+   float median() const;
+   // mean of lowest 80% of the samples
+   float meanLowest80Percent() const;
+   // return true if the buffer is full (i.e. statistics are representative)
+   inline bool filledToCapacity() const { return itsBufferFull;}
+protected:
+   // update cache of sorted indices
+   // (it is assumed that itsSampleNumber points to the newly
+   // replaced element)
+   void updateSortedCache() const;
+   // build sorted cache from the scratch
+   void buildSortedCache() const;
+   // number of samples accumulated so far
+   // (can be less than the buffer size)
+   size_t numberOfSamples() const;
+   // this helper method builds the cache if
+   // necessary using one of the methods
+   void fillCacheIfNecessary() const;
+private:
+   // buffer with samples (unsorted)
+   std::vector<float> itsVariances;
+   // current sample number (<=itsVariances.size())
+   size_t itsSampleNumber;
+   // true, if the buffer all values in the sample buffer are used
+   bool itsBufferFull;
+   // cached indices into vector of samples
+   mutable std::vector<size_t> itsSortedIndices;
+   // true if any of the statistics have been obtained at least
+   // once. This flag allows to implement a more efficient way of
+   // calculating statistics, if they are needed at once and not
+   // after each addition of a new element
+   mutable bool itsStatisticsAccessed;
+};
+//
+///////////////////////////////////////////////////////////////////////////////
 } // namespace asap
+///////////////////////////////////////////////////////////////////////////////
+//
+// LFNoiseEstimator  a helper class designed to estimate off-line variance
+//                   using statistics depending on the distribution of
+//                   values (e.g. like a median)
+//
+//                   Two statistics are supported: median and an average of
+//                   80% of smallest values.
+//
+// construct an object
+// size - maximum sample size. After a size number of elements is processed
+// any new samples would cause the algorithm to drop the oldest samples in the
+// buffer.
+LFNoiseEstimator::LFNoiseEstimator(size_t size) : itsVariances(size),
+     itsSampleNumber(0), itsBufferFull(false), itsSortedIndices(size),
+     itsStatisticsAccessed(false)
+{
+   AlwaysAssert(size>0,AipsError);
+}
+// add a new sample
+// in - the new value
+void LFNoiseEstimator::add(float in)
+{
+   if (isnan(in)) {
+       // normally it shouldn't happen
+       return;
+   }
+   itsVariances[itsSampleNumber] = in;
+   if (itsStatisticsAccessed) {
+       // only do element by element addition if on-the-fly
+       // statistics are needed
+       updateSortedCache();
+   }
+   // advance itsSampleNumber now
+   ++itsSampleNumber;
+   if (itsSampleNumber == itsVariances.size()) {
+       itsSampleNumber = 0;
+       itsBufferFull = true;
+   }
+   AlwaysAssert(itsSampleNumber<itsVariances.size(),AipsError);
+}
+// number of samples accumulated so far
+// (can be less than the buffer size)
+size_t LFNoiseEstimator::numberOfSamples() const
+{
+  // the number of samples accumulated so far may be less than the
+  // buffer size
+  const size_t nSamples = itsBufferFull ? itsVariances.size(): itsSampleNumber;
+  AlwaysAssert( (nSamples > 0) && (nSamples <= itsVariances.size()), AipsError);
+  return nSamples;
+}
+// this helper method builds the cache if
+// necessary using one of the methods
+void LFNoiseEstimator::fillCacheIfNecessary() const
+{
+  if (!itsStatisticsAccessed) {
+      if ((itsSampleNumber!=0) || itsBufferFull) {
+          // build the whole cache efficiently
+          buildSortedCache();
+      } else {
+          updateSortedCache();
+      }
+      itsStatisticsAccessed = true;
+  } // otherwise, it is updated in 'add' using on-the-fly method
+}
+// median of the distribution
+float LFNoiseEstimator::median() const
+{
+  fillCacheIfNecessary();
+  // the number of samples accumulated so far may be less than the
+  // buffer size
+  const size_t nSamples = numberOfSamples();
+  const size_t medSample = nSamples / 2;
+  AlwaysAssert(medSample < itsSortedIndices.size(), AipsError);
+  return itsVariances[itsSortedIndices[medSample]];
+}
+// mean of lowest 80% of the samples
+float LFNoiseEstimator::meanLowest80Percent() const
+{
+  fillCacheIfNecessary();
+  // the number of samples accumulated so far may be less than the
+  // buffer size
+  const size_t nSamples = numberOfSamples();
+  float result = 0;
+  size_t numpt=size_t(0.8*nSamples);
+  if (!numpt) {
+      numpt=nSamples; // no much else left,
+                     // although it is very inaccurate
+  }
+  AlwaysAssert( (numpt > 0) && (numpt<itsSortedIndices.size()), AipsError);
+  for (size_t ch=0; ch<numpt; ++ch) {
+       result += itsVariances[itsSortedIndices[ch]];
+  }
+  result /= float(numpt);
+  return result;
+}
+// update cache of sorted indices
+// (it is assumed that itsSampleNumber points to the newly
+// replaced element)
+void LFNoiseEstimator::updateSortedCache() const
+{
+  // the number of samples accumulated so far may be less than the
+  // buffer size
+  const size_t nSamples = numberOfSamples();
+  if (itsBufferFull) {
+      // first find the index of the element which is being replaced
+      size_t index = nSamples;
+      for (size_t i=0; i<nSamples; ++i) {
+           AlwaysAssert(i < itsSortedIndices.size(), AipsError);
+           if (itsSortedIndices[i] == itsSampleNumber) {
+               index = i;
+               break;
+           }
+      }
+      AlwaysAssert( index < nSamples, AipsError);
+      const vector<size_t>::iterator indStart = itsSortedIndices.begin();
+      // merge this element with preceeding block first
+      if (index != 0) {
+          // merge indices on the basis of variances
+          inplace_merge(indStart,indStart+index,indStart+index+1,
+                        indexedCompare<size_t>(itsVariances.begin()));
+      }
+      // merge with the following block
+      if (index + 1 != nSamples) {
+          // merge indices on the basis of variances
+          inplace_merge(indStart,indStart+index+1,indStart+nSamples,
+                        indexedCompare<size_t>(itsVariances.begin()));
+      }
+  } else {
+      // itsSampleNumber is the index of the new element
+      AlwaysAssert(itsSampleNumber < itsSortedIndices.size(), AipsError);
+      itsSortedIndices[itsSampleNumber] = itsSampleNumber;
+      if (itsSampleNumber >= 1) {
+          // we have to place this new sample in
+          const vector<size_t>::iterator indStart = itsSortedIndices.begin();
+          // merge indices on the basis of variances
+          inplace_merge(indStart,indStart+itsSampleNumber,indStart+itsSampleNumber+1,
+                        indexedCompare<size_t>(itsVariances.begin()));
+      }
+  }
+}
+// build sorted cache from the scratch
+void LFNoiseEstimator::buildSortedCache() const
+{
+  // the number of samples accumulated so far may be less than the
+  // buffer size
+  const size_t nSamples = numberOfSamples();
+  AlwaysAssert(nSamples <= itsSortedIndices.size(), AipsError);
+  for (size_t i=0; i<nSamples; ++i) {
+       itsSortedIndices[i]=i;
+  }
+  // sort indices, but check the array of variances
+  const vector<size_t>::iterator indStart = itsSortedIndices.begin();
+  stable_sort(indStart,indStart+nSamples, indexedCompare<size_t>(itsVariances.begin()));
+}
+//
+///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 …
+}
 // supplementary function to control running mean calculations.
 // It adds a specified channel to the running mean box and
+// supplementary function to control running mean/median calculations.
+// It adds a specified channel to the running box and
 // removes (ch-max_box_nchan+1)'th channel from there
 // Channels, for which the mask is false or index is beyond the
 …
                 (meanch2-square(meanch));
       linmean=coeff*(Float(cur_channel)-meanch)+mean;
+      linvariance=sqrt(sumf2/Float(box_chan_cntr)-square(mean)-
+                    square(coeff)*(meanch2-square(meanch)));
+      linvariance=sumf2/Float(box_chan_cntr)-square(mean)-
+                    square(coeff)*(meanch2-square(meanch));
+      if (linvariance<0.) {
+          // this shouldn't happen normally, but could be due to round-off error
+          linvariance = 0;
+      } else {
+          linvariance = sqrt(linvariance);
+      }
+  }
   need2recalculate=False;
 …
 ///////////////////////////////////////////////////////////////////////////////
 //
 // LFAboveThreshold - a running mean algorithm for line detection
+// LFAboveThreshold - a running mean/median algorithm for line detection
 //
 //
 …
 LFAboveThreshold::LFAboveThreshold(std::list<pair<int,int> > &in_lines,
                                    int in_min_nchan,
+                                   casa::Float in_threshold) throw() :
+                                   casa::Float in_threshold,
+                                   bool use_median,
+                                   int noise_sample_size) throw() :
              min_nchan(in_min_nchan), threshold(in_threshold),
+             lines(in_lines), running_box(NULL) {}
+             lines(in_lines), running_box(NULL), itsUseMedian(use_median),
+             itsNoiseSampleSize(noise_sample_size) {}
 LFAboveThreshold::~LFAboveThreshold() throw()
 …
       running_box=new RunningBox(spectrum,mask,edge,max_box_nchan);
       // determine the off-line variance first
       // an assumption made: lines occupy a small part of the spectrum
+      std::vector<float> variances(edge.second-edge.first);
+      DebugAssert(variances.size(),AipsError);
+      for (;running_box->haveMore();running_box->next())
+           variances[running_box->getChannel()-edge.first]=
+                                running_box->getLinVariance();
+      // in the future we probably should do a proper Chi^2 estimation
+      // now a simple 80% of smaller values will be used.
+      // it may degrade the performance of the algorithm for weak lines
+      // due to a bias of the Chi^2 distribution.
+      stable_sort(variances.begin(),variances.end());
+      Float offline_variance=0;
+      uInt offline_cnt=uInt(0.8*variances.size());
+      if (!offline_cnt) offline_cnt=variances.size(); // no much else left,
+                                    // although it is very inaccurate
+      for (uInt n=0;n<offline_cnt;++n)
+           offline_variance+=variances[n];
+      offline_variance/=Float(offline_cnt);
+      const size_t noiseSampleSize = itsNoiseSampleSize<0 ? size_t(edge.second-edge.first) :
+                      std::min(size_t(itsNoiseSampleSize), size_t(edge.second-edge.first));
+      DebugAssert(noiseSampleSize,AipsError);
+      const bool globalNoise = (size_t(edge.second - edge.first) == noiseSampleSize);
+      LFNoiseEstimator ne(noiseSampleSize);
+      for (;running_box->haveMore();running_box->next()) {
+           ne.add(running_box->getLinVariance());
+           if (ne.filledToCapacity()) {
+               break;
+           }
+      }
+      Float offline_variance = -1; // just a flag that it is unset
+      if (globalNoise) {
+          offline_variance = itsUseMedian ? ne.median() : ne.meanLowest80Percent();
+      }
       // actual search algorithm
 …
                                  running_box->next()) {
            const int ch=running_box->getChannel();
+           if (running_box->getNumberOfBoxPoints()>=minboxnchan)
+           if (!globalNoise) {
+               // add a next point for a local noise estimate
+               ne.add(running_box->getLinVariance());
+           }
+           if (running_box->getNumberOfBoxPoints()>=minboxnchan) {
+               if (!globalNoise) {
+                   offline_variance = itsUseMedian ? ne.median() : ne.meanLowest80Percent();
+               }
+               AlwaysAssert(offline_variance>0.,AipsError);
                processChannel(mask[ch] && (fabs(running_box->aboveMean()) >=
                   threshold*offline_variance), mask);
            else processCurLine(mask); // just finish what was accumulated before
+           } else processCurLine(mask); // just finish what was accumulated before
            signs[ch]=getAboveMeanSign();
+           // os<<ch<<" "<<spectrum[ch]<<" "<<fabs(running_box->aboveMean())<<" "<<
+           // threshold*offline_variance<<endl;
+           const Float buf=running_box->aboveMean();
+           if (buf>0) signs[ch]=1;
+           else if (buf<0) signs[ch]=-1;
+           else if (buf==0) signs[ch]=0;
+           //os<<ch<<" "<<spectrum[ch]<<" "<<running_box->getLinMean()<<" "<<
+           //             threshold*offline_variance<<endl;
+            //os<<ch<<" "<<spectrum[ch]<<" "<<fabs(running_box->aboveMean())<<" "<<
+            //threshold*offline_variance<<endl;
+      }
       if (lines.size())
 …
 //              Setting a very large value doesn't usually provide
 //              valid detections.
 // in_box_size  the box size for running mean calculation. Default is
+// in_box_size  the box size for running mean/median calculation. Default is
 //              1./5. of the whole spectrum size
+// in_noise_box the box size for off-line noise estimation (if working with
+//              local noise. Negative value means use global noise estimate
+//              Default is -1 (i.e. estimate using the whole spectrum)
+// in_median    true if median statistics is used as opposed to average of
+//              the lowest 80% of deviations (default)
 void STLineFinder::setOptions(const casa::Float &in_threshold,
                               const casa::Int &in_min_nchan,
                               const casa::Int &in_avg_limit,
+                              const casa::Float &in_box_size) throw()
+                              const casa::Float &in_box_size,
+                              const casa::Float &in_noise_box,
+                              const casa::Bool &in_median) throw()
+{
   threshold=in_threshold;
 …
   avg_limit=in_avg_limit;
   box_size=in_box_size;
+  itsNoiseBox = in_noise_box;
+  itsUseMedian = in_median;
+}
 …
                 const casa::uInt &whichRow) throw(casa::AipsError)
+{
-  //const int minboxnchan=4;
   if (scan.null())
       throw AipsError("STLineFinder::findLines - a scan should be set first,"
 …
       throw AipsError("STLineFinder::findLines - in_scan and in_mask have different"
             "number of spectral channels.");
+  // taking flagged channels into account
+  vector<bool> flaggedChannels = scan->getMask(whichRow);
+  if (flaggedChannels.size()) {
+      // there is a mask set for this row
+      if (flaggedChannels.size() != mask.nelements()) {
+          throw AipsError("STLineFinder::findLines - internal inconsistency: number of mask elements do not match the number of channels");
+      }
+      for (size_t ch = 0; ch<mask.nelements(); ++ch) {
+           mask[ch] &= flaggedChannels[ch];
+      }
+  }
   // number of elements in in_edge
   if (in_edge.size()>2)
 …
       throw AipsError("STLineFinder::findLines - box_size is too small");
+  // number of elements in the sample for noise estimate
+  const int noise_box = itsNoiseBox<0 ? -1 : int(nchan * itsNoiseBox);
+  if ((noise_box!= -1) and (noise_box<2))
+      throw AipsError("STLineFinder::findLines - noise_box is supposed to be at least 2 elements");
   spectrum.resize();
   spectrum = Vector<Float>(scan->getSpectrum(whichRow));
 …
      try {
          // line find algorithm
          LFAboveThreshold lfalg(new_lines,avg_factor*min_nchan, threshold);
+         LFAboveThreshold lfalg(new_lines,avg_factor*min_nchan, threshold, itsUseMedian,noise_box);
          lfalg.findLines(spectrum,temp_mask,edge,max_box_nchan);
          signs.resize(lfalg.getSigns().nelements());

branches/alma/src/STLineFinder.h

-              r1353
+              r1757
    // in_box_size  the box size for running mean calculation. Default is
    //              1./5. of the whole spectrum size
+   // in_noise_box the box size for off-line noise estimation (if working with
+   //              local noise. Negative value means use global noise estimate
+   //              Default is -1 (i.e. estimate using the whole spectrum)
+   // in_median    true if median statistics is used as opposed to average of
+   //              the lowest 80% of deviations (default)
    void setOptions(const casa::Float &in_threshold=sqrt(3.),
                    const casa::Int &in_min_nchan=3,
                    const casa::Int &in_avg_limit=8,
+                   const casa::Float &in_box_size=0.2) throw();
+                   const casa::Float &in_box_size=0.2,
+                   const casa::Float &in_noise_box=-1.,
+                   const casa::Bool &in_median = casa::False) throw();
    // set the scan to work with (in_scan parameter)
 …
    // a buffer for the spectrum
    mutable casa::Vector<casa::Float>  spectrum;
+   // the box size for off-line noise estimation (if working with
+   // local noise. Negative value means use global noise estimate
+   // Default is -1 (i.e. estimate using the whole spectrum)
+   casa::Float itsNoiseBox;
+   // true if median statistics is used as opposed to average of
+   // the lowest 80% of deviations (default)
+   casa::Bool itsUseMedian;
 };

branches/alma/src/STMath.cpp

-              r1719
+              r1757
 #include "RowAccumulator.h"
 #include "STAttr.h"
+#include "STSelector.h"
 #include "STMath.h"
-#include "STSelector.h"
 using namespace casa;
 …
+}
 CountedPtr<Scantable> STMath::binaryOperate(const CountedPtr<Scantable>& left,
                                             const CountedPtr<Scantable>& right,
+CountedPtr<Scantable> STMath::binaryOperate(const CountedPtr<Scantable>& left,
+                                            const CountedPtr<Scantable>& right,
                                             const std::string& mode)
+{
 …
+{
   STSelector sel;
   CountedPtr< Scantable > ws = getScantable(s, false);
 …
   // for each row
   // assume that the data order are same between sig and ref
   RowAccumulator acc( asap::TINTSYS ) ;
+  RowAccumulator acc( asap::W_TINTSYS ) ;
   for ( int i = 0 ; i < sig->nrow() ; i++ ) {
     // get values
 …
   // initialize the lookup table if necessary
   if ( lookup.empty() ) {
     lookup["NONE"]   = asap::NONE;
     lookup["TINT"] = asap::TINT;
     lookup["TINTSYS"]  = asap::TINTSYS;
     lookup["TSYS"]  = asap::TSYS;
     lookup["VAR"]  = asap::VAR;
+    lookup["NONE"]   = asap::W_NONE;
+    lookup["TINT"] = asap::W_TINT;
+    lookup["TINTSYS"]  = asap::W_TINTSYS;
+    lookup["TSYS"]  = asap::W_TSYS;
+    lookup["VAR"]  = asap::W_VAR;
+  }
 …
     String msg;
     if ( nc > 0 ) {
       ppoly = new Polynomial<Float>(nc);
+      ppoly = new Polynomial<Float>(nc-1);
       coeff = coeffs;
       msg = String("user");
 …
       STAttr sdAttr;
       coeff = sdAttr.gainElevationPoly(inst);
       ppoly = new Polynomial<Float>(3);
+      ppoly = new Polynomial<Float>(coeff.nelements()-1);
       msg = String("built in");
+    }
 …
     if (d < 0) {
       Instrument inst =
         STAttr::convertInstrument(tab.keywordSet().asString("AntennaName"),
+        STAttr::convertInstrument(tab.keywordSet().asString("AntennaName"),
                                   True);
       STAttr sda;
 …
 CountedPtr< Scantable > STMath::opacity( const CountedPtr< Scantable > & in,
                                          float tau )
+                                         const std::vector<float>& tau )
+{
   CountedPtr< Scantable > out = getScantable(in, false);
+  Table tab = out->table();
+  ROScalarColumn<Float> elev(tab, "ELEVATION");
+  ArrayColumn<Float> specCol(tab, "SPECTRA");
+  ArrayColumn<uChar> flagCol(tab, "FLAGTRA");
+  ArrayColumn<Float> tsysCol(tab, "TSYS");
+  for ( uInt i=0; i<tab.nrow(); ++i) {
+    Float zdist = Float(C::pi_2) - elev(i);
+    Float factor = exp(tau/cos(zdist));
+    MaskedArray<Float> ma = maskedArray(specCol(i), flagCol(i));
+    ma *= factor;
+    specCol.put(i, ma.getArray());
+    flagCol.put(i, flagsFromMA(ma));
+    Vector<Float> tsys;
+    tsysCol.get(i, tsys);
+    tsys *= factor;
+    tsysCol.put(i, tsys);
+  Table outtab = out->table();
+  const uInt ntau = uInt(tau.size());
+  std::vector<float>::const_iterator tauit = tau.begin();
+  AlwaysAssert((ntau == 1 || ntau == in->nif() || ntau == in->nif() * in->npol()),
+               AipsError);
+  TableIterator iiter(outtab, "IFNO");
+  while ( !iiter.pastEnd() ) {
+    Table itab = iiter.table();
+    TableIterator piter(outtab, "POLNO");
+    while ( !piter.pastEnd() ) {
+      Table tab = piter.table();
+      ROScalarColumn<Float> elev(tab, "ELEVATION");
+      ArrayColumn<Float> specCol(tab, "SPECTRA");
+      ArrayColumn<uChar> flagCol(tab, "FLAGTRA");
+      ArrayColumn<Float> tsysCol(tab, "TSYS");
+      for ( uInt i=0; i<tab.nrow(); ++i) {
+        Float zdist = Float(C::pi_2) - elev(i);
+        Float factor = exp(*tauit/cos(zdist));
+        MaskedArray<Float> ma = maskedArray(specCol(i), flagCol(i));
+        ma *= factor;
+        specCol.put(i, ma.getArray());
+        flagCol.put(i, flagsFromMA(ma));
+        Vector<Float> tsys;
+        tsysCol.get(i, tsys);
+        tsys *= factor;
+        tsysCol.put(i, tsys);
+      }
+      if (ntau == in->nif()*in->npol() ) {
+        tauit++;
+      }
+      piter++;
+    }
+    if (ntau >= in->nif() ) {
+      tauit++;
+    }
+    iiter++;
+  }
   return out;
 …
 CountedPtr< Scantable > STMath::smoothOther( const CountedPtr< Scantable >& in,
                                              const std::string& kernel,
                                              float width )
+                                             float width, int order)
+{
   CountedPtr< Scantable > out = getScantable(in, false);
 …
       mathutil::runningMedian(specout, maskout, spec , mask, width);
       convertArray(flag, maskout);
+    } else if ( kernel == "poly" ) {
+      mathutil::polyfit(specout, maskout, spec, !mask, width, order);
+      convertArray(flag, !maskout);
+    }
     flagCol.put(i, flag);
 …
 CountedPtr< Scantable > STMath::smooth( const CountedPtr< Scantable >& in,
+                                        const std::string& kernel, float width )
+{
+  if (kernel == "rmedian"  || kernel == "hanning") {
+    return smoothOther(in, kernel, width);
+                                        const std::string& kernel, float width,
+                                        int order)
+{
+  if (kernel == "rmedian"  || kernel == "hanning" || kernel == "poly") {
+    return smoothOther(in, kernel, width, order);
+  }
   CountedPtr< Scantable > out = getScantable(in, false);
 …
           id = out->molecules().addEntry(rf, name, fname);
           molidcol.put(k, id);
           Float frot,fax,ftan,fhand,fmount,fuser, fxy, fxyp;
           (*it)->focus().getEntry(fax, ftan, frot, fhand,
+          Float fpa,frot,fax,ftan,fhand,fmount,fuser, fxy, fxyp;
+          (*it)->focus().getEntry(fpa, fax, ftan, frot, fhand,
                                   fmount,fuser, fxy, fxyp,
                                   rec.asuInt("FOCUS_ID"));
           id = out->focus().addEntry(fax, ftan, frot, fhand,
+          id = out->focus().addEntry(fpa, fax, ftan, frot, fhand,
                                      fmount,fuser, fxy, fxyp);
           focusidcol.put(k, id);
 …
   cols[3] = String("CYCLENO");
   TableIterator iter(tout, cols);
   CountedPtr<STPol> stpol = STPol::getPolClass(out->factories_,
+  CountedPtr<STPol> stpol = STPol::getPolClass(out->factories_,
                                                out->getPolType() );
   while (!iter.pastEnd()) {
 …
     ArrayColumn<Float> speccol(t, "SPECTRA");
     ScalarColumn<uInt> focidcol(t, "FOCUS_ID");
-    ScalarColumn<Float> parancol(t, "PARANGLE");
     Matrix<Float> pols(speccol.getColumn());
     try {
       stpol->setSpectra(pols);
       Float fang,fhand,parang;
       fang = in->focusTable_.getTotalFeedAngle(focidcol(0));
+      Float fang,fhand;
+      fang = in->focusTable_.getTotalAngle(focidcol(0));
       fhand = in->focusTable_.getFeedHand(focidcol(0));
+      parang = parancol(0);
+      /// @todo re-enable this
+      // disable total feed angle to support paralactifying Caswell style
+      stpol->setPhaseCorrections(parang, -parang, fhand);
+      stpol->setPhaseCorrections(fang, fhand);
       // use a member function pointer in STPol.  This only works on
       // the STPol pointer itself, not the Counted Pointer so
 …
       uInt row = tab.rowNumbers()[0];
       stpol->setSpectra(in->getPolMatrix(row));
       Float fang,fhand,parang;
       fang = in->focusTable_.getTotalFeedAngle(in->mfocusidCol_(row));
+      Float fang,fhand;
+      fang = in->focusTable_.getTotalAngle(in->mfocusidCol_(row));
       fhand = in->focusTable_.getFeedHand(in->mfocusidCol_(row));
+      parang = in->paraCol_(row);
+      /// @todo re-enable this
+      // disable total feed angle to support paralactifying Caswell style
+      stpol->setPhaseCorrections(parang, -parang, fhand);
+      stpol->setPhaseCorrections(fang, fhand);
       Int npolout = 0;
       for (uInt i=0; i<tab.nrow(); ++i) {
 …
 CountedPtr< Scantable >
   asap::STMath::lagFlag( const CountedPtr< Scantable > & in,
+                          double frequency, double width )
+                         double start, double end,
+                         const std::string& mode)
+{
   CountedPtr< Scantable > out = getScantable(in, false);
 …
       Vector<Float> spec = specCol(i);
       Vector<uChar> flag = flagCol(i);
       Int lag0 = Int(spec.nelements()*abs(inc)/(frequency+width)+0.5);
       Int lag1 = Int(spec.nelements()*abs(inc)/(frequency-width)+0.5);
+      int fstart = -1;
+      int fend = -1;
       for (unsigned int k=0; k < flag.nelements(); ++k ) {
         if (flag[k] > 0) {
+          spec[k] = 0.0;
+          fstart = k;
+          while (flag[k] > 0 && k < flag.nelements()) {
+            fend = k;
+            k++;
+          }
+        }
+        Float interp = 0.0;
+        if (fstart-1 > 0 ) {
+          interp = spec[fstart-1];
+          if (fend+1 < spec.nelements()) {
+            interp = (interp+spec[fend+1])/2.0;
+          }
+        } else {
+          interp = spec[fend+1];
+        }
+        if (fstart > -1 && fend > -1) {
+          for (int j=fstart;j<=fend;++j) {
+            spec[j] = interp;
+          }
+        }
+        fstart =-1;
+        fend = -1;
+      }
       Vector<Complex> lags;
       ffts.fft0(lags, spec);
+      Int start =  max(0, lag0);
+      Int end =  min(Int(lags.nelements()-1), lag1);
+      if (start == end) {
+        lags[start] = Complex(0.0);
+      Int lag0(start+0.5);
+      Int lag1(end+0.5);
+      if (mode == "frequency") {
+        lag0 = Int(spec.nelements()*abs(inc)/(start)+0.5);
+        lag1 = Int(spec.nelements()*abs(inc)/(end)+0.5);
+      }
+      Int lstart =  max(0, lag0);
+      Int lend =  min(Int(lags.nelements()-1), lag1);
+      if (lstart == lend) {
+        lags[lstart] = Complex(0.0);
       } else {
+        for (int j=start; j <=end ;++j) {
+        if (lstart > lend) {
+          Int tmp = lend;
+          lend = lstart;
+          lstart = tmp;
+        }
+        for (int j=lstart; j <=lend ;++j) {
           lags[j] = Complex(0.0);
+        }

branches/alma/src/STMath.h

-              r1680
+              r1757
   casa::CountedPtr<Scantable>
     binaryOperate( const casa::CountedPtr<Scantable>& left,
                    const casa::CountedPtr<Scantable>& right,
+    binaryOperate( const casa::CountedPtr<Scantable>& left,
+                   const casa::CountedPtr<Scantable>& right,
                    const std::string& mode);
 …
   casa::CountedPtr<Scantable>
     smooth(const casa::CountedPtr<Scantable>& in, const std::string& kernel,
                       float width);
+                      float width, int order=2);
   casa::CountedPtr<Scantable>
 …
   casa::CountedPtr<Scantable> opacity(const casa::CountedPtr<Scantable>& in,
                                       float tau);
+                                      const std::vector<float>& tau);
   casa::CountedPtr<Scantable>
 …
    */
   casa::CountedPtr<Scantable>
     lagFlag( const casa::CountedPtr<Scantable>& in, double frequency,
               double width);
+    lagFlag( const casa::CountedPtr<Scantable>& in, double start,
+             double end, const std::string& mode="frequency");
   // test for average spectra with different channel/resolution
 …
                               bool tokelvin, float cfac);
   casa::CountedPtr< Scantable >
+  casa::CountedPtr< Scantable >
     smoothOther( const casa::CountedPtr< Scantable >& in,
                  const std::string& kernel,
                  float width );
+                 float width, int order=2 );
   casa::CountedPtr< Scantable >

branches/alma/src/STMathWrapper.h

-              r1680
+              r1757
   ScantableWrapper
+    smooth(const ScantableWrapper& in, const std::string& kernel, float width)
+  { return ScantableWrapper(STMath::smooth(in.getCP(), kernel, width)); }
+    smooth(const ScantableWrapper& in, const std::string& kernel, float width,
+           int order=2)
+  { return ScantableWrapper(STMath::smooth(in.getCP(), kernel, width, order)); }
   ScantableWrapper
 …
   ScantableWrapper opacity(const ScantableWrapper& in,
                                       float tau)
+                          const std::vector<float>& tau)
   { return ScantableWrapper(STMath::opacity(in.getCP(), tau)); }
 …
   ScantableWrapper lagFlag( const ScantableWrapper& in,
+                            double frequency, double width )
+  { return ScantableWrapper(STMath::lagFlag(in.getCP(), frequency, width)); }
+                            double start, double end,
+                            const std::string& mode="frequency" )
+  { return ScantableWrapper(STMath::lagFlag(in.getCP(), start, end,
+                                            mode)); }
   // test for average spectra with different channel/resolution

branches/alma/src/STPol.h

-              r1015
+              r1757
   typedef  void (STPol::*polOperation)( casa::Float phase );
   STPol(): totalfeed_(0.0),parangle_(0.0),feedhand_(1.0) {}
+  STPol(): totalangle_(0.0),feedhand_(1.0) {}
   virtual ~STPol() {}
 …
+  void setPhaseCorrections(casa::Float parangle=0.0, casa::Float totalfeed=0.0,
+                           casa::Float feedhand=1.0)
+    { totalfeed_=totalfeed;parangle_=parangle;feedhand_=feedhand;}
+  void setPhaseCorrections(casa::Float totalang=0.0, casa::Float feedhand=1.0)
+    { totalangle_=totalang;feedhand_=feedhand;}
   casa::Float getTotalPhase() const { return totalfeed_+parangle_; }
+  casa::Float getTotalPhase() const { return totalangle_; }
   casa::Float getFeedHand() const { return feedhand_; }
 …
   static std::map<std::string, std::map<int, std::string> > labelmap_;
   casa::Float totalfeed_,parangle_,feedhand_;
+  casa::Float totalangle_,feedhand_;
   std::string mode_;
   casa::Matrix<casa::Float> basespectra_;

branches/alma/src/STWriter.cpp

-              r1683
+              r1757
 #include <atnf/PKSIO/PKSMS2writer.h>
 #include <atnf/PKSIO/PKSSDwriter.h>
+#include <atnf/PKSIO/SrcType.h>
 #include <tables/Tables/Table.h>
 …
 #include "STAsciiWriter.h"
 #include "STHeader.h"
+#include "STMath.h"
 #include "STWriter.h"
 …
                     const std::string &filename)
+{
+  // If we write out foreign formats we have to convert the frequency system
+  // into the output frame, as we do everything related to SPectarlCoordinates
+  // in asap on-the-fly.
+  CountedPtr<Scantable> inst = in;
+  if (in->frequencies().getFrame(true) != in->frequencies().getFrame(false)) {
+    STMath stm(false);
+    inst = stm.frequencyAlign(in);
+  }
   if (format_=="ASCII") {
     STAsciiWriter iw;
+    // ASCII calls SpectralCoordinate::toWorld so no freqAlign use 'in'
     if (iw.write(*in, filename)) {
       return 0;
 …
       iw.setClass(True);
+    }
     if (iw.write(*in, filename)) {
+    if (iw.write(*inst, filename)) {
       return 0;
+    }
 …
   // this is a little different from what I have done
   // before. Need to check with the Offline User Test data
   STHeader hdr = in->getHeader();
+  STHeader hdr = inst->getHeader();
   //const Int nPol  = hdr.npol;
   //const Int nChan = hdr.nchan;
   std::vector<uint> ifs = in->getIFNos();
   int nIF = in->nif();//ifs.size();
+  std::vector<uint> ifs = inst->getIFNos();
+  int nIF = inst->nif();//ifs.size();
   Vector<uInt> nPol(nIF),nChan(nIF);
   Vector<Bool> havexpol(nIF);
   String fluxUnit = hdr.fluxunit;
+  fluxUnit.upcase();
   nPol = 0;nChan = 0; havexpol = False;
   for (uint i=0;i<ifs.size();++i) {
     nPol(ifs[i]) = in->npol();
     nChan(ifs[i]) = in->nchan(ifs[i]);
+    nPol(ifs[i]) = inst->npol();
+    nChan(ifs[i]) = inst->nchan(ifs[i]);
     havexpol(ifs[i]) = nPol(ifs[i]) > 2;
+  }
+  const Table table = in->table();
+//   Vector<String> obstypes(2);
+//   obstypes(0) = "TR";//on
+//   obstypes(1) = "RF TR";//off
+  const Table table = inst->table();
   // Create the output file and write static data.
 …
     throw(AipsError("Failed to create output file"));
+  }
   Int count = 0;
 …
           String tcalt;
           Vector<String> stmp0, stmp1;
           in->frequencies().getEntry(crpix,crval, pksrec.freqInc,
+          inst->frequencies().getEntry(crpix,crval, pksrec.freqInc,
                                      rec.asuInt("FREQ_ID"));
           in->focus().getEntry(pksrec.focusAxi, pksrec.focusTan,
                                pksrec.focusRot, tmp0,tmp1,tmp2,tmp3,tmp4,
                                rec.asuInt("FOCUS_ID"));
           in->molecules().getEntry(pksrec.restFreq,stmp0,stmp1,
+          inst->focus().getEntry(pksrec.parAngle, pksrec.focusAxi, pksrec.focusTan,
+                                 pksrec.focusRot, tmp0,tmp1,tmp2,tmp3,tmp4,
+                                 rec.asuInt("FOCUS_ID"));
+          inst->molecules().getEntry(pksrec.restFreq,stmp0,stmp1,
                                    rec.asuInt("MOLECULE_ID"));
           in->tcal().getEntry(pksrec.tcalTime, pksrec.tcal,
+          inst->tcal().getEntry(pksrec.tcalTime, pksrec.tcal,
                               rec.asuInt("TCAL_ID"));
           in->weather().getEntry(pksrec.temperature, pksrec.pressure,
+          inst->weather().getEntry(pksrec.temperature, pksrec.pressure,
                                  pksrec.humidity, pksrec.windSpeed,
                                  pksrec.windAz, rec.asuInt("WEATHER_ID"));
 …
           pksrec.fieldName = rec.asString("FIELDNAME");
           pksrec.srcName   = rec.asString("SRCNAME");
+          pksrec.obsType   = hdr.obstype;
+          //pksrec.obsType   = obstypes[rec.asInt("SRCTYPE")];
+          pksrec.obsType = getObsTypes( rec.asInt("SRCTYPE") ) ;
           pksrec.bandwidth = nchan * abs(pksrec.freqInc);
           pksrec.azimuth   = rec.asFloat("AZIMUTH");
           pksrec.elevation = rec.asFloat("ELEVATION");
-          pksrec.parAngle  = rec.asFloat("PARANGLE");
           pksrec.refBeam   = rec.asInt("REFBEAMNO") + 1;
           pksrec.sigma.resize(npol);
 …
+{
   String poltype = tab.keywordSet().asString("POLTYPE");
+  if ( poltype == "stokes") {
+// Full stokes is not supported. Just allow stokes I
+  if ( poltype == "stokes" && tab.nrow() != 1) {
     String msg = "poltype = " + poltype + " not yet supported in output.";
     throw(AipsError(msg));
 …
+}
+}
+// get obsType string from SRCTYPE value
+String STWriter::getObsTypes( Int srctype )
+{
+  String obsType ;
+  switch( srctype ) {
+  case Int(SrcType::PSON):
+    obsType = "PSON" ;
+    break ;
+  case Int(SrcType::PSOFF):
+    obsType = "PSOFF" ;
+    break ;
+  case Int(SrcType::NOD):
+    obsType = "NOD" ;
+    break ;
+  case Int(SrcType::FSON):
+    obsType = "FSON" ;
+    break ;
+  case Int(SrcType::FSOFF):
+    obsType = "FSOFF" ;
+    break ;
+  case Int(SrcType::SKY):
+    obsType = "SKY" ;
+    break ;
+  case Int(SrcType::HOT):
+    obsType = "HOT" ;
+    break ;
+  case Int(SrcType::WARM):
+    obsType = "WARM" ;
+    break ;
+  case Int(SrcType::COLD):
+    obsType = "COLD" ;
+    break ;
+  case Int(SrcType::PONCAL):
+    obsType = "PSON:CALON" ;
+    break ;
+  case Int(SrcType::POFFCAL):
+    obsType = "PSOFF:CALON" ;
+    break ;
+  case Int(SrcType::NODCAL):
+    obsType = "NOD:CALON" ;
+    break ;
+  case Int(SrcType::FONCAL):
+    obsType = "FSON:CALON" ;
+    break ;
+  case Int(SrcType::FOFFCAL):
+    obsType = "FSOFF:CALOFF" ;
+    break ;
+  case Int(SrcType::FSLO):
+    obsType = "FSLO" ;
+    break ;
+  case Int(SrcType::FLOOFF):
+    obsType = "FS:LOWER:OFF" ;
+    break ;
+  case Int(SrcType::FLOSKY):
+    obsType = "FS:LOWER:SKY" ;
+    break ;
+  case Int(SrcType::FLOHOT):
+    obsType = "FS:LOWER:HOT" ;
+    break ;
+  case Int(SrcType::FLOWARM):
+    obsType = "FS:LOWER:WARM" ;
+    break ;
+  case Int(SrcType::FLOCOLD):
+    obsType = "FS:LOWER:COLD" ;
+    break ;
+  case Int(SrcType::FSHI):
+    obsType = "FSHI" ;
+    break ;
+  case Int(SrcType::FHIOFF):
+    obsType = "FS:HIGHER:OFF" ;
+    break ;
+  case Int(SrcType::FHISKY):
+    obsType = "FS:HIGHER:SKY" ;
+    break ;
+  case Int(SrcType::FHIHOT):
+    obsType = "FS:HIGHER:HOT" ;
+    break ;
+  case Int(SrcType::FHIWARM):
+    obsType = "FS:HIGHER:WARM" ;
+    break ;
+  case Int(SrcType::FHICOLD):
+    obsType = "FS:HIGHER:COLD" ;
+    break ;
+  default:
+    obsType = "NOTYPE" ;
+  }
+  return obsType ;
+}
+}

branches/alma/src/STWriter.h

-              r1388
+              r1757
 #include <casa/aips.h>
 #include <casa/Utilities/CountedPtr.h>
+#include <casa/BasicSL/String.h>
 #include "Logger.h"
 …
   void replacePtTab(const casa::Table& tab, const std::string& fname);
+  casa::String getObsTypes( casa::Int srctype ) ;
   std::string     format_;
   PKSwriter* writer_;

branches/alma/src/Scantable.cpp

-              r1707
+              r1757
   td.addColumn(ScalarColumnDesc<Float>("AZIMUTH"));
   td.addColumn(ScalarColumnDesc<Float>("ELEVATION"));
-  td.addColumn(ScalarColumnDesc<Float>("PARANGLE"));
   td.addColumn(ScalarColumnDesc<Float>("OPACITY"));
 …
   elCol_.attach(table_, "ELEVATION");
   dirCol_.attach(table_, "DIRECTION");
-  paraCol_.attach(table_, "PARANGLE");
   fldnCol_.attach(table_, "FIELDNAME");
   rbeamCol_.attach(table_, "REFBEAMNO");
+  mweatheridCol_.attach(table_,"WEATHER_ID");
   mfitidCol_.attach(table_,"FIT_ID");
   mfreqidCol_.attach(table_, "FREQ_ID");
 …
+}
 MPosition Scantable::getAntennaPosition () const
+MPosition Scantable::getAntennaPosition() const
+{
   Vector<Double> antpos;
 …
   /// @todo reindex SCANNO, recompute nbeam, nif, npol
   inname = path.expandedName();
+  table_.deepCopy(inname, Table::New);
+  // WORKAROUND !!! for Table bug
+  // Remove when fixed in casacore
+  if ( table_.tableType() == Table::Memory  && !selector_.empty() ) {
+    Table tab = table_.copyToMemoryTable(generateName());
+    tab.deepCopy(inname, Table::New);
+    tab.markForDelete();
+  } else {
+    table_.deepCopy(inname, Table::New);
+  }
+}
 …
+}
 std::vector<uint> Scantable::getNumbers(ScalarColumn<uInt>& col)
+std::vector<uint> Scantable::getNumbers(const ScalarColumn<uInt>& col) const
+{
   Vector<uInt> nos(col.getColumn());
 …
     specCol_.get(whichrow, arr);
   } else {
+    CountedPtr<STPol> stpol(STPol::getPolClass(Scantable::factories_, basetype));
+    CountedPtr<STPol> stpol(STPol::getPolClass(Scantable::factories_,
+                                               basetype));
     uInt row = uInt(whichrow);
     stpol->setSpectra(getPolMatrix(row));
     Float fang,fhand,parang;
     fang = focusTable_.getTotalFeedAngle(mfocusidCol_(row));
+    fang = focusTable_.getTotalAngle(mfocusidCol_(row));
     fhand = focusTable_.getFeedHand(mfocusidCol_(row));
+    parang = paraCol_(row);
+    /// @todo re-enable this
+    // disable total feed angle to support paralactifying Caswell style
+    stpol->setPhaseCorrections(parang, -parang, fhand);
+    stpol->setPhaseCorrections(fang, fhand);
     arr = stpol->getSpectrum(requestedpol, ptype);
+  }
 …
       << setw(15) << "Polarisations:" << setw(4) << npol()
       << "(" << getPolType() << ")" << endl
+      << setw(15) << "Channels:"  << setw(4) << nchan() << endl;
+  oss << endl;
+      << setw(15) << "Channels:" << nchan() << endl;
   String tmp;
   oss << setw(15) << "Observer:"
 …
       << setw(10) << "Time" << setw(18) << "Integration" << endl;
   oss << setw(5) << "" << setw(5) << "Beam" << setw(3) << "" << dirtype << endl;
   oss << setw(10) << "" << setw(3) << "IF" << setw(6) << ""
+  oss << setw(10) << "" << setw(3) << "IF" << setw(3) << ""
       << setw(8) << "Frame" << setw(16)
+      << "RefVal" << setw(10) << "RefPix" << setw(12) << "Increment" <<endl;
+      << "RefVal" << setw(10) << "RefPix" << setw(12) << "Increment"
+      << setw(7) << "Channels"
+      << endl;
   oss << asap::SEPERATOR << endl;
   TableIterator iter(table_, "SCANNO");
 …
         ROTableRow irow(isubt);
         const TableRecord& irec = irow.get(0);
         oss << setw(10) << "";
+        oss << setw(9) << "";
         oss << setw(3) << std::right << irec.asuInt("IFNO") << std::left
+            << setw(2) << "" << frequencies().print(irec.asuInt("FREQ_ID"))
+            << setw(1) << "" << frequencies().print(irec.asuInt("FREQ_ID"))
+            << setw(3) << "" << nchan(irec.asuInt("IFNO"))
             << endl;
 …
     Double tm;
     table_.keywordSet().get("UTC",tm);
     return MEpoch(MVEpoch(tm));
+    return MEpoch(MVEpoch(tm));
+  }
+}
 …
+{
   return formatDirection(getDirection(uInt(whichrow)));
+}
+SpectralCoordinate Scantable::getSpectralCoordinate(int whichrow) const {
+  const MPosition& mp = getAntennaPosition();
+  const MDirection& md = getDirection(whichrow);
+  const MEpoch& me = timeCol_(whichrow);
+  //Double rf = moleculeTable_.getRestFrequency(mmolidCol_(whichrow));
+  Vector<Double> rf = moleculeTable_.getRestFrequency(mmolidCol_(whichrow));
+  return freqTable_.getSpectralCoordinate(md, mp, me, rf,
+                                          mfreqidCol_(whichrow));
+}
 …
     return stlout;
+  }
+  const MPosition& mp = getAntennaPosition();
+  const MDirection& md = getDirection(whichrow);
+  const MEpoch& me = timeCol_(whichrow);
+  //Double rf = moleculeTable_.getRestFrequency(mmolidCol_(whichrow));
+  Vector<Double> rf = moleculeTable_.getRestFrequency(mmolidCol_(whichrow));
+  SpectralCoordinate spc =
+    freqTable_.getSpectralCoordinate(md, mp, me, rf, mfreqidCol_(whichrow));
+  SpectralCoordinate spc = getSpectralCoordinate(whichrow);
   Vector<Double> pixel(nchan);
   Vector<Double> world;
 …
            Sort::QuickSort|Sort::NoDuplicates );
   for (uInt i=0; i<fids.nelements(); ++i) {
     frequencies().shiftRefPix(npix, i);
+  }
+}
 std::string asap::Scantable::getAntennaName() const
+    frequencies().shiftRefPix(npix, fids[i]);
+  }
+}
+std::string Scantable::getAntennaName() const
+{
   String out;
 …
+}
 int asap::Scantable::checkScanInfo(const std::vector<int>& scanlist) const
+int Scantable::checkScanInfo(const std::vector<int>& scanlist) const
+{
   String tbpath;
 …
+}
 std::vector<double>  asap::Scantable::getDirectionVector(int whichrow) const
+std::vector<double> Scantable::getDirectionVector(int whichrow) const
+{
   Vector<Double> Dir = dirCol_(whichrow).getAngle("rad").getValue();
 …
+}
+std::vector<float> Scantable::getWeather(int whichrow) const
+{
+  std::vector<float> out(5);
+  //Float temperature, pressure, humidity, windspeed, windaz;
+  weatherTable_.getEntry(out[0], out[1], out[2], out[3], out[4],
+                         mweatheridCol_(uInt(whichrow)));
+  return out;
+}
+}
 //namespace asap

branches/alma/src/Scantable.h

-              r1707
+              r1757
 #include <casa/Utilities/CountedPtr.h>
-#include <casa/Exceptions/Error.h>
-#include <coordinates/Coordinates/SpectralCoordinate.h>
 #include <tables/Tables/Table.h>
 #include <tables/Tables/ArrayColumn.h>
 …
 #include <measures/TableMeasures/ScalarMeasColumn.h>
+#include <coordinates/Coordinates/SpectralCoordinate.h>
 #include <casa/Arrays/Vector.h>
 #include <casa/Quanta/Quantum.h>
+#include <casa/Exceptions/Error.h>
 #include "Logger.h"
 …
    */
   casa::MDirection getDirection( int whichrow ) const;
   /**
    * get the direction type as a string, e.g. "J2000"
 …
    * @return a string describing the direction reference
    */
   std::string getDirectionRefString() const;
+  std::string getDirectionRefString() const;
   /**
 …
   int getBeam(int whichrow) const;
   std::vector<uint> getBeamNos() { return getNumbers(beamCol_); }
+  std::vector<uint> getBeamNos() const { return getNumbers(beamCol_); }
   int getIF(int whichrow) const;
   std::vector<uint> getIFNos() { return getNumbers(ifCol_); }
+  std::vector<uint> getIFNos() const { return getNumbers(ifCol_); }
   int getPol(int whichrow) const;
   std::vector<uint> getPolNos() { return getNumbers(polCol_); }
   std::vector<uint> getScanNos() { return getNumbers(scanCol_); }
+  std::vector<uint> getPolNos() const { return getNumbers(polCol_); }
+  std::vector<uint> getScanNos() const { return getNumbers(scanCol_); }
   int getScan(int whichrow) const { return scanCol_(whichrow); }
 …
     { return azCol_(whichrow); }
   float getParAngle(int whichrow) const
     { return paraCol_(whichrow); }
+    { return focus().getParAngle(mfocusidCol_(whichrow)); }
   int getTcalId(int whichrow) const
     { return mtcalidCol_(whichrow); }
 …
   std::vector<double> getAbcissa(int whichrow) const;
+  std::vector<float> getWeather(int whichrow) const;
   std::string getAbcissaLabel(int whichrow) const;
 …
   void shift(int npix);
+  casa::SpectralCoordinate getSpectralCoordinate(int whichrow) const;
   void convertDirection(const std::string& newframe);
 …
    * against the information found in GBT_GO table for
    * scan number orders to get correct pairs.
    * @param[in] scan list
    * @return status
+   * @param[in] scan list
+   * @return status
    */
   int checkScanInfo(const std::vector<int>& scanlist) const;
   /**
    * Get the direction as a vector, for a specific row
+   * Get the direction as a vector, for a specific row
    * @param[in] whichrow the row numbyyer
    * @return the direction in a vector
+   * @return the direction in a vector
    */
   std::vector<double> getDirectionVector(int whichrow) const;
+  /**
+   * Set a flag indicating whether the data was parallactified
+   * @param[in] flag true or false
+   */
+  void parallactify(bool flag)
+    { focus().setParallactify(flag); }
   /**
 …
   int rowToScanIndex(int therow);
   std::vector<uint> getNumbers(casa::ScalarColumn<casa::uInt>& col);
   static const casa::uInt version_ = 2;
+  std::vector<uint> getNumbers(const casa::ScalarColumn<casa::uInt>& col) const;
+  static const casa::uInt version_ = 3;
   STSelector selector_;
 …
   casa::ScalarColumn<casa::Float> azCol_;
   casa::ScalarColumn<casa::Float> elCol_;
-  casa::ScalarColumn<casa::Float> paraCol_;
   casa::ScalarColumn<casa::String> srcnCol_, fldnCol_;
   casa::ScalarColumn<casa::uInt> scanCol_, beamCol_, ifCol_, polCol_, cycleCol_, flagrowCol_;

branches/alma/src/ScantableWrapper.h

-              r1707
+              r1757
 #include "STFit.h"
 #include "Scantable.h"
+#include "STCoordinate.h"
 namespace asap {
 …
     { return table_->checkScanInfo(scanlist); }
   std::vector<double>  getDirectionVector(int whichrow) const
+  std::vector<double> getDirectionVector(int whichrow) const
     { return table_->getDirectionVector(whichrow); }
+  void parallactify(bool flag)
+    { table_->parallactify(flag); }
+  STCoordinate getCoordinate(int row) {
+    return STCoordinate(table_->getSpectralCoordinate(row));
+  }
+  std::vector<float> getWeather(int whichrow) const
+    { return table_->getWeather(whichrow); }
   void reshapeSpectrum( int nmin, int nmax )

branches/alma/src/python_Scantable.cpp

-              r1707
+              r1757
     .def("_setsourcetype", &ScantableWrapper::setSourceType)
     .def("_getdirectionvec", &ScantableWrapper::getDirectionVector)
+    .def("_parallactify", &ScantableWrapper::parallactify)
+    .def("get_coordinate", &ScantableWrapper::getCoordinate)
+    .def("_get_weather", &ScantableWrapper::getWeather)
     .def("_reshape", &ScantableWrapper::reshapeSpectrum,
          (boost::python::arg("nmin")=-1,

branches/alma/src/python_asap.cpp

r1693	r1757
75	75	asap::python::python_LineCatalog();
76	76	asap::python::python_Logger();
	77	asap::python::python_STCoordinate();
	78	asap::python::python_STAtmosphere();
77	79	asap::python::python_SrcType();
78	80

branches/alma/src/python_asap.h

r1693	r1757
47	47	void python_LineCatalog();
48	48	void python_Logger();
	49	void python_STCoordinate();
	50	void python_STAtmosphere();
49	51	void python_SrcType();
50	52

branches/alma/test

Property svn:ignore set to
.asaprc

branches/alma/test/file-io.py

-              r1267
+              r1757
 data.save('output/test.asap',overwrite=True)
 data.save('output/test.ascii',format='ASCII',overwrite=True)
+data.save('output/testascii',format='ASCII',overwrite=True)
 data.save('output/test.sdfits',format='SDFITS',overwrite=True)
+data.save('output/testfits',format='FITS',overwrite=True)
+data.save('output/testclass',format='CLASS',overwrite=True)
 data2 = scantable('output/test.sdfits')

branches/alma/test/parkes-pol.py

-              r1038
+              r1757
 plotter.set_range(-30,0)
 selection.reset()
+plotter.plot(plotscans)
 selection.set_polarisations(['I','Q', 'U', 'V'])
 plotter.set_selection(selection)
+plotter.save('output/parkes_iquv.png',dpi=80)
 selection.set_polarisations(['I','Plinear'])
 plotter.set_selection(selection)
+plotter.save('output/parkes_iplin.png',dpi=80)
 selection.set_polarisations(['RR','LL'])
 plotter.set_selection(selection)
-plotter.plot(plotscans)
 plotter.save('output/parkes_rrll.png',dpi=80)

branches/alma/web/index.html

-              r1379
+              r1757
 <h2>Current Release</h2>
 <b class="asap">ASAP</b> latest stable version 2.2 was released on May, 2<sup>nd</sup> 2007. It can be obtained in the <a href="#download">Download</a> section.
+<div style="color: red;">
+  Note: Due to a bug in this release, Mopra users should follow <a href="https://svn.atnf.csiro.au/trac/asap/wiki/AsapFaq" >these</a> instructions.
+</div>
 <h2>Screenshots</h2>
 …
   <li><b class="asap">ASAP</b> source code is available through our subversion repository
     <pre>
         svn co http://sourcecode.atnf.csiro.au/repos/asap/tags/asap2.2.0
+        svn co http://svn.atnf.csiro.au/asap/tags/asap2.2.0
     </pre>
   </li>

Context Navigation

Legend:

Download in other formats: