MSSelection.h

Go to the documentation of this file.

//# MSSelection.h: Class to represent a selection on an MS
//# Copyright (C) 1996,1997,1998,1999,2001
//# 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: casa-feedback@nrao.edu.
//#        Postal address: AIPS++ Project Office
//#                        National Radio Astronomy Observatory
//#                        520 Edgemont Road
//#                        Charlottesville, VA 22903-2475 USA
 
#ifndef MS_MSSELECTION_H
#define MS_MSSELECTION_H
 
#include <casacore/casa/aips.h>
#include <casacore/casa/BasicSL/String.h>
#include <casacore/casa/Arrays/Vector.h>
#include <casacore/measures/Measures/MEpoch.h>
#include <casacore/measures/Measures/MRadialVelocity.h>
#include <casacore/tables/TaQL/ExprNode.h>
#include <casacore/ms/MeasurementSets/MeasurementSet.h>
#include <casacore/casa/Arrays/Matrix.h>
#include <casacore/casa/Arrays/Cube.h>
#include <casacore/ms/MSSel/MSSelectionError.h>
#include <casacore/ms/MSSel/MSSelectionErrorHandler.h>
#include <casacore/ms/MSSel/MSSelectableTable.h>
#include <map>
 
namespace casacore { //# NAMESPACE CASACORE - BEGIN
 
// <summary> 
// MSSelection: Class to represent a selection on an MS
// </summary>
 
// <use visibility=export>
 
// <reviewed reviewer="" date="" tests="" demos="">
 
// <prerequisite>
//   <li> <linkto class="MeasurementSet">MeasurementSet</linkto> module
// </prerequisite>
//
// <etymology>
// From "MeasurementSet" and "selection".
// </etymology>
//
// <synopsis>
// The MSSelection class represents a selection on a MeasurementSet (MS).
// This class is used in translating MS selections represented as
// selection items in the user interface, and for converting between
// MS selection and pure TaQL selection.
//
// The purpose of this class is to provides a simple expression based
// selection mechanism to both the end-user and developer wishing to
// perform query operations over a measurement set.  This is
// accomplished by abstracting the TaQL interface through an
// adapter/translation interface which converts STaQL (Simple Table
// Query Language) expressions into the equivalent table expression
// form, reducing the knowledge necessary to perform powerful query
// operations directly in TaQL.  It is also possible to supply pure
// TaQL expression(s) as sub-expressions if required. For a complete
// list of the STaQL interface refer to the MeasurementSet Selection Syntax document at: <a
// href="http://casa.nrao.edu/other_doc.shtml">Data
// Selection</a>
//
// The sub-expressions are interpreted in the order which they were
// set.  The order however in not important - any dependency on the
// order in which the expressions are evaluated is handled internally.
// The result of parsing the expressions is TableExprNode (TEN).  All
// TENs from sub-expressions are finally ANDed and the resultant TEN
// is used to select the rows of the MS table.
//
// </synopsis>
//
// <example>
// <srcblock>
// // Create a MS and a MS selection
// MeasurementSet ms(msName);
// MSSelection select;
// // Setup any sub-expressions of interest directly
// // (or optionally send this information through a Record)
// select.setFieldExpr("0,1");
// select.setSpwExpr(">0");
// // Create a table expression over a MS representing the selection
// TableExprNode node = select.toTableExprNode(&ms);
// // Optionally create a table and new MS based on this node
// Table tablesel(ms.tableName(), Table::Update);
// MeasurementSet mssel(tablesel(node, node.nrow()));
// </srcblock>
// </example>
//
// <motivation>
// This class is used by the MS access classes.
// </motivation>
//
// <todo asof="Aug/14/2009">
// Generalize SpwExpressions and PolnExpressions to optionally include
// DataDescription ID specifications.
// </todo>
 
  class MSSelection
  {
  public:
    enum MSExprType {NO_EXPR = 0,
             ANTENNA_EXPR,
             CORR_EXPR,
             FIELD_EXPR,
             SPW_EXPR,
             SCAN_EXPR,
             ARRAY_EXPR,
             TIME_EXPR,
             UVDIST_EXPR,
             POLN_EXPR,
             STATE_EXPR,
             OBSERVATION_EXPR,
             FEED_EXPR,
             TAQL_EXPR,
             MAX_EXPR = TAQL_EXPR};
    enum MSSMode {PARSE_NOW=0, PARSE_LATE};
 
