Line data    Source code

       1             : //# TimeVarVJMCol.h: TimeVarVisJones cal_main table column access
       2             : //# Copyright (C) 1996,1997,1998,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 adressed 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             : //#
      27             : //# $Id$
      28             : 
      29             : #ifndef CALIBRATION_TIMEVARVJMCOL_H
      30             : #define CALIBRATION_TIMEVARVJMCOL_H
      31             : 
      32             : #include <synthesis/CalTables/VisJonesMCol.h>
      33             : #include <synthesis/CalTables/TimeVarVJTable.h>
      34             : 
      35             : namespace casa { //# NAMESPACE CASA - BEGIN
      36             : 
      37             : // <summary> 
      38             : // ROTimeVarVisJonesMCol: Read-only TimeVarVisJones cal_main column access
      39             : // </summary>
      40             : 
      41             : // <use visibility=export>
      42             : 
      43             : // <reviewed reviewer="" date="" tests="" demos="">
      44             : 
      45             : // <prerequisite>
      46             : //   <li> <linkto class="ROCalMainColumns">ROCalMainColumns</linkto> module
      47             : //   <li> <linkto class="ROVisJonesMCol">ROVisJonesMCol</linkto> module
      48             : // </prerequisite>
      49             : //
      50             : // <etymology>
      51             : // From "read-only","time-variable visibility Jones","cal main" and "columns".
      52             : // </etymology>
      53             : //
      54             : // <synopsis>
      55             : // The ROTimeVarVisJonesMCol class allows read-only access to columns in the
      56             : // TimeVarVisJones main calibration table. Specializations for solvable 
      57             : // VisJones calibration table column access are provided through inheritance.
      58             : // </etymology>
      59             : //
      60             : // <example>
      61             : // <srcblock>
      62             : // </srcblock>
      63             : // </example>
      64             : //
      65             : // <motivation>
      66             : // Encapsulate read-only access to TVVJ calibration table columns.
      67             : // </motivation>
      68             : //
      69             : // <todo asof="01/07/01">
      70             : // (i) Deal with non-standard columns.
      71             : // </todo>
      72             : 
      73             : class ROTimeVarVisJonesMCol : public ROVisJonesMCol
      74             : {
      75             :  public:
      76             :   // Construct from a calibration table
      77             :   ROTimeVarVisJonesMCol (const TimeVarVisJonesTable& tvvjTable);
      78             : 
      79             :   // Default destructor
      80           0 :   virtual ~ROTimeVarVisJonesMCol() {};
      81             : 
      82             :  protected:
      83             :   // Prohibit public use of the null constructor, which
      84             :   // does not produce a usable object.
      85             :   ROTimeVarVisJonesMCol() {};
      86             : 
      87             :  private:
      88             :   // Prohibit copy constructor and assignment operator 
      89             :   ROTimeVarVisJonesMCol (const ROTimeVarVisJonesMCol&);
      90             :   ROTimeVarVisJonesMCol& operator= (const ROTimeVarVisJonesMCol&);
      91             : };
      92             : 
      93             : // <summary> 
      94             : // TimeVarVisJonesMCol: RW TimeVarVisJones cal_main column access
      95             : // </summary>
      96             : 
      97             : // <use visibility=export>
      98             : 
      99             : // <reviewed reviewer="" date="" tests="" demos="">
     100             : 
     101             : // <prerequisite>
     102             : //   <li> <linkto class="CalMainColumns">CalMainColumns</linkto> module
     103             : //   <li> <linkto class="VisJonesMCol">VisJonesMCol</linkto> module
     104             : // </prerequisite>
     105             : //
     106             : // <etymology>
     107             : // From "time-variable visibility Jones","cal main table" and "columns".
     108             : // </etymology>
     109             : //
     110             : // <synopsis>
     111             : // The TimeVarVisJonesMCol class allows read-write access to columns in the
     112             : // TimeVarVisJones main calibration table. Specializations for solvable 
     113             : // VisJones calibration table types are provided through inheritance.
     114             : // </etymology>
     115             : //
     116             : // <example>
     117             : // <srcblock>
     118             : // </srcblock>
     119             : // </example>
     120             : //
     121             : // <motivation>
     122             : // Encapsulate read-write access to TVVJ calibration table columns.
     123             : // </motivation>
     124             : //
     125             : // <todo asof="01/07/01">
     126             : // (i) Deal with non-standard columns.
     127             : // </todo>
     128             : 
     129             : class TimeVarVisJonesMCol : public VisJonesMCol
     130             : {
     131             :  public:
     132             :   // Construct from a calibration table
     133             :   TimeVarVisJonesMCol (TimeVarVisJonesTable& tvvjTable);
     134             : 
     135             :   // Default destructor
     136           3 :   virtual ~TimeVarVisJonesMCol() {};
     137             : 
     138             :  protected:
     139             :   // Prohibit public use of the null constructor, which
     140             :   // does not produce a usable object.
     141             :   TimeVarVisJonesMCol() {};
     142             : 
     143             :  private:
     144             :   // Prohibit copy constructor and assignment operator 
     145             :   TimeVarVisJonesMCol (const TimeVarVisJonesMCol&);
     146             :   TimeVarVisJonesMCol& operator= (const TimeVarVisJonesMCol&);
     147             : };
     148             : 
     149             : // <summary> 
     150             : // ROPJonesMCol: Read-only PJones cal_main column access
     151             : // </summary>
     152             : 
     153             : // <use visibility=export>
     154             : 
     155             : // <reviewed reviewer="" date="" tests="" demos="">
     156             : 
     157             : // <prerequisite>
     158             : //  <li> <linkto class="ROCalMainColumns">ROCalMainColumns</linkto> module
     159             : //  <li> <linkto class="ROVisJonesMCol">ROVisJonesMCol</linkto> module
     160             : // </prerequisite>
     161             : //
     162             : // <etymology>
     163             : // From "read-only","PJones","cal main" and "columns".
     164             : // </etymology>
     165             : //
     166             : // <synopsis>
     167             : // The ROPJonesMCol class allows read-only access to columns in the
     168             : // PJones main calibration table. PJones matrices are used to store
     169             : // parallactic angle information in the Measurement Equation formalism.
     170             : // </etymology>
     171             : //
     172             : // <example>
     173             : // <srcblock>
     174             : // </srcblock>
     175             : // </example>
     176             : //
     177             : // <motivation>
     178             : // Encapsulate read-only access to PJones calibration table columns.
     179             : // </motivation>
     180             : //
     181             : // <todo asof="01/07/01">
     182             : // (i) Deal with non-standard columns.
     183             : // </todo>
     184             : 
     185             : class ROPJonesMCol : public ROTimeVarVisJonesMCol
     186             : {
     187             :  public:
     188             :   // Construct from a calibration table
     189             :   ROPJonesMCol (const PJonesTable& pjTable);
     190             : 
     191             :   // Default destructor
     192           0 :   virtual ~ROPJonesMCol() {};
     193             : 
     194             :  protected:
     195             :   // Prohibit public use of the null constructor, which
     196             :   // does not produce a usable object.
     197             :   ROPJonesMCol() {};
     198             : 
     199             :  private:
     200             :   // Prohibit copy constructor and assignment operator 
     201             :   ROPJonesMCol (const ROPJonesMCol&);
     202             :   ROPJonesMCol& operator= (const ROPJonesMCol&);
     203             : };
     204             : 
     205             : // <summary> 
     206             : // PJonesMCol: RW PJones cal_main column access
     207             : // </summary>
     208             : 
     209             : // <use visibility=export>
     210             : 
     211             : // <reviewed reviewer="" date="" tests="" demos="">
     212             : 
     213             : // <prerequisite>
     214             : //   <li> <linkto class="CalMainColumns">CalMainColumns</linkto> module
     215             : //   <li> <linkto class="VisJonesMCol">VisJonesMCol</linkto> module
     216             : // </prerequisite>
     217             : //
     218             : // <etymology>
     219             : // From "PJones","cal main table" and "columns".
     220             : // </etymology>
     221             : //
     222             : // <synopsis>
     223             : // The PJonesMCol class allows read-write access to columns in the
     224             : // PJones main calibration table. PJones matrices are used to store
     225             : // parallactic angle information in the Measurement Equation formalism.
     226             : // </etymology>
     227             : //
     228             : // <example>
     229             : // <srcblock>
     230             : // </srcblock>
     231             : // </example>
     232             : //
     233             : // <motivation>
     234             : // Encapsulate read-write access to PJones calibration table columns.
     235             : // </motivation>
     236             : //
     237             : // <todo asof="01/07/01">
     238             : // (i) Deal with non-standard columns.
     239             : // </todo>
     240             : 
     241             : class PJonesMCol : public TimeVarVisJonesMCol
     242             : {
     243             :  public:
     244             :   // Construct from a calibration table
     245             :   PJonesMCol (PJonesTable& pjTable);
     246             : 
     247             :   // Default destructor
     248           0 :   virtual ~PJonesMCol() {};
     249             : 
     250             :  protected:
     251             :   // Prohibit public use of the null constructor, which
     252             :   // does not produce a usable object.
     253             :   PJonesMCol() {};
     254             : 
     255             :  private:
     256             :   // Prohibit copy constructor and assignment operator 
     257             :   PJonesMCol (const PJonesMCol&);
     258             :   PJonesMCol& operator= (const PJonesMCol&);
     259             : };
     260             : 
     261             : // <summary> 
     262             : // ROCJonesMCol: Read-only CJones cal_main column access
     263             : // </summary>
     264             : 
     265             : // <use visibility=export>
     266             : 
     267             : // <reviewed reviewer="" date="" tests="" demos="">
     268             : 
     269             : // <prerequisite>
     270             : //  <li> <linkto class="ROCalMainColumns">ROCalMainColumns</linkto> module
     271             : //  <li> <linkto class="ROVisJonesMCol">ROVisJonesMCol</linkto> module
     272             : // </prerequisite>
     273             : //
     274             : // <etymology>
     275             : // From "read-only","CJones","cal main" and "columns".
     276             : // </etymology>
     277             : //
     278             : // <synopsis>
     279             : // The ROCJonesMCol class allows read-only access to columns in the
     280             : // CJones main calibration table. CJones matrices are used to store
     281             : // polarization configuration information in the Measurement Equation 
     282             : // formalism.
     283             : // </etymology>
     284             : //
     285             : // <example>
     286             : // <srcblock>
     287             : // </srcblock>
     288             : // </example>
     289             : //
     290             : // <motivation>
     291             : // Encapsulate read-only access to CJones calibration table columns.
     292             : // </motivation>
     293             : //
     294             : // <todo asof="01/07/01">
     295             : // (i) Deal with non-standard columns.
     296             : // </todo>
     297             : 
     298             : class ROCJonesMCol : public ROTimeVarVisJonesMCol
     299             : {
     300             :  public:
     301             :   // Construct from a calibration table
     302             :   ROCJonesMCol (const CJonesTable& cjTable);
     303             : 
     304             :   // Default destructor
     305           0 :   virtual ~ROCJonesMCol() {};
     306             : 
     307             :  protected:
     308             :   // Prohibit public use of the null constructor, which
     309             :   // does not produce a usable object.
     310             :   ROCJonesMCol() {};
     311             : 
     312             :  private:
     313             :   // Prohibit copy constructor and assignment operator 
     314             :   ROCJonesMCol (const ROCJonesMCol&);
     315             :   ROCJonesMCol& operator= (const ROCJonesMCol&);
     316             : };
     317             : 
     318             : // <summary> 
     319             : // CJonesMCol: RW CJones cal_main column access
     320             : // </summary>
     321             : 
     322             : // <use visibility=export>
     323             : 
     324             : // <reviewed reviewer="" date="" tests="" demos="">
     325             : 
     326             : // <prerequisite>
     327             : //   <li> <linkto class="CalMainColumns">CalMainColumns</linkto> module
     328             : //   <li> <linkto class="VisJonesMCol">VisJonesMCol</linkto> module
     329             : // </prerequisite>
     330             : //
     331             : // <etymology>
     332             : // From "CJones","cal main table" and "columns".
     333             : // </etymology>
     334             : //
     335             : // <synopsis>
     336             : // The CJonesMCol class allows read-write access to columns in the
     337             : // CJones main calibration table. CJones matrices are used to store
     338             : // polarization configuration information in the Measurement 
     339             : // Equation formalism.
     340             : // </etymology>
     341             : //
     342             : // <example>
     343             : // <srcblock>
     344             : // </srcblock>
     345             : // </example>
     346             : //
     347             : // <motivation>
     348             : // Encapsulate read-write access to CJones calibration table columns.
     349             : // </motivation>
     350             : //
     351             : // <todo asof="01/07/01">
     352             : // (i) Deal with non-standard columns.
     353             : // </todo>
     354             : 
     355             : class CJonesMCol : public TimeVarVisJonesMCol
     356             : {
     357             :  public:
     358             :   // Construct from a calibration table
     359             :   CJonesMCol (CJonesTable& cjTable);
     360             : 
     361             :   // Default destructor
     362           0 :   virtual ~CJonesMCol() {};
     363             : 
     364             :  protected:
     365             :   // Prohibit public use of the null constructor, which
     366             :   // does not produce a usable object.
     367             :   CJonesMCol() {};
     368             : 
     369             :  private:
     370             :   // Prohibit copy constructor and assignment operator 
     371             :   CJonesMCol (const CJonesMCol&);
     372             :   CJonesMCol& operator= (const CJonesMCol&);
     373             : };
     374             : 
     375             : 
     376             : } //# NAMESPACE CASA - END
     377             : 
     378             : #endif
     379             :    
     380             :   
     381             : 
     382             : 
     383             :