Changeset 824 for trunk/src


Ignore:
Timestamp:
02/17/06 13:39:22 (19 years ago)
Author:
mar637
Message:

Forgot to change the contents in the last check in

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/Scantable.h

    r804 r824  
    1 //#---------------------------------------------------------------------------
    2 //# SDMemTable.h: A MemoryTable container for single dish integrations
    3 //#---------------------------------------------------------------------------
    4 //# Copyright (C) 2004
    5 //# ATNF
    6 //#
    7 //# This program is free software; you can redistribute it and/or modify it
    8 //# under the terms of the GNU General Public License as published by the Free
    9 //# Software Foundation; either version 2 of the License, or (at your option)
    10 //# any later version.
    11 //#
    12 //# This program is distributed in the hope that it will be useful, but
    13 //# WITHOUT ANY WARRANTY; without even the implied warranty of
    14 //# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
    15 //# Public License for more details.
    16 //#
    17 //# You should have received a copy of the GNU General Public License along
    18 //# with this program; if not, write to the Free Software Foundation, Inc.,
    19 //# 675 Massachusetts Ave, Cambridge, MA 02139, USA.
    20 //#
    21 //# Correspondence concerning this software should be addressed as follows:
    22 //#        Internet email: Malte.Marquarding@csiro.au
    23 //#        Postal address: Malte Marquarding,
    24 //#                        Australia Telescope National Facility,
    25 //#                        P.O. Box 76,
    26 //#                        Epping, NSW, 2121,
    27 //#                        AUSTRALIA
    28 //#
    29 //# $Id:
    30 //#---------------------------------------------------------------------------
    31 #ifndef SDMEMTABLE_H
    32 #define SDMEMTABLE_H
     1//
     2// C++ Interface: Scantable
     3//
     4// Description:
     5//
     6//
     7// Author: Malte Marquarding <asap@atnf.csiro.au>, (C) 2005
     8//
     9// Copyright: See COPYING file that comes with this distribution
     10//
     11//
     12#ifndef ASAPSCANTABLE_H
     13#define ASAPSCANTABLE_H
    3314
    3415// STL
    … …  
    3920#include <casa/Arrays/MaskedArray.h>
    4021#include <casa/BasicSL/String.h>
     22#include <casa/Utilities/CountedPtr.h>
     23
    4124#include <coordinates/Coordinates/SpectralCoordinate.h>
     25
    4226#include <tables/Tables/Table.h>
    4327#include <tables/Tables/ArrayColumn.h>
    4428#include <tables/Tables/ScalarColumn.h>
    4529
    46 #include "SDDefs.h"
    47 #include "SDFitTable.h"
     30#include <measures/TableMeasures/ScalarMeasColumn.h>
     31
    4832#include "SDLog.h"
     33#include "SDContainer.h"
     34#include "STFrequencies.h"
     35#include "STWeather.h"
     36#include "STFocus.h"
     37#include "STTcal.h"
     38#include "STMolecules.h"
     39#include "STSelector.h"
     40
     41
    4942
    5043namespace asap {
    5144
    52 class SDContainer;
    53 class SDHeader;
    54 class SDFrequencyTable;
    55 class SDFitTable;
    56 
    57 
    58 class SDMemTable : private SDLog {
     45/**
     46  * This class contains and wraps a casa::Table, which is used to store
     47  * all the information. This can be either a MemoryTable or a
     48  * disk based Table.
     49  * It provides access functions to the underlying table
     50  * It contains n subtables:
     51  * @li weather
     52  * @li frequencies
     53  * @li molecules
     54  * @li tcal
     55  * @li focus
     56  * @li fits
     57  *
     58  * @brief The main ASAP data container
     59  * @author Malte Marquarding
     60  * @date
     61  * @version
     62*/
     63class Scantable : private SDLog
     64{
    5965public:
    60   // create a new (empty) SDMemTable
    61   SDMemTable();
    62   // create a SDMemTable from an (aips++) table on disk
    63   SDMemTable(const std::string& name);
    64 
    65   // Copy Construct a SDMemTable, if clear==True only header and
    66   // skeleton are copied, otherwise the whole table is copied.
    67   SDMemTable(const SDMemTable& other, casa::Bool clear=casa::False);
    68 
    69   // Copy Construct (copy semantics) a SDMemTable, give a scanid constraint
    70   // see also getScan()
    71   SDMemTable(const casa::Table& tab, const std::string& expr);
    72 
    73   // Assignment operator (copy semantics)
    74   SDMemTable &operator=(const SDMemTable& other);
    75 
    76   virtual ~SDMemTable();
    77 
    78   // put data from meta conatiner into the table
    79   bool putSDContainer(const SDContainer& sdc);
    80   bool putSDHeader(const SDHeader& sdh);
    81   bool putSDFreqTable(const SDFrequencyTable& sdft);
    82 
    83   //get the data wrapped up in a meta container
    84 
    85   SDContainer getSDContainer(casa::uInt whichRow=0) const;
    86   SDHeader getSDHeader() const;
    87 
    88   // Get SD Frequency table.
    89   SDFrequencyTable getSDFreqTable() const;
    90 
    91   // get spectrum,mask and tsys for the given row, at the selected
    92   // cursor - all as stl vectors
    93   virtual std::vector<float> getSpectrum(casa::Int whichRow=0) const;
    94   virtual std::vector<bool> getMask(casa::Int whichRow=0) const;
    95 
    96   // Get length of STokes spectrum. XX & YY -> I
    97   // Anything else the length stays the same.
    98   int nStokes() const;
    99 
    100   // Get specific Stokes at cursor location. One of either I,Q,U,V or
    101   // I,P,PA,V (doPol=True) (determined by the polSel cursor location
    102   // 0->3) If the latter, you can add a PA offset (degrees)
    103   virtual std::vector<float> getStokesSpectrum(casa::Int whichRow=0,
    104                                                casa::Bool doPol=casa::False) const;
    105 
    106   // Returns Label for polarization selected by polSel_ (or
    107   // over-ridden with arg. polIdx).  If doStokes is False, returns
    108   // label for raw correlations (linear or circular). If True returns
    109   // label for Stokes.  If doPol=False, I,Q,U,V else I,P,PA,V
    110   std::string getPolarizationLabel(casa::Bool linear, casa::Bool stokes,
    111                                    casa::Bool linPol,
    112                                    casa::Int polIdx=-1) const;
    113 
    114   // Convert Stokes to linear or circular polarizations (specified by
    115   // polIdx=0:3).  Presently, only conversion to RR or LL is
    116   // supported.
    117   virtual std::vector<float> stokesToPolSpectrum(casa::Int whichRow,
    118                                                  casa::Bool toLinear,
    119                                                  casa::Int polIdx) const;
    120 
    121   // Get all Stokes at the specified Beam/IF cursor location (ignoring
    122   // the internal cursor).  -1 means all on that axis.  Really, this function
    123   // should not be here, and the SDContainer should hold the stokes spectrum
    124   // as well.  However, because the Stokes column is virtual, and its shape
    125   // is not the same as nPol(), I have put it here for direct access as needed
    126   virtual casa::Array<casa::Float> getStokesSpectrum(casa::Int whichRow=0,
    127                                                      casa::Int iBeam=-1,
    128                                                      casa::Int iIF=-1) const;
    129 
    130   // Get Tsys at cursor location
    131   virtual casa::Float getTsys(casa::Int whichRow=0) const;
    132 
    133   // get all as aips++ Vectors
    134   virtual void getSpectrum(casa::Vector<casa::Float>& spectrum,
    135                            casa::Int whichRow=0) const;
    136 
    137   // Get rest frequencies
    138   std::vector<double> getRestFreqs() const;
    139 
    140   // get info for current row
    141   // if whichRow == -1 the Header time is given
    142   std::string getTime(casa::Int whichRow=0,
    143                       casa::Bool showDate=casa::False) const ;
    144   casa::MEpoch getEpoch(casa::Int whichRow=0) const;
    145   casa::MDirection getDirection(casa::Int whichRow=0,
    146                                 casa::Bool refBeam=casa::False) const;
    147 
    148   std::string getSourceName(casa::Int whichRow=0) const;
    149 
    150   float getElevation(casa::Int whichRow=0) const;
    151   float getAzimuth(casa::Int whichRow=0) const;
    152   float getParAngle(casa::Int whichRow=0) const;
    153 
    154   double getInterval(casa::Int whichRow=0) const;
    155 
    156   virtual void setSpectrum(std::vector<float> spectrum, int whichRow=0);
    157   virtual void setCoordInfo(std::vector<string> theinfo);
    158 
    159   // Set RestFreqID.  source="" and IF=-1 means select all
    160   virtual casa::Bool setRestFreqs(const casa::Vector<casa::Double>& restFreqs,
    161                                   const casa::String& unit,
    162                                   const std::vector<std::string>& lines,
    163                                   const casa::String& source,
    164                                   casa::Int whichIF=-1);
    165 
    166   // List lines
    167   std::string spectralLines() const;
    168 
    169   // Get/Set flux unit
     66  /**
     67   * Default constructor
     68   */
     69  Scantable(casa::Table::TableType ttype = casa::Table::Memory);
     70
     71  /**
     72   * Create a Scantable object form an existing table on disk
     73   * @param[in] name the name of the existing Scantable
     74   */
     75  Scantable(const std::string& name, casa::Table::TableType ttype = casa::Table::Memory);
     76
     77  /// @fixme this is only sensible for MemoryTables....
     78  Scantable(const Scantable& other, bool clear=true);
     79
     80  /**
     81   * Destructor
     82   */
     83  virtual ~Scantable();
     84
     85  /**
     86   * get a const reference to the underlying casa::Table
     87   * @return const casa::Table reference
     88   */
     89  const casa::Table& table() const;
     90
     91  /**
     92   * get a reference to the underlying casa::Table with the Selection
     93   * object applied if set
     94   * @return casa::Table reference
     95   */
     96  casa::Table& table();
     97
     98  void setSelection(const STSelector& selection);
     99  void unsetSelection();
     100  /**
     101   * set the header
     102   * @param[in] sdh an SDHeader object
     103   */
     104  void putSDHeader( const SDHeader& sdh );
     105
     106  /**
     107   * get the header information
     108   * @return an SDHeader object
     109   */
     110  SDHeader getSDHeader( ) const;
     111
     112
     113  /**
     114   * Checks if the "other" Scantable is conformant with this,
     115   * i.e. if  header values are the same.
     116   * @param[in] other another Scantable
     117   * @return true or false
     118   */
     119  bool conformant( const Scantable& other);
     120
     121  /**
     122   * return the number of scans in the table
     123   * @return number of scans in the table
     124   */
     125  int nScan() const;
     126
     127  //casa::MDirection::Types getDirectionReference() const;
     128  //casa::MEpoch::Types getTimeReference() const;
     129
     130  /**
     131   * Get global antenna position
     132   * @return
     133   */
     134  casa::MPosition getAntennaPosition() const;
     135
     136  /**
     137   *
     138   * @return
     139   */
     140
    170141  std::string getFluxUnit() const;
    171   void setFluxUnit (const std::string& unit);
    172 
    173   // Set Instrument
    174   void setInstrument (const std::string& instrument);
    175 
    176   // set the current value
    177   virtual bool setIF(casa::Int whichIF=0);
    178   virtual bool setBeam(casa::Int whichBeam=0);
    179   virtual bool setPol(casa::Int whichPol=0);
    180 
    181   // REset cursor to 0
    182   virtual void resetCursor();
    183 
    184   // Hard flags the current spectrum, not reversible
    185   virtual void flag(int whichRow);
    186 
    187   // return the currently selected values
    188   virtual casa::Int getIF() const { return IFSel_; }
    189   virtual casa::Int getBeam() const { return beamSel_; }
    190   virtual casa::Int getPol() const { return polSel_; }
    191 
    192   // returns unit, conversion frame, doppler, base-frame
    193   virtual std::vector<std::string> getCoordInfo() const;
    194 
    195   // number of scans in table
    196   virtual casa::Int nScan() const;
    197 
    198   // get a summary of the table
    199   virtual std::string summary(bool verbose=false) const;
    200 
    201   // get/set the history
     142
     143  /**
     144   *
     145   * @param unit
     146   */
     147  void setFluxUnit( const std::string& unit );
     148
     149  /**
     150   *
     151   * @param instrument
     152   */
     153  void setInstrument( const std::string& instrument );
     154
     155  void calculateAZEL();
     156
     157  /**
     158   * "hard" flags
     159   * @param[in] whichrow
     160   */
     161  void flag();
     162
     163  int nbeam(int scanno=-1) const;
     164  int nif(int scanno=-1) const;
     165  int npol(int scanno=-1) const;
     166  int nchan(int scanno=-1, int ifno=-1) const;
     167
     168  int nrow(int scanno=-1) const;
     169
     170  double getInterval(int whichrow=0) const;
     171
     172  float getTsys(int whichrow=0) const;
     173
     174  std::vector<bool> getMask(int whichrow=0) const;
     175  std::vector<float> getSpectrum(int whichrow=0) const;
     176
     177  std::vector<float> getStokesSpectrum( int whichrow=0,
     178                                        bool dopol=false) const;
     179  std::string getPolarizationLabel(bool linear, bool stokes,
     180                                   bool linpol,
     181                                   int polidx=-1) const;
     182
     183  void makePersistent(const std::string& filename);
     184
     185
     186  void select(const STSelector& sel);
     187
     188  const STSelector& selection() const { return selector_; }
     189
    202190  std::vector<std::string> getHistory() const;
    203191  void addHistory(const std::string& hist);
    … …  
    206194  void appendToHistoryTable(const casa::Table& otherHist);
    207195
    208   // write to disk as aips++ table
    209   void makePersistent(const std::string& filename);
    210 
    211   // get a new SDMemTable containing all rows with the same give SCANID
    212   SDMemTable getScan(casa::Int scanID) const;
    213   SDMemTable getSource(const std::string& source) const;
    214 
    215   const casa::TableRecord& getHeader() const {return table_.keywordSet();}
    216   // get a handle to the "raw" aips++ table
    217   const casa::Table& table() const { return table_; }
    218 
    219   // return the number of values
    220   casa::Int nBeam() const;
    221   casa::Int nIF() const;
    222   casa::Int nPol() const;
    223   casa::Int nChan() const;
    224 
    225   // return the number of rows (integrations) in the table
    226   casa::Int nRow() const { return table_.nrow(); }
    227 
    228   // return a row as a Masked array, internally converting uChar flags
    229   // to bool mask
    230   casa::MaskedArray<casa::Float> rowAsMaskedArray(casa::uInt whichRow,
    231                                                   casa::Bool toStokes=casa::False) const;
    232 
    233   // Return SC, setting only the basic construction state (i.e.
    234   // no conversion or velocity or rest frequency state).
    235   // Specify the index of the FreqID you want
    236   casa::SpectralCoordinate getSpectralCoordinate(casa::uInt whichIdx) const;
    237 
    238   // Return SC. Set velocity conversion state (unit,doppler), and
    239   // rest frequency.  If row number given (>=0), also set
    240   // frame conversion layer (needs direction & time which require row)
    241   casa::SpectralCoordinate getSpectralCoordinate(casa::uInt freqID,
    242                                                  casa::uInt restFreqID,
    243                                                  casa::uInt row) const;
    244 
    245   // Set just the reference value, pixel and increment into the table
    246   // No other state is extracted.
    247   casa::Bool setCoordinate(const casa::SpectralCoordinate& speccord,
    248                            casa::uInt whichIdx);
    249 
    250   casa::Int nCoordinates() const;
    251 
    252   std::vector<double> getAbcissa(int whichRow=0) const;
    253   std::string getAbcissaString(casa::Int whichRow=0) const;
    254 
    255 // Get global reference  types
    256   casa::MDirection::Types getDirectionReference() const;
    257   casa::MEpoch::Types getTimeReference() const;
    258 
    259 // Get global antenna position
    260   casa::MPosition getAntennaPosition() const;
    261 
    262   bool putSDFitTable(const SDFitTable& sdft);
    263   SDFitTable getSDFitTable() const;
    264   SDFitTable getSDFitTable(casa::uInt whichRow) const;
    265 
    266   void addFit(casa::uInt whichRow,
    267               const casa::Vector<casa::Double>& p,
    268               const casa::Vector<casa::Bool>& m,
    269               const casa::Vector<casa::String>& f,
    270               const casa::Vector<casa::Int>& c);
    271 
    272 
    273   void calculateAZEL();
     196  std::string summary(bool verbose=false);
     197  std::string getTime(int whichrow=-1, bool showdate=true) const;
     198
     199
     200  STFrequencies& frequencies() { return freqTable_; }
     201  STWeather& weather() { return weatherTable_; }
     202  STFocus& focus() { return focusTable_; }
     203  STTcal& tcal() { return tcalTable_; }
     204  STMolecules& molecules() { return moleculeTable_; }
    274205
    275206private:
    276   // utility func for nice printout
    277   casa::String formatSec(casa::Double x) const;
    278   casa::String formatDirection(const casa::MDirection& md) const;
    279   std::vector<float> getFloatSpectrum(const casa::Array<casa::Float>& arr) const;
    280   void setup();
     207  /**
     208   * Turns a time vale into a formatted string
     209   * @param x
     210   * @return
     211   */
     212  std::string formatSec(casa::Double x) const;
     213
     214  std::string formatTime(const casa::MEpoch& me, bool showdate)const;
     215
     216  /**
     217   *  Turns a casa::MDirection into a nicely formatted string
     218   * @param md an casa::MDirection
     219   * @return
     220   */
     221  std::string formatDirection(const casa::MDirection& md) const;
     222
     223
     224  /**
     225   * Create a unique file name for the paged (temporary) table
     226   * @return just the name
     227   */
     228  static casa::String generateName();
     229
     230  /**
     231   * attach to cached columns
     232   */
    281233  void attach();
    282   void renumber();
    283 
    284   // Generate start and end for shape and current cursor selection
    285   void getCursorSlice(casa::IPosition& start, casa::IPosition& end,
    286                       const casa::IPosition& shape) const;
    287 
    288   // the current cursor into the array
    289   casa::Int IFSel_,beamSel_,polSel_;
    290   // the underlying memory table
     234
     235  /**
     236   * Set up the main casa::Table
     237   */
     238  void setupMainTable();
     239
     240  void setupHistoryTable();
     241  void setupMoleculeTable();
     242  void setupFitTable();
     243
     244  /**
     245   * Convert an "old" asap1 style row index into a new index
     246   * @param[in] therow
     247   * @return and index into @table_
     248   */
     249  int rowToScanIndex(int therow);
     250
     251  static const unsigned int version_ = 2;
     252
     253  STSelector selector_;
     254
     255  casa::Table::TableType type_;
     256
     257  // the actual data
    291258  casa::Table table_;
    292   // The current table version
    293   static const casa::uInt version_ = 1;
     259  casa::Table originalTable_;
     260
     261  STTcal tcalTable_;
     262  STFrequencies freqTable_;
     263  STWeather weatherTable_;
     264  STFocus focusTable_;
     265  STMolecules moleculeTable_;
     266  casa::Table fitTable_;
     267  casa::Table historyTable_;
    294268
    295269  // Cached Columns to avoid reconstructing them for each row get/put
    296270  casa::ScalarColumn<casa::Double> timeCol_, integrCol_;
    297   casa::ScalarColumn<casa::Float> azCol_, elCol_, paraCol_;
    298   casa::ScalarColumn<casa::String> srcnCol_, fldnCol_, tcaltCol_;
    299   casa::ScalarColumn<casa::Int> scanCol_, rbeamCol_;
    300   casa::ArrayColumn<casa::Float> specCol_, tsCol_, tcalCol_;
    301   casa::ArrayColumn<casa::Double> dirCol_;
     271  casa::MDirection::ScalarColumn dirCol_;
     272  casa::ScalarColumn<casa::Double> azCol_;
     273  casa::ScalarColumn<casa::Double> elCol_;
     274  casa::ScalarColumn<casa::Float> paraCol_;
     275  casa::ScalarColumn<casa::String> srcnCol_, fldnCol_;
     276  casa::ScalarColumn<casa::uInt> scanCol_, beamCol_, cycleCol_;
     277  casa::ScalarColumn<casa::Int> rbeamCol_;
     278  casa::ArrayColumn<casa::Float> specCol_, tsCol_;
    302279  casa::ArrayColumn<casa::uChar> flagsCol_;
    303   casa::ArrayColumn<casa::uInt> freqidCol_, restfreqidCol_;
    304   casa::ArrayColumn<casa::String> histCol_;
    305   casa::ArrayColumn<casa::Int> fitCol_;
    306   casa::ROArrayColumn<casa::Float> stokesCol_;
     280
     281  // id in frequencies table
     282  casa::ScalarColumn<casa::uInt> mfreqidCol_;
     283  // id in tcal table
     284  casa::ScalarColumn<casa::uInt> mtcalidCol_;
     285
     286  casa::ArrayColumn<casa::String> histitemCol_;
     287  casa::ScalarColumn<casa::uInt> mfitidCol_, fitidCol_;
     288  // id in weather table and main table
     289  casa::ScalarColumn<casa::uInt> mweatheridCol_;
     290
     291  casa::ScalarColumn<casa::uInt> mfocusidCol_;
     292
     293  casa::ScalarColumn<casa::uInt> mmolidCol_;
     294
    307295};
    308296
    309 }// namespace
     297
     298} // namespace
     299
    310300#endif
Note: See TracChangeset for help on using the changeset viewer.