    // Default null constructor, and destructor
    MSSelection();
    virtual ~MSSelection();
    
    // Construct using an MS and the various selection expressions to
    // be applied to the given MS.  By default, the expressions will
    // be parsed immediately.  With mode=PARSE_LATE, the parsing will
    // be done with a call to toTableExprNode().
    MSSelection(const MeasurementSet& ms,
        const MSSMode& mode=PARSE_NOW,
        const String& timeExpr="",
        const String& antennaExpr="",
        const String& fieldExpr="",
        const String& spwExpr="",
        const String& uvDistExpr="",
        const String& taqlExpr="",
        const String& polnExpr="",
        const String& scanExpr="",
        const String& arrayExpr="",
        const String& stateExpr="",
        const String& observationExpr="",
        const String& feedExpr="");
    
    // Construct from a record representing a selection item at the
    // CLI or user interface level.  This is functionally same as the
    // constructor above with mode=PARSE_LATE.
    MSSelection(const Record& selectionItem);
    
    // Copy constructor
    MSSelection(const MSSelection& other);
    
    // Assignment operator
    MSSelection& operator=(const MSSelection& other);
    
    // Helper method for converting index vectors to expression strings
    static String indexExprStr(Vector<Int> index);
    
    // Helper method for converting name vectors to expression strings
    static String nameExprStr(Vector<String> name);
    
    // Expression setters.  The following set*Expr() methods only set
    // the expressions.  Parsing is done with a call to
    // toTableExprNode().
    Bool setAntennaExpr(const String& antennaExpr);
    Bool setFieldExpr(const String& fieldExpr);
    Bool setSpwExpr(const String& spwExpr);
    Bool setScanExpr(const String& scanExpr);
    Bool setArrayExpr(const String& ArrayExpr);
    Bool setTimeExpr(const String& timeExpr);
    Bool setUvDistExpr(const String& uvDistExpr);
    Bool setTaQLExpr(const String& taqlExpr);
    Bool setPolnExpr(const String& polnExpr);
    Bool setStateExpr(const String& stateExpr);
    Bool setObservationExpr(const String& observationExpr);
    Bool setFeedExpr(const String& feedExpr);
 
    // Accessor for the various selection expressions as strings.
    const String getExpr(const MSExprType type=NO_EXPR);
    
    // Accessor for result of parsing all of the selection
    // expressions.  The final TableExprNode (TEN) is the result of
    // ANDing the TENs for the individual expressions.
    TableExprNode getTEN(const MeasurementSet*ms = NULL);
 
    // Accessor for the list of the selected scan IDs.
    inline Vector<Int> getScanList(const MeasurementSet* ms=NULL) 
    {getTEN(ms); return scanIDs_p;}
 
    // Accessor for the list of the selected observation IDs.
    inline Vector<Int> getObservationList(const MeasurementSet* ms=NULL) 
    {getTEN(ms); return observationIDs_p;}
 
    // Accessor for the list of the selected feed1 IDs.
    inline Vector<Int> getFeed1List(const MeasurementSet* ms=NULL) 
    {getTEN(ms); return feed1IDs_p;}
 
    // Accessor for the list of the selected feed2 IDs.
    inline Vector<Int> getFeed2List(const MeasurementSet* ms=NULL) 
    {getTEN(ms); return feed2IDs_p;}
 
    // Similar to baselines for antennas
    inline Matrix<Int> getFeedPairList(const MeasurementSet* ms=NULL) 
    {getTEN(ms); return feedPairIDs_p;}
    
    // Accessor for the list of selected sub-array IDs.
    inline Vector<Int> getSubArrayList(const MeasurementSet* ms=NULL) 
    {getTEN(ms); return arrayIDs_p;}
    
    // Accessor for the list of antenna-1 of the selected baselines.
    // Antennas affected by the baseline negation operator have the
    // antenna IDs multiplied by -1.
    inline Vector<Int> getAntenna1List(const MeasurementSet* ms=NULL) 
    {// if (antenna1IDs_p.nelements() <= 0) 
    getTEN(ms); return antenna1IDs_p;}
    
