Line data    Source code

       1             : //# SolvableVJTable.cc: Implementation of SolvableVJTable.h
       2             : //# Copyright (C) 1996,1997,1998,1999,2000,2001,2003
       3             : //# Associated Universities, Inc. Washington DC, USA.
       4             : //#
       5             : //# This library is free software; you can redistribute it and/or modify it
       6             : //# under the terms of the GNU Library General Public License as published by
       7             : //# the Free Software Foundation; either version 2 of the License, or (at your
       8             : //# option) any later version.
       9             : //#
      10             : //# This library is distributed in the hope that it will be useful, but WITHOUT
      11             : //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
      12             : //# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
      13             : //# License for more details.
      14             : //#
      15             : //# You should have received a copy of the GNU Library General Public License
      16             : //# along with this library; if not, write to the Free Software Foundation,
      17             : //# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
      18             : //#
      19             : //# Correspondence concerning AIPS++ should be addressed as follows:
      20             : //#        Internet email: aips2-request@nrao.edu.
      21             : //#        Postal address: AIPS++ Project Office
      22             : //#                        National Radio Astronomy Observatory
      23             : //#                        520 Edgemont Road
      24             : //#                        Charlottesville, VA 22903-2475 USA
      25             : //#
      26             : //# $Id$
      27             : //----------------------------------------------------------------------------
      28             : 
      29             : #include <synthesis/CalTables/SolvableVJTable.h>
      30             : 
      31             : using namespace casacore;
      32             : namespace casa { //# NAMESPACE CASA - BEGIN
      33             : 
      34             : //----------------------------------------------------------------------------
      35             : 
      36           1 : SolvableVisJonesTable::SolvableVisJonesTable() : TimeVarVisJonesTable(),
      37           1 :                                                  itsSolvableVisJonesDesc()
      38             : {
      39             : // Default null constructor for calibration table; do nothing for now
      40             : // Output to private data:
      41             : //    itsSolvableVisJonesDesc   SolvableVisJonesDesc  SolvableVisJones table 
      42             : //                                                    descriptor
      43             : //
      44           1 : };
      45             : 
      46             : //----------------------------------------------------------------------------
      47             : 
      48           1 : SolvableVisJonesTable::~SolvableVisJonesTable()
      49             : {
      50             : // Default destructor
      51             : //
      52           1 : };
      53             : 
      54             : //----------------------------------------------------------------------------
      55             : 
      56           0 : SolvableVisJonesTable::SolvableVisJonesTable (const String& tableName, 
      57           0 :                                               Table::TableOption access) :
      58           0 :   itsSolvableVisJonesDesc()
      59             : {
      60             : // Construct from a time-variable VisJones cal table name and access option. 
      61             : // Used for creating new tables or opening an existing table.
      62             : // Input:
      63             : //    tableName                const String&         Cal table name
      64             : //    access                   Table::TableOption    Access option
      65             : // Output to private data:
      66             : //    itsSolvableVisJonesDesc  SolvableVisJonesDesc  SolvableVisJones table 
      67             : //                                                   descriptor
      68             : //
      69             :   // Is this a new or existing calibration table ?
      70           0 :   if (access == Table::New || access == Table::NewNoReplace ||
      71             :       access == Table::Scratch) {
      72           0 :     createCalTable (tableName, itsSolvableVisJonesDesc, access);
      73             :   } else {
      74           0 :     openCalTable (tableName, access);
      75             :   };
      76           0 : };
      77             : 
      78             : //----------------------------------------------------------------------------
      79             : 
      80           0 : SolvableVisJonesTable::SolvableVisJonesTable (const String& tableName, 
      81             :                                               const String& type,
      82           0 :                                               Table::TableOption access) :
      83           0 :   itsSolvableVisJonesDesc(type)
      84             : {
      85             : // Construct from a time-variable VisJones cal table name and access option. 
      86             : // Used for creating new tables or opening an existing table.
      87             : // Input:
      88             : //    tableName                const String&         Cal table name
      89             : //    access                   Table::TableOption    Access option
      90             : // Output to private data:
      91             : //    itsSolvableVisJonesDesc  SolvableVisJonesDesc  SolvableVisJones table 
      92             : //                                                   descriptor
      93             : //
      94             :   // Is this a new or existing calibration table ?
      95           0 :   if (access == Table::New || access == Table::NewNoReplace ||
      96             :       access == Table::Scratch) {
      97           0 :     createCalTable (tableName, itsSolvableVisJonesDesc, access);
      98             :   } else {
      99           0 :     openCalTable (tableName, access);
     100             :   };
     101           0 : };
     102             : 
     103             : 
     104             : //----------------------------------------------------------------------------
     105             : 
     106           1 : GJonesTable::GJonesTable() : SolvableVisJonesTable(), itsGJonesDesc()
     107             : {
     108             : // Default null constructor for calibration table; do nothing for now
     109             : // Output to private data:
     110             : //    itsGJonesDesc      GJonesDesc         GJones table descriptor
     111             : //
     112           1 : };
     113             : 
     114             : //----------------------------------------------------------------------------
     115             : 
     116           1 : GJonesTable::~GJonesTable()
     117             : {
     118             : // Default destructor
     119             : //
     120           1 : };
     121             : 
     122             : //----------------------------------------------------------------------------
     123             : 
     124           0 : GJonesTable::GJonesTable (const String& tableName, 
     125           0 :                           Table::TableOption access) :
     126           0 :   itsGJonesDesc()
     127             : {
     128             : // Construct from a time-variable VisJones cal table name and access option. 
     129             : // Used for creating new tables or opening an existing table.
     130             : // Input:
     131             : //    tableName          const String&         Cal table name
     132             : //    access             Table::TableOption    Access option
     133             : // Output to private data:
     134             : //    itsGJonesDesc      GJonesDesc            GJones table descriptor
     135             : //
     136             :   // Is this a new or existing calibration table ?
     137           0 :   if (access == Table::New && access == Table::NewNoReplace &&
     138             :       access == Table::Scratch) {
     139           0 :     createCalTable (tableName, itsGJonesDesc, access);
     140             :   } else {
     141           0 :     openCalTable (tableName, access);
     142             :   };
     143           0 : };
     144             : 
     145             : //----------------------------------------------------------------------------
     146             : 
     147           0 : GJonesDelayRateSBTable::GJonesDelayRateSBTable() : SolvableVisJonesTable(),
     148           0 :                                                    itsGJonesDelayRateSBDesc()
     149             : {
     150             : // Default null constructor for calibration table; do nothing for now
     151             : // Output to private data:
     152             : //    itsGJonesDelayRateSBDesc   GJonesDelayRateSBDesc   GJonesDelayRateSB 
     153             : //                                                       table descriptor
     154             : //
     155           0 : };
     156             : 
     157             : //----------------------------------------------------------------------------
     158             : 
     159           0 : GJonesDelayRateSBTable::~GJonesDelayRateSBTable()
     160             : {
     161             : // Default destructor
     162             : //
     163           0 : };
     164             : 
     165             : //----------------------------------------------------------------------------
     166             : 
     167           0 : GJonesDelayRateSBTable::GJonesDelayRateSBTable (const String& tableName, 
     168           0 :                                                 Table::TableOption access) :
     169           0 :   itsGJonesDelayRateSBDesc()
     170             : {
     171             : // Construct from a time-variable VisJones cal table name and access option. 
     172             : // Used for creating new tables or opening an existing table.
     173             : // Input:
     174             : //    tableName                  const String&          Cal table name
     175             : //    access                     Table::TableOption     Access option
     176             : // Output to private data:
     177             : //    itsGJonesDelayRateSBDesc   GJonesDelayRateSBDesc  GJonesDelayRateSB 
     178             : //                                                      table descriptor
     179             : //
     180             :   // Is this a new or existing calibration table ?
     181           0 :   if (access == Table::New && access == Table::NewNoReplace &&
     182             :       access == Table::Scratch) {
     183           0 :     createCalTable (tableName, itsGJonesDelayRateSBDesc, access);
     184             :   } else {
     185           0 :     openCalTable (tableName, access);
     186             :   };
     187           0 : };
     188             : 
     189             : //----------------------------------------------------------------------------
     190             : 
     191           0 : DJonesTable::DJonesTable() : SolvableVisJonesTable(), itsDJonesDesc()
     192             : {
     193             : // Default null constructor for calibration table; do nothing for now
     194             : // Output to private data:
     195             : //    itsDJonesDesc      DJonesDesc         DJones table descriptor
     196             : //
     197           0 : };
     198             : 
     199             : //----------------------------------------------------------------------------
     200             : 
     201           0 : DJonesTable::~DJonesTable()
     202             : {
     203             : // Default destructor
     204             : //
     205           0 : };
     206             : 
     207             : //----------------------------------------------------------------------------
     208             : 
     209           0 : DJonesTable::DJonesTable (const String& tableName, 
     210           0 :                           Table::TableOption access) :
     211           0 :   itsDJonesDesc()
     212             : {
     213             : // Construct from a time-variable VisJones cal table name and access option. 
     214             : // Used for creating new tables or opening an existing table.
     215             : // Input:
     216             : //    tableName          const String&         Cal table name
     217             : //    access             Table::TableOption    Access option
     218             : // Output to private data:
     219             : //    itsDJonesDesc      DJonesDesc            DJones table descriptor
     220             : //
     221             :   // Is this a new or existing calibration table ?
     222           0 :   if (access == Table::New && access == Table::NewNoReplace &&
     223             :       access == Table::Scratch) {
     224           0 :     createCalTable (tableName, itsDJonesDesc, access);
     225             :   } else {
     226           0 :     openCalTable (tableName, access);
     227             :   };
     228           0 : };
     229             : 
     230             : //----------------------------------------------------------------------------
     231             : 
     232           0 : TJonesTable::TJonesTable() : SolvableVisJonesTable(), itsTJonesDesc()
     233             : {
     234             : // Default null constructor for calibration table; do nothing for now
     235             : // Output to private data:
     236             : //    itsTJonesDesc      TJonesDesc         TJones table descriptor
     237             : //
     238           0 : };
     239             : 
     240             : //----------------------------------------------------------------------------
     241             : 
     242           0 : TJonesTable::~TJonesTable()
     243             : {
     244             : // Default destructor
     245             : //
     246           0 : };
     247             : 
     248             : //----------------------------------------------------------------------------
     249             : 
     250           0 : TJonesTable::TJonesTable (const String& tableName, 
     251           0 :                           Table::TableOption access) :
     252           0 :   itsTJonesDesc()
     253             : {
     254             : // Construct from a time-variable VisJones cal table name and access option. 
     255             : // Used for creating new tables or opening an existing table.
     256             : // Input:
     257             : //    tableName          const String&         Cal table name
     258             : //    access             Table::TableOption    Access option
     259             : // Output to private data:
     260             : //    itsTJonesDesc      TJonesDesc            TJones table descriptor
     261             : //
     262             :   // Is this a new or existing calibration table ?
     263           0 :   if (access == Table::New && access == Table::NewNoReplace &&
     264             :       access == Table::Scratch) {
     265           0 :     createCalTable (tableName, itsTJonesDesc, access);
     266             :   } else {
     267           0 :     openCalTable (tableName, access);
     268             :   };
     269           0 : };
     270             : 
     271             : //----------------------------------------------------------------------------
     272             : 
     273             : 
     274             : } //# NAMESPACE CASA - END
     275             :