source: trunk/src/SDMemTable.h@ 364

Last change on this file since 364 was 322, checked in by kil064, 20 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
Line 
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
33
34// STL
35#include <string>
36#include <vector>
37// AIPS++
38 #include <casa/aips.h>
39#include <casa/Arrays/MaskedArray.h>
40#include <casa/BasicSL/String.h>
41#include <coordinates/Coordinates/SpectralCoordinate.h>
42#include <tables/Tables/Table.h>
43#include <tables/Tables/ArrayColumn.h>
44#include <tables/Tables/ScalarColumn.h>
45
46#include "SDDefs.h"
47
48
49
50namespace asap {
51
52class SDContainer;
53class SDHeader;
54class SDFrequencyTable;
55
56
57
58
59class SDMemTable {
60public:
61 // create a new (empty) SDMemTable
62 SDMemTable();
63 // create a SDMemTable from an (aips++) table on disk
64 SDMemTable(const std::string& name);
65
66 // Copy Construct a SDMemTable, if clear==True only header and
67 // skeleton are copied, otherwise the whole table is copied.
68 SDMemTable(const SDMemTable& other, casa::Bool clear=casa::False);
69
70 // Copy Construct (copy semantics) a SDMemTable, give a scanid constraint
71 // see also getScan()
72 SDMemTable(const casa::Table& tab, const std::string& expr);
73
74 // Assignment operator (copy semantics)
75 SDMemTable &operator=(const SDMemTable& other);
76
77 virtual ~SDMemTable();
78
79 // put data from meta conatiner into the table
80 bool putSDContainer(const SDContainer& sdc);
81 bool putSDHeader(const SDHeader& sdh);
82 bool putSDFreqTable(const SDFrequencyTable& sdft);
83
84 //get the data wrapped up in a meta container
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 virtual casa::Float getTsys(casa::Int whichRow=0) const;
97 // get all as aips++ Vectors
98 virtual void getSpectrum(casa::Vector<casa::Float>& spectrum,
99 casa::Int whichRow=0) const;
100
101 //virtual void getMask(Vector<Bool>& mask,Int whichRow=0) const;
102 std::vector<double> getRestFreqs() const;
103
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 ;
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//
112 std::string getSourceName(casa::Int whichRow=0) const;
113 double getInterval(casa::Int whichRow=0) const;
114
115 virtual void setSpectrum(std::vector<float> spectrum, int whichRow=0);
116 virtual void setRestFreqs(std::vector<double> freqs,
117 const std::string& theunit);
118 virtual void setCoordInfo(std::vector<string> theinfo);
119
120// Get/Set flux unit
121 std::string getFluxUnit() const;
122 void setFluxUnit (const std::string& unit);
123
124// Set Instrument
125 void setInstrument (const std::string& instrument);
126
127 // set the current value
128 virtual bool setIF(casa::Int whichIF=0);
129 virtual bool setBeam(casa::Int whichBeam=0);
130 virtual bool setPol(casa::Int whichPol=0);
131
132 // REset cursor to 0
133 virtual void resetCursor();
134
135 //sets the user mask applied to all spectra
136 virtual bool setMask(std::vector<int> whichChans);
137 // Hard flags the current spectrum, not reversible
138 virtual void flag(int whichRow);
139
140 // return the currently selected values
141 virtual casa::Int getIF() const { return IFSel_; }
142 virtual casa::Int getBeam() const { return beamSel_; }
143 virtual casa::Int getPol() const { return polSel_; }
144
145 // returns unit, conversion frame, doppler, base-frame
146 virtual std::vector<std::string> getCoordInfo() const;
147
148 // number of scans in table
149 virtual casa::Int nScan() const;
150
151 // get a summary of the table
152 virtual std::string summary() const;
153
154 std::vector<std::string> history(int whichRow=0) const;
155 bool appendHistory(const std::string& hist, int whichRow=0);
156 // write to disk as aips++ table
157 void makePersistent(const std::string& filename);
158
159 // get a new SDMemTable containing all rows with the same give SCANID
160 SDMemTable getScan(casa::Int scanID) const;
161 SDMemTable getSource(const std::string& source) const;
162
163 const casa::TableRecord& getHeader() const {return table_.keywordSet();}
164 // get a handle to the "raw" aips++ table
165 const casa::Table& table() const { return table_; }
166
167 // return the number of values
168 casa::Int nBeam() const;
169 casa::Int nIF() const;
170 casa::Int nPol() const;
171 casa::Int nChan() const;
172
173 // return the number of rows (integrations) in the table
174 casa::Int nRow() const { return table_.nrow(); }
175
176 // return a row as a Masked array, internally converting uChar flags
177 // to bool mask
178 casa::MaskedArray<casa::Float> rowAsMaskedArray(casa::uInt whichRow,
179 casa::Bool useSelection =
180 casa::False) const;
181
182 // Return SC, setting only the basic construction state (i.e.
183 // no conversion or velocity or rest frequency state).
184 // Specify the index of the FreqID you want
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.
194 casa::Bool setCoordinate(const casa::SpectralCoordinate& speccord,
195 casa::uInt whichIdx);
196
197 casa::Int nCoordinates() const;
198
199 std::vector<double> getAbcissa(int whichRow=0) const;
200 std::string getAbcissaString(casa::Int whichRow=0) const;
201
202// Get global reference types
203 casa::MDirection::Types getDirectionReference() const;
204 casa::MEpoch::Types getTimeReference() const;
205
206// Get global antenna position
207 casa::MPosition getAntennaPosition() const;
208
209// Helper function to check instrument (antenna) name and give enum
210 static Instrument convertInstrument(const casa::String& instrument,
211 casa::Bool throwIt);
212
213private:
214 // utility func for nice printout
215 casa::String formatSec(casa::Double x) const;
216 casa::String formatDirection(const casa::MDirection& md) const;
217 void setup();
218 void attach();
219 // the current cursor into the array
220 casa::Int IFSel_,beamSel_,polSel_;
221 std::vector<bool> chanMask_;
222 // the underlying memory table
223 casa::Table table_;
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_;
235};
236
237}// namespace
238#endif
Note: See TracBrowser for help on using the repository browser.