    // Accessor for the list of antenna-2 of the selected baselines.
    // Antennas affected by the baseline negation operator have the
    // antenna IDs multiplied by -1.
    inline Vector<Int> getAntenna2List(const MeasurementSet* ms=NULL) 
    {// if (antenna2IDs_p.nelements() <= 0) 
    getTEN(ms); return antenna2IDs_p;}
    
    // Accessor for the list of selected baselines.  The list is a Nx2
    // Matrix with one row per baseline containing the antenna IDs of
    // the two antenna associated with the baseline.
    //
    // Baselines affected by the negation operator in the baseline
    // selection expression are reported with one or both the antenna
    // IDs multiplied by -1.  E.g. a baseline selection expression
    // "!1" will result in a baseline list
    //
    // [-1, 2],
    // [-1, 3],
    // [-1, 4],
    // ....
    //
    // The expression "!1&10" will result in a baseline list [-1,
    // -10].  Etc...
    //
    inline Matrix<Int> getBaselineList(const MeasurementSet* ms=NULL) 
    {getTEN(ms); return baselineIDs_p;}
    
    // Accessor for the list of selected field IDs.
    inline Vector<Int> getFieldList(const MeasurementSet* ms=NULL) 
    {// if (fieldIDs_p.nelements() <= 0) 
    getTEN(ms); return fieldIDs_p;}
 
    // Accessor for the list of selected state Obs_Modes.
    inline Vector<Int> getStateObsModeList(const MeasurementSet* ms=NULL) 
    {if (stateObsModeIDs_p.nelements() <= 0) getTEN(ms); return stateObsModeIDs_p;}
    
    // Accessor for the list of the specified time range(s) as the
    // start and end MJD values.  The time ranges are stored as columns,
    // i.e. the output Matrix is 2 x n_ranges.
    inline Matrix<Double> getTimeList(const MeasurementSet* ms=NULL)
    {getTEN(ms); return selectedTimesList_p;}
    
    // Accessor for the list of the specified uv-range(s) as the start
    // and end values in units used in the MS.
    inline Matrix<Double> getUVList(const MeasurementSet* ms=NULL) 
    {getTEN(ms); return selectedUVRange_p;}
    
    // Accessor for the list of user defined units for the
    // uv-range(s).  The uv-range(s) return by getUVList is always in
    // the units used in the MS.
    inline Vector<Bool> getUVUnitsList(const MeasurementSet* ms=NULL) 
    {getTEN(ms); return selectedUVUnits_p;}
 
    // Accessor for the list of the selected Spectral Window IDs.
    inline Vector<Int> getSpwList(const MeasurementSet* ms=NULL) 
    {// if (spwIDs_p.nelements() <= 0) 
    getTEN(ms); return spwIDs_p;}
    
    // Accessor for the table (as a nx4 Matrix) of the selected
    // Spectral Windows and associated ranges of selected channels.
    // Each row of the Matrix has the following elements:
    //
    //    SpwID StartCh StopCh Step
    //
    // where StartCh, StopCh and Step are the first and the last
    // selected channels and step is the step size.  If no step size
    // was supplied as part of the expression, the value of Step is
    // replaced with the value of the defaultStep parameter. Multiple
    // channel specifications for the same Spectral Window selection,
    // results in multiple rows in the Matrix. If sorted is True, the
    // rows of the output Matrix will be sorted by the SPW IDs (the
    // entries in the first column).
    Matrix<Int> getChanList(const MeasurementSet* ms=NULL, 
                const Int defaultStep=1,
                const Bool sorted=False);
 
    //
    // Same as getChanList, except that the channels and steps are in Hz.
    //    
    Matrix<Double> getChanFreqList(const MeasurementSet* ms=NULL, 
                   const Bool sorted=False);
 
    // Accessor for the list of the selected Data Description IDs
    // (DDID) from the polarization expression parsing.  The actual
    // selected DDIDs would be an intersection of the DDIDs selected
    // from polarization and SPW expressions parsing (see
    // getSPWDDIDList() below).
    // Note that there is no guarantee that returned vector
    // is inmight not be in sorted order.
    inline Vector<Int> getDDIDList(const MeasurementSet* ms=NULL) 
    {if (ddIDs_p.nelements() <= 0) getTEN(ms); return ddIDs_p;}
 
