source: trunk/src/SDMemTable.h @ 370

Last change on this file since 370 was 322, checked in by kil064, 19 years ago

cache all the ScalarColumn? and ArrayColumn? objects to avoid reconstructnig
themn for every row get/put.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 8.3 KB
RevLine 
[2]1//#---------------------------------------------------------------------------
2//# SDMemTable.h: A MemoryTable container for single dish integrations
3//#---------------------------------------------------------------------------
4//# Copyright (C) 2004
[125]5//# ATNF
[2]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//#---------------------------------------------------------------------------
[125]31#ifndef SDMEMTABLE_H
32#define SDMEMTABLE_H
[2]33
34// STL
35#include <string>
36#include <vector>
37// AIPS++
[236]38 #include <casa/aips.h>
[322]39#include <casa/Arrays/MaskedArray.h>
[80]40#include <casa/BasicSL/String.h>
[322]41#include <coordinates/Coordinates/SpectralCoordinate.h>
[80]42#include <tables/Tables/Table.h>
[322]43#include <tables/Tables/ArrayColumn.h>
44#include <tables/Tables/ScalarColumn.h>
45
[236]46#include "SDDefs.h"
[2]47
[39]48
[322]49
[83]50namespace asap {
[2]51
52class SDContainer;
53class SDHeader;
54class SDFrequencyTable;
55
56
[322]57
58
[2]59class SDMemTable {
60public:
[19]61  // create a new (empty) SDMemTable
[18]62  SDMemTable();
[50]63  // create a SDMemTable from an (aips++) table on disk
[18]64  SDMemTable(const std::string& name);
[19]65
66  // Copy Construct a SDMemTable, if clear==True only header and
67  // skeleton are copied, otherwise the whole table is copied.
[147]68  SDMemTable(const SDMemTable& other, casa::Bool clear=casa::False);
[2]69
[161]70  // Copy Construct (copy semantics) a SDMemTable, give a scanid constraint
[19]71  // see also getScan()
[125]72  SDMemTable(const casa::Table& tab, const std::string& expr);
[161]73
74  // Assignment operator (copy semantics) 
[138]75  SDMemTable &operator=(const SDMemTable& other);
76 
[2]77  virtual ~SDMemTable();
[19]78
79  // put data from meta conatiner into the table
[39]80  bool putSDContainer(const SDContainer& sdc);
81  bool putSDHeader(const SDHeader& sdh);
82  bool putSDFreqTable(const SDFrequencyTable& sdft);
[21]83
[161]84  //get the data wrapped up in a meta container
[125]85  SDContainer getSDContainer(casa::uInt whichRow=0) const;
[39]86  SDHeader getSDHeader() const;
[293]87
[306]88  // Get SD Frequency table. 
[39]89  SDFrequencyTable getSDFreqTable() const;
[306]90
[19]91  // get spectrum,mask and tsys for the given row, at the selected
[21]92  // cursor - all as stl vectors
[125]93  virtual std::vector<float> getSpectrum(casa::Int whichRow=0) const;
94  virtual std::vector<bool> getMask(casa::Int whichRow=0) const;
[21]95
[125]96  virtual casa::Float getTsys(casa::Int whichRow=0) const;
[21]97  // get all as aips++ Vectors
[125]98  virtual void getSpectrum(casa::Vector<casa::Float>& spectrum,
[164]99                           casa::Int whichRow=0) const;
[2]100
[88]101  //virtual void getMask(Vector<Bool>& mask,Int whichRow=0) const;
[251]102  std::vector<double> getRestFreqs() const;
103 
[281]104  // get info for current row 
105  // if whichRow == -1 the Header time is given
106  std::string getTime(casa::Int whichRow=0,
107                      casa::Bool showDate=casa::False) const ;
[286]108  casa::MEpoch getEpoch(casa::Int whichRow=0) const;
109  casa::MDirection getDirection(casa::Int whichRow=0,
110                                casa::Bool refBeam=casa::False) const;
111//
[125]112  std::string getSourceName(casa::Int whichRow=0) const;
113  double getInterval(casa::Int whichRow=0) const;
[50]114
[88]115  virtual void setSpectrum(std::vector<float> spectrum, int whichRow=0);
[125]116  virtual void setRestFreqs(std::vector<double> freqs,
117                            const std::string& theunit);
[105]118  virtual void setCoordInfo(std::vector<string> theinfo);
[206]119
[218]120// Get/Set flux unit
[206]121  std::string getFluxUnit() const;
[218]122  void setFluxUnit (const std::string& unit);
[206]123
[236]124// Set Instrument
125  void setInstrument (const std::string& instrument);
126
[19]127  // set the current value
[125]128  virtual bool setIF(casa::Int whichIF=0);
129  virtual bool setBeam(casa::Int whichBeam=0);
130  virtual bool setPol(casa::Int whichPol=0);
[88]131
[303]132  // REset cursor to 0
133  virtual void resetCursor();
134
[88]135  //sets the user mask applied to all spectra
[68]136  virtual bool setMask(std::vector<int> whichChans);
[88]137  // Hard flags the current spectrum, not reversible
138  virtual void flag(int whichRow);
139
[19]140  // return the currently selected values
[154]141  virtual casa::Int getIF() const { return IFSel_; }
142  virtual casa::Int getBeam() const { return beamSel_; }
143  virtual casa::Int getPol() const { return polSel_; }
[263]144
145  // returns unit, conversion frame, doppler, base-frame
[206]146  virtual std::vector<std::string> getCoordInfo() const;
[88]147
[50]148  // number of scans in table
[125]149  virtual casa::Int nScan() const;
[50]150
[206]151  // get a summary of the table
[260]152  virtual std::string summary() const;
[88]153
[206]154  std::vector<std::string> history(int whichRow=0) const;
155  bool appendHistory(const std::string& hist, int whichRow=0);
[19]156  // write to disk as aips++ table
[2]157  void makePersistent(const std::string& filename);
[19]158
[88]159  // get a new SDMemTable containing all rows with the same give SCANID
[164]160  SDMemTable getScan(casa::Int scanID) const;
161  SDMemTable getSource(const std::string& source) const;
[18]162
[125]163  const casa::TableRecord& getHeader() const {return table_.keywordSet();}
[19]164  // get a handle to the "raw" aips++ table
[138]165  const casa::Table& table() const { return table_; }
[2]166
[19]167  // return the number of values
[125]168  casa::Int nBeam() const;
169  casa::Int nIF() const;
170  casa::Int nPol() const;
171  casa::Int nChan() const;
[18]172
[22]173  // return the number of rows (integrations) in the table
[125]174  casa::Int nRow() const { return table_.nrow(); }
[22]175
[19]176  // return a row as a Masked array, internally converting uChar flags
177  // to bool mask
[125]178  casa::MaskedArray<casa::Float> rowAsMaskedArray(casa::uInt whichRow,
[206]179                                                  casa::Bool useSelection =
180                                                  casa::False) const;
[19]181
[286]182  // Return SC, setting only the basic construction state (i.e.
[306]183  // no conversion or velocity or rest frequency state).
184  // Specify the index of the FreqID you want
[286]185  casa::SpectralCoordinate getSpectralCoordinate(casa::uInt whichIdx) const;
186
187  // Return SC. Set velocity conversion state (unit,doppler),
188  // set rest frequencies.  If row number given (>-0), also set
189  // frame conversion layer (needs direction & time which require row)
190  casa::SpectralCoordinate getSpectralCoordinate(casa::uInt whichIdx, casa::uInt row) const;
191
192  // Set just the reference value, pixel and increment into the table
193  // No other state is extracted.
[125]194  casa::Bool setCoordinate(const casa::SpectralCoordinate& speccord,
195                           casa::uInt whichIdx);
[50]196
[125]197  casa::Int nCoordinates() const;
[88]198
[164]199  std::vector<double> getAbcissa(int whichRow=0) const;
200  std::string getAbcissaString(casa::Int whichRow=0) const;
[212]201
[286]202// Get global reference  types
[281]203  casa::MDirection::Types getDirectionReference() const;
204  casa::MEpoch::Types getTimeReference() const;
[212]205
[286]206// Get global antenna position
207  casa::MPosition getAntennaPosition() const;
208
[236]209// Helper function to check instrument (antenna) name and give enum
[281]210  static Instrument convertInstrument(const casa::String& instrument,
211                                      casa::Bool throwIt);
[236]212
[2]213private:
[105]214  // utility func for nice printout
[260]215  casa::String formatSec(casa::Double x) const;
[281]216  casa::String formatDirection(const casa::MDirection& md) const;
[2]217  void setup();
[322]218  void attach();
[19]219  // the current cursor into the array
[125]220  casa::Int IFSel_,beamSel_,polSel_;
[88]221  std::vector<bool> chanMask_;
[50]222  // the underlying memory table
[125]223  casa::Table table_;
[322]224
225// Cached Columns to avoid reconstructing them for each row get/put
226  casa::ScalarColumn<casa::Double> timeCol_, integrCol_;
227  casa::ScalarColumn<casa::Float> azCol_, elCol_, paraCol_;
228  casa::ScalarColumn<casa::String> srcnCol_, fldnCol_, tcaltCol_;
229  casa::ScalarColumn<casa::Int> scanCol_, rbeamCol_;
230  casa::ArrayColumn<casa::Float> specCol_, tsCol_, tcalCol_;
231  casa::ArrayColumn<casa::Double> dirCol_;
232  casa::ArrayColumn<casa::uChar> flagsCol_;
233  casa::ArrayColumn<casa::uInt> freqidCol_;
234  casa::ArrayColumn<casa::String> histCol_;
[2]235};
236
237}// namespace
238#endif
Note: See TracBrowser for help on using the repository browser.