source: trunk/src/SDMemTable.h@ 498

Last change on this file since 498 was 493, checked in by kil064, 20 years ago

function stokesLength() -> nStokes()

getStokesSpectrumLabel and getCircularSpectrumLabel combined into

getPolarizationLabel

getCircularSpectrum -> stokesToPolSpectrum

This is a more consistent set. Move some functionality to SDPolUtil

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 11.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#include "SDFitTable.h"
48
49namespace asap {
50
51class SDContainer;
52class SDHeader;
53class SDFrequencyTable;
54class SDFitTable;
55
56
57
58class SDMemTable {
59public:
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 I,P,PA,V (doPol=True)
101 // (determined by the polSel cursor location 0->3)
102 // 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,
105 casa::Float paOffset=0.0) const;
106
107 // Returns Label for polarization selected by polSel_ (or over-ridden
108 // with arg. polIdx). If doStokes is False,
109 // returns label for raw correlations (linear or circular). If True returns label for
110 // Stokes. If doPol=False, I,Q,U,V else I,P,PA,V
111 std::string getPolarizationLabel (casa::Bool linear, casa::Bool stokes,
112 casa::Bool linPol, casa::Int polIdx=-1) const;
113
114 // Convert Stokes to linear or circular polarizations (specified by polIdx=0:3).
115 // Presently, only conversion to RR or LL is supported.
116 virtual std::vector<float> stokesToPolSpectrum (casa::Int whichRow, casa::Bool toLinear,
117 casa::uInt polIdx) const;
118
119 // Get all Stokes at the specified Beam/IF cursor location (ignoring
120 // the internal cursor). -1 means all on that axis. Really, this function
121 // should not be here, and the SDContainer should hold the stokes spectrum
122 // as well. However, because the Stokes column is virtual, and its shape
123 // is not the same as nPol(), I have put it here for direct access as needed
124 virtual casa::Array<casa::Float> getStokesSpectrum(casa::Int whichRow=0,
125 casa::Int iBeam=-1,
126 casa::Int iIF=-1) const;
127
128 // Get Tsys at cursor location
129 virtual casa::Float getTsys(casa::Int whichRow=0) const;
130
131 // get all as aips++ Vectors
132 virtual void getSpectrum(casa::Vector<casa::Float>& spectrum,
133 casa::Int whichRow=0) const;
134 //virtual void getMask(Vector<Bool>& mask,Int whichRow=0) const;
135
136 // Get rest frequencies
137 std::vector<double> getRestFreqs() const;
138
139 // get info for current row
140 // if whichRow == -1 the Header time is given
141 std::string getTime(casa::Int whichRow=0,
142 casa::Bool showDate=casa::False) const ;
143 casa::MEpoch getEpoch(casa::Int whichRow=0) const;
144 casa::MDirection getDirection(casa::Int whichRow=0,
145 casa::Bool refBeam=casa::False) const;
146
147 std::string getSourceName(casa::Int whichRow=0) const;
148 double getInterval(casa::Int whichRow=0) const;
149
150 virtual void setSpectrum(std::vector<float> spectrum, int whichRow=0);
151 virtual void setCoordInfo(std::vector<string> theinfo);
152
153 // Set RestFreqID. source="" and IF=-1 means select all
154 virtual casa::Bool setRestFreqs(const casa::Vector<casa::Double>& restFreqs,
155 const casa::String& unit,
156 const std::vector<std::string>& lines,
157 const casa::String& source,
158 casa::Int whichIF=-1);
159
160 // List lines
161 void spectralLines() const;
162
163 // Get/Set flux unit
164 std::string getFluxUnit() const;
165 void setFluxUnit (const std::string& unit);
166
167 // Set Instrument
168 void setInstrument (const std::string& instrument);
169
170 // set the current value
171 virtual bool setIF(casa::Int whichIF=0);
172 virtual bool setBeam(casa::Int whichBeam=0);
173 virtual bool setPol(casa::Int whichPol=0);
174
175 // REset cursor to 0
176 virtual void resetCursor();
177
178 //sets the user mask applied to all spectra
179 virtual bool setMask(std::vector<int> whichChans);
180 // Hard flags the current spectrum, not reversible
181 virtual void flag(int whichRow);
182
183 // return the currently selected values
184 virtual casa::Int getIF() const { return IFSel_; }
185 virtual casa::Int getBeam() const { return beamSel_; }
186 virtual casa::Int getPol() const { return polSel_; }
187
188 // returns unit, conversion frame, doppler, base-frame
189 virtual std::vector<std::string> getCoordInfo() const;
190
191 // number of scans in table
192 virtual casa::Int nScan() const;
193
194 // get a summary of the table
195 virtual std::string summary(bool verbose=false) const;
196
197 // get/set the history
198 std::vector<std::string> getHistory() const;
199 void addHistory(const std::string& hist);
200
201 casa::Table getHistoryTable() const;
202 void appendToHistoryTable(const casa::Table& otherHist);
203
204 // write to disk as aips++ table
205 void makePersistent(const std::string& filename);
206
207 // get a new SDMemTable containing all rows with the same give SCANID
208 SDMemTable getScan(casa::Int scanID) const;
209 SDMemTable getSource(const std::string& source) const;
210
211 const casa::TableRecord& getHeader() const {return table_.keywordSet();}
212 // get a handle to the "raw" aips++ table
213 const casa::Table& table() const { return table_; }
214
215 // return the number of values
216 casa::Int nBeam() const;
217 casa::Int nIF() const;
218 casa::Int nPol() const;
219 casa::Int nChan() const;
220
221 // return the number of rows (integrations) in the table
222 casa::Int nRow() const { return table_.nrow(); }
223
224 // return a row as a Masked array, internally converting uChar flags
225 // to bool mask
226 casa::MaskedArray<casa::Float> rowAsMaskedArray(casa::uInt whichRow,
227 casa::Bool toStokes=casa::False) const;
228
229 // Return SC, setting only the basic construction state (i.e.
230 // no conversion or velocity or rest frequency state).
231 // Specify the index of the FreqID you want
232 casa::SpectralCoordinate getSpectralCoordinate(casa::uInt whichIdx) const;
233
234 // Return SC. Set velocity conversion state (unit,doppler), and
235 // rest frequency. If row number given (>=0), also set
236 // frame conversion layer (needs direction & time which require row)
237 casa::SpectralCoordinate getSpectralCoordinate(casa::uInt freqID,
238 casa::uInt restFreqID,
239 casa::uInt row) const;
240
241 // Set just the reference value, pixel and increment into the table
242 // No other state is extracted.
243 casa::Bool setCoordinate(const casa::SpectralCoordinate& speccord,
244 casa::uInt whichIdx);
245
246 casa::Int nCoordinates() const;
247
248 std::vector<double> getAbcissa(int whichRow=0) const;
249 std::string getAbcissaString(casa::Int whichRow=0) const;
250
251// Get global reference types
252 casa::MDirection::Types getDirectionReference() const;
253 casa::MEpoch::Types getTimeReference() const;
254
255// Get global antenna position
256 casa::MPosition getAntennaPosition() const;
257
258 bool putSDFitTable(const SDFitTable& sdft);
259 SDFitTable getSDFitTable() const;
260 SDFitTable getSDFitTable(casa::uInt whichRow) const;
261
262 void addFit(casa::uInt whichRow,
263 const casa::Vector<casa::Double>& p,
264 const casa::Vector<casa::Bool>& m,
265 const casa::Vector<casa::String>& f,
266 const casa::Vector<casa::Int>& c);
267
268
269private:
270 // utility func for nice printout
271 casa::String formatSec(casa::Double x) const;
272 casa::String formatDirection(const casa::MDirection& md) const;
273 std::vector<float> getFloatSpectrum(const casa::Array<casa::Float>& arr) const;
274 void setup();
275 void attach();
276 void renumber();
277
278 // Generate start and end for shape and current cursor selection
279 void getCursorSlice(casa::IPosition& start, casa::IPosition& end,
280 const casa::IPosition& shape) const;
281
282 // the current cursor into the array
283 casa::Int IFSel_,beamSel_,polSel_;
284 std::vector<bool> chanMask_;
285 // the underlying memory table
286 casa::Table table_;
287 // The current table version
288 static const casa::uInt version_ = 1;
289
290 // Cached Columns to avoid reconstructing them for each row get/put
291 casa::ScalarColumn<casa::Double> timeCol_, integrCol_;
292 casa::ScalarColumn<casa::Float> azCol_, elCol_, paraCol_;
293 casa::ScalarColumn<casa::String> srcnCol_, fldnCol_, tcaltCol_;
294 casa::ScalarColumn<casa::Int> scanCol_, rbeamCol_;
295 casa::ArrayColumn<casa::Float> specCol_, tsCol_, tcalCol_;
296 casa::ArrayColumn<casa::Double> dirCol_;
297 casa::ArrayColumn<casa::uChar> flagsCol_;
298 casa::ArrayColumn<casa::uInt> freqidCol_, restfreqidCol_;
299 casa::ArrayColumn<casa::String> histCol_;
300 casa::ArrayColumn<casa::Int> fitCol_;
301 casa::ROArrayColumn<casa::Float> stokesCol_;
302};
303
304}// namespace
305#endif
Note: See TracBrowser for help on using the repository browser.