    // Accessor for the list of the selected Data Description IDs from
    // the SPW expression parsing.  The actual
    // selected DDIDs would be an intersection of the DDIDs selected
    // from polarization and SPW expressions parsing (see
    // getDDIDList() above).
    //
    // The actual DDIDs selected will be an intersection of the lists
    // from getDDIDList() and getSPWDDIDList() (which can be generated
    // using the set_intersection(Vector<Int>&, Vector<Int>&) global
    // method in MSSelectionTool.{cc,h}).
    inline Vector<Int> getSPWDDIDList(const MeasurementSet* ms=NULL) 
    {if (spwDDIDs_p.nelements() <= 0) getTEN(ms); return spwDDIDs_p;}
 
    //
    // The key in the ordered map returned by getPolMap() is the Data
    // Description ID (DDID). The value is a vector containing the
    // list of in-row indices to pick out the selected polarizations
    // (or equivalently, the list of indices for the vector in the
    // corrType column of the POLARIZATION sub-table). These are also
    // what the user intended (i.e., e.g. not all DD IDs due to user
    // POL expression might be selected due to SPW expressions).
    //
    inline std::map<Int, Vector<Int> > getPolMap(const MeasurementSet* ms=NULL) 
    {getTEN(ms); return selectedPolMap_p;};
 
    //
    // The key in the ordered map returned by getCorrMap() is the
    // pol. in the Data Description ID (DDID) sub-table.  The value is
    // a Vector of two Vectors.
    //
    // The returned Map<T> has a key that maps to two vectors:
    // Key  ---->    Vector1               Vector2
    //
    // Key : Row index in the POLARIZATION sub-table
    //
    // Vector1 : List of poln. indices selected from the row pointed
    //           by Key.  These are the in-row indices to pick-out the
    //           desired (selected) polarization products from the
    //           selected rows of the MS (or equivalently, the list of
    //           indices for the vector in the corrType column of the
    //           POLARIZATION sub-table).
    //
    // Vector2 : List of selected rows from the DATA_DESCRIPTION sub-table 
    //
    // An example: following are the sub-tables used for the example
    // explaination below:
    //
    // POLARIZATION Sub-table
    // ======================
    // Row    Poln
    // ------------
    // 0         RR, LL
    // 1         RR, LR, RL, LL
    //
    // DATA_DESCRIPTION Sub-table
    // ==========================
    // Row      PolnID         SpwID
    // ------------------------------
    // 0          0              0
    // 1          1              1
    // 2          1              2
    // 3          1              3
    // 4          1              4
    // 5          1              5
    // 6          1              6
    // 7          1              7
    // 8          1              8
    //
    //
    // E.g., the expression poln='LL'
    //
    // returns the Map:
    //
    // corrmap = (0, [[1], [0]]) (1, [[3], [0,1,2,3,4,5,6,7,8]] )
    //
    // The rows from the POLARIZATION table selected are 0 and 1,  These are
    // two keys for the two entries in the map.
    //
    //  1. The two vectors in map 1 are:  [1] and [0].  The this reads as:
    //      From the 0th. row of the POLARIZATION table, use the indices [1].  The
    //      relevant list of associated DD rows are [0]
    //
    //  2. The two vectors in map 2 are:  [3] and  [0,1,2,3,4,5,6,7,8].  This reads as:
    //       From the 1st. row of the POLARIZATION table, use the indices [3].  The
    //       relevant list of associated DD rows are [0,1,2,3,4,5,6,7,8].
    //
    // For a client code:
    //
    // o To get a list of the DDIDs selected, iterate over all entries of the
    //   map and collate the second vector from each entry.
    //
    //        Or, use getDDIDList().
    //
    // o To get the list of the selected poln. *in-row indices*, collate the
    //   first vector from each entry.
    //
    // o To get a list of POLARIZATION IDs selected (rows of the POLARIZATION
    //   table), make a list of all the keys of this map.
    inline std::map<Int, Vector<Vector<Int> > > getCorrMap(const MeasurementSet* ms=NULL) 
    {getTEN(ms); return selectedSetupMap_p;};
 
    // Methods to convert the maps return by getChanList and
    // getCorrMap to a list of Slice which can be directly used by
    // Table system for in-row selection of frequency channels and
    // polarizations.
    void getChanSlices(Vector<Vector<Slice> >& chanslices, 
               const MeasurementSet* ms=NULL, 
               const Int defaultChanStep=1);
 
