source: trunk/src/SDMemTable.h@ 459

Last change on this file since 459 was 457, checked in by kil064, 20 years ago

move SDMemTable::rotateXYPhase to SDMath

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 10.4 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;
55class SDFitTable;
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
86 SDContainer getSDContainer(casa::uInt whichRow=0) const;
87 SDHeader getSDHeader() const;
88
89 // Get SD Frequency table.
90 SDFrequencyTable getSDFreqTable() const;
91
92 // get spectrum,mask and tsys for the given row, at the selected
93 // cursor - all as stl vectors
94 virtual std::vector<float> getSpectrum(casa::Int whichRow=0) const;
95 virtual std::vector<bool> getMask(casa::Int whichRow=0) const;
96
97 // When we can handle input correlations being either circular or
98 // linear, we should probably have functions; getLinear,
99 // getCircular, getStokes since one can inter-convert between all
100 // three regardless of the input provided there are 4
101 // polarizations. For now, we are assuming, if there are 4
102 // polarizations, that we have linears. getSpectrum is then
103 // 'getLinear', getStokesSpectrum is 'getStokes' and
104 // getCircularSpectrum is 'getCircular'
105
106
107 // Get Stokes at cursor location. One of either I,Q,U,V or I,P,PA,V
108 // (doPol=True) If the latter, you can add a PA offset (degrees)
109 virtual std::vector<float> getStokesSpectrum(casa::Int whichRow=0,
110 casa::Bool doPol=casa::False,
111 casa::Float paOffset=0.0) const;
112
113 // Get RR or LL at cursor location (except not polSel_)
114 virtual std::vector<float> getCircularSpectrum(casa::Int whichRow=0,
115 casa::Bool rr=casa::True) const;
116
117 virtual casa::Float getTsys(casa::Int whichRow=0) const;
118 // get all as aips++ Vectors
119 virtual void getSpectrum(casa::Vector<casa::Float>& spectrum,
120 casa::Int whichRow=0) const;
121 //virtual void getMask(Vector<Bool>& mask,Int whichRow=0) const;
122
123 std::vector<double> getRestFreqs() const;
124
125 // get info for current row
126 // if whichRow == -1 the Header time is given
127 std::string getTime(casa::Int whichRow=0,
128 casa::Bool showDate=casa::False) const ;
129 casa::MEpoch getEpoch(casa::Int whichRow=0) const;
130 casa::MDirection getDirection(casa::Int whichRow=0,
131 casa::Bool refBeam=casa::False) const;
132
133 std::string getSourceName(casa::Int whichRow=0) const;
134 double getInterval(casa::Int whichRow=0) const;
135
136 virtual void setSpectrum(std::vector<float> spectrum, int whichRow=0);
137 virtual void setCoordInfo(std::vector<string> theinfo);
138
139 // Set RestFreqID. source="" and IF=-1 means select all
140 virtual casa::Bool setRestFreqs(const casa::Vector<casa::Double>& restFreqs,
141 const casa::String& unit,
142 const std::vector<std::string>& lines,
143 const casa::String& source,
144 casa::Int whichIF=-1);
145
146 // List lines
147 void spectralLines() const;
148
149 // Get/Set flux unit
150 std::string getFluxUnit() const;
151 void setFluxUnit (const std::string& unit);
152
153 // Set Instrument
154 void setInstrument (const std::string& instrument);
155
156 // set the current value
157 virtual bool setIF(casa::Int whichIF=0);
158 virtual bool setBeam(casa::Int whichBeam=0);
159 virtual bool setPol(casa::Int whichPol=0);
160
161 // REset cursor to 0
162 virtual void resetCursor();
163
164 //sets the user mask applied to all spectra
165 virtual bool setMask(std::vector<int> whichChans);
166 // Hard flags the current spectrum, not reversible
167 virtual void flag(int whichRow);
168
169 // return the currently selected values
170 virtual casa::Int getIF() const { return IFSel_; }
171 virtual casa::Int getBeam() const { return beamSel_; }
172 virtual casa::Int getPol() const { return polSel_; }
173
174 // returns unit, conversion frame, doppler, base-frame
175 virtual std::vector<std::string> getCoordInfo() const;
176
177 // number of scans in table
178 virtual casa::Int nScan() const;
179
180 // get a summary of the table
181 virtual std::string summary(bool verbose=false) const;
182
183 std::vector<std::string> history(int whichRow=0) const;
184 bool appendHistory(const std::string& hist, int whichRow=0);
185 // write to disk as aips++ table
186 void makePersistent(const std::string& filename);
187
188 // get a new SDMemTable containing all rows with the same give SCANID
189 SDMemTable getScan(casa::Int scanID) const;
190 SDMemTable getSource(const std::string& source) const;
191
192 const casa::TableRecord& getHeader() const {return table_.keywordSet();}
193 // get a handle to the "raw" aips++ table
194 const casa::Table& table() const { return table_; }
195
196 // return the number of values
197 casa::Int nBeam() const;
198 casa::Int nIF() const;
199 casa::Int nPol() const;
200 casa::Int nChan() const;
201
202 // return the number of rows (integrations) in the table
203 casa::Int nRow() const { return table_.nrow(); }
204
205 // return a row as a Masked array, internally converting uChar flags
206 // to bool mask
207 casa::MaskedArray<casa::Float> rowAsMaskedArray(casa::uInt whichRow,
208 casa::Bool toStokes=casa::False) const;
209
210 // Return SC, setting only the basic construction state (i.e.
211 // no conversion or velocity or rest frequency state).
212 // Specify the index of the FreqID you want
213 casa::SpectralCoordinate getSpectralCoordinate(casa::uInt whichIdx) const;
214
215 // Return SC. Set velocity conversion state (unit,doppler), and
216 // rest frequency. If row number given (>=0), also set
217 // frame conversion layer (needs direction & time which require row)
218 casa::SpectralCoordinate getSpectralCoordinate(casa::uInt freqID,
219 casa::uInt restFreqID,
220 casa::uInt row) const;
221
222 // Set just the reference value, pixel and increment into the table
223 // No other state is extracted.
224 casa::Bool setCoordinate(const casa::SpectralCoordinate& speccord,
225 casa::uInt whichIdx);
226
227 casa::Int nCoordinates() const;
228
229 std::vector<double> getAbcissa(int whichRow=0) const;
230 std::string getAbcissaString(casa::Int whichRow=0) const;
231
232// Get global reference types
233 casa::MDirection::Types getDirectionReference() const;
234 casa::MEpoch::Types getTimeReference() const;
235
236// Get global antenna position
237 casa::MPosition getAntennaPosition() const;
238
239// Helper function to check instrument (antenna) name and give enum
240 static Instrument convertInstrument(const casa::String& instrument,
241 casa::Bool throwIt);
242
243 bool putSDFitTable(const SDFitTable& sdft);
244 SDFitTable getSDFitTable() const;
245
246 void addFit(casa::uInt whichRow,
247 const casa::Vector<casa::Double>& p,
248 const casa::Vector<casa::Bool>& m,
249 const casa::Vector<casa::String>& f,
250 const casa::Vector<casa::Int>& c);
251
252private:
253 // utility func for nice printout
254 casa::String formatSec(casa::Double x) const;
255 casa::String formatDirection(const casa::MDirection& md) const;
256 std::vector<float> getFloatSpectrum(const casa::Array<casa::Float>& arr) const;
257 void setup();
258 void attach();
259 void renumber();
260
261 // Generate start and end for shape and current cursor selection
262 void setCursorSlice(casa::IPosition& start, casa::IPosition& end,
263 const casa::IPosition& shape) const;
264
265 // the current cursor into the array
266 casa::Int IFSel_,beamSel_,polSel_;
267 std::vector<bool> chanMask_;
268 // the underlying memory table
269 casa::Table table_;
270
271 // Cached Columns to avoid reconstructing them for each row get/put
272 casa::ScalarColumn<casa::Double> timeCol_, integrCol_;
273 casa::ScalarColumn<casa::Float> azCol_, elCol_, paraCol_;
274 casa::ScalarColumn<casa::String> srcnCol_, fldnCol_, tcaltCol_;
275 casa::ScalarColumn<casa::Int> scanCol_, rbeamCol_;
276 casa::ArrayColumn<casa::Float> specCol_, tsCol_, tcalCol_;
277 casa::ArrayColumn<casa::Double> dirCol_;
278 casa::ArrayColumn<casa::uChar> flagsCol_;
279 casa::ArrayColumn<casa::uInt> freqidCol_, restfreqidCol_;
280 casa::ArrayColumn<casa::String> histCol_;
281 casa::ArrayColumn<casa::Int> fitCol_;
282 casa::ROArrayColumn<casa::Float> stokesCol_;
283};
284
285}// namespace
286#endif
Note: See TracBrowser for help on using the repository browser.