    void getCorrSlices(Vector<Vector<Slice> >& corrslices,
               const MeasurementSet* ms=NULL);
    
    
    // Clear sub-expression and reset priority.  Default behavior is to
    // reset all sub-expressions.
    void clear(const MSExprType type=NO_EXPR);
    
    // Set all error handlers to a known state (NULL).
    void clearErrorHandlers();
 
    Bool exprIsNull(const MSExprType type=NO_EXPR);
    
    // Convey to the various parsers to delete the TENs they hold
    void deleteNodes();
 
    // Delete error handlers (mostly the internally allocated ones).
    void deleteErrorHandlers();
 
    // Convert to TableExprNode format (C++ interface to TaQL).  This
    // is now for purely backwards compatibility and ease of use.  It
    // internally constructs the MSSelectableTable from the supplied
    // MS and calls the generic version of toTableExprNode below
    // (which works with MSSelectableTable object).
    TableExprNode toTableExprNode(const MeasurementSet* ms);
 
    // Convert to TableExprNode format (C++ interface to TaQL).  The
    // MSSelectableTable is a pure-virtual base class which provides a
    // generic interface both to MeasurementSet and CalTable (in the
    // synthesis module) services used in MSSelection.  The actual
    // objects used for supplying MeasurementSet or CalTable to
    // MSSelection are MSInterface and CTInterface classes
    // respectively.  With this, MSSelection module can be used for
    // selection on MeasurementSet or CalTable.
    TableExprNode toTableExprNode(MSSelectableTable* msLike);
    
    // Return the selected MS.  The selected MS reflects only row
    // selections (as against in-row selections).  If outMSName != "",
    // the selected MS is also written to the disk (a shallow copy).
    //
    // For in-row selection, use the appropriate global function
    // mssSetData() MSSelectionTools.h which also returns the in-row
    // (corr/chan) slices that can be supplied to the VisIter object
    // for on-the-fly in-row selection.
    Bool getSelectedMS(MeasurementSet& selectedMS,
               const String& outMSName="");
    
    void resetMS(const MeasurementSet& ms) {resetTEN(); ms_p=&ms;};
    void resetTEN() {fullTEN_p=TableExprNode();};
    
    
    // The MSSelection object is designed to be re-usable object.  The
    // following reset() methods set the internal state of the object
    // to same state as with the equivalent constructor.
    //
    // mode can be one of the MSSModes.  MSSMode::PARSE_NOW will parse
    // the given expressions and internally hold the final TEN
    // (i.e. will also internally call toTableExprNode()).  The
    // internal TEN can be accessed via the getTEN() method.
    // MSSMode::PARSE_LATER will only set the expression strings.
    // Parsing will be done later with a call to toTableExprNode().
    //
    // This version, here for backward compatibility reasons,
    // internally constructs a
    // <linkto class="MSSelectableTable">MSSelectableTable</linkto>
    // object and calls the reset() method below that works with
    // MSSelectableTable.
    void reset(const MeasurementSet& ms,
           const MSSMode& mode           = PARSE_NOW,
           const String& timeExpr        = "",
           const String& antennaExpr     = "",
           const String& fieldExpr       = "",
           const String& spwExpr         = "",
           const String& uvDistExpr      = "",
           const String& taqlExpr        = "",
           const String& polnExpr        = "",
           const String& scanExpr        = "",
           const String& arrayExpr       = "",
           const String& stateExpr       = "",
           const String& observationExpr = "");
 
    // Add feedExpr; keep old signature for backwards compatibility
    void reset2(const MeasurementSet& ms,
           const MSSMode& mode           = PARSE_NOW,
           const String& timeExpr        = "",
           const String& antennaExpr     = "",
           const String& fieldExpr       = "",
           const String& spwExpr         = "",
           const String& uvDistExpr      = "",
           const String& taqlExpr        = "",
           const String& polnExpr        = "",
           const String& scanExpr        = "",
           const String& arrayExpr       = "",
           const String& stateExpr       = "",
           const String& observationExpr = "",
           const String& feedExpr        = "");
 
    // This version of reset() works with generic MSSelectableTable
    // object.  Accessing the services of the MSSelection module via
    // this interface is recommended over the version of reset() that
    // uses MeasurementSet.
    void reset(MSSelectableTable& msLike,
           const MSSMode& mode           = PARSE_NOW,
           const String& timeExpr        = "",
           const String& antennaExpr     = "",
           const String& fieldExpr       = "",
           const String& spwExpr         = "",
           const String& uvDistExpr      = "",
           const String& taqlExpr        = "",
           const String& polnExpr        = "",
           const String& scanExpr        = "",
           const String& arrayExpr       = "",
           const String& stateExpr       = "",
           const String& observationExpr = "");
 
    // Add feedExpr; keep old signature for backwards compatibility
    void reset2(MSSelectableTable& msLike,
           const MSSMode& mode           = PARSE_NOW,
           const String& timeExpr        = "",
           const String& antennaExpr     = "",
           const String& fieldExpr       = "",
           const String& spwExpr         = "",
           const String& uvDistExpr      = "",
           const String& taqlExpr        = "",
           const String& polnExpr        = "",
           const String& scanExpr        = "",
           const String& arrayExpr       = "",
           const String& stateExpr       = "",
           const String& observationExpr = "",
           const String& feedExpr        = "");
 
    // Set the maximum value acceptable for SCAN, OBSERVATION or
    // SUB-ARRAY IDs. The main-table columns for these do not refere
    // to rows of sub-tables and therefore there is no cheap way to
    // find a valid range for these which can be used in the parsers
    // to generate error or warning messages if a value outside the
    // range is used in the expressions.  The default maximum value
    // for scan, observation and sub-array IDs is 1000.
    inline void setMaxScans(const Int& n=1000) {maxScans_p=n;};
    inline void setMaxObs(const Int& n=1000)   {maxObs_p=n;};
    inline void setMaxArray(const Int& n=1000) {maxArray_p=n;};
    
    // Set the error handler to be used for reporting errors while
    // parsing the type of expression give by the first argument.
    void setErrorHandler(const MSExprType type, MSSelectionErrorHandler* mssEH,
             const Bool overRide=True);
    
    // Initialize the error handler.  This is set the error-handler to
    // the user supplied error handler via setErrorHandler() or to the
    // default built-in error handler.
    void initErrorHandler(const MSExprType tye=NO_EXPR);
 
    // Execute the handleError() method of the error-handlers.  This
    // is called in the catch code for any exceptions emitted from any
    // of the parsers. It is also called at the end of the
    // parsing cycle.
    void runErrorHandler();
 
    // Return the pointer to the MS used internally.
    const MeasurementSet* getMS(MSSelectableTable* msLike);
 
  private:
    // Set into the order of the selection expression
    Bool setOrder(MSSelection::MSExprType type);
    
    // Initialize from a Record representing a selection
    // item from the user interface or CLI
    void fromSelectionItem(const Record& selectionItem);
    
    // Check if record field exists and is not unset
    Bool definedAndSet(const Record& inpRec, const String& fieldName);
    
    // Convert an MS select string to TaQL
    //   const String msToTaQL(const String& msSelect) {};
    
    TableExprNode fullTEN_p;
    const MeasurementSet *ms_p;
    // Selection expressions
    String antennaExpr_p;
    String fieldExpr_p;
    String spwExpr_p;
    String scanExpr_p;
    String arrayExpr_p;
    String timeExpr_p;
    String uvDistExpr_p;
    String polnExpr_p;
    String taqlExpr_p;
    String stateExpr_p;
    String observationExpr_p;
    String feedExpr_p;
    // Priority
    Vector<Int> exprOrder_p;
    Vector<Int> antenna1IDs_p,antenna2IDs_p,fieldIDs_p, spwIDs_p, scanIDs_p, arrayIDs_p,
      ddIDs_p,stateObsModeIDs_p, observationIDs_p, spwDDIDs_p, feed1IDs_p, feed2IDs_p;
    Matrix<Int> chanIDs_p;
    Matrix<Int> baselineIDs_p;
    Matrix<Int> feedPairIDs_p;
    Matrix<Double> selectedTimesList_p;
    Matrix<Double> selectedUVRange_p;
    Vector<Bool> selectedUVUnits_p;
    std::map<Int, Vector<Int> > selectedPolMap_p;
    std::map<Int, Vector<Vector<Int> > > selectedSetupMap_p;
    Int maxScans_p, maxObs_p, maxArray_p;
    Bool isMS_p,toTENCalled_p;
  };
  
} //# NAMESPACE CASACORE - END
 
#endif