source: trunk/src/Scantable.h@ 882

Last change on this file since 882 was 865, checked in by mar637, 19 years ago

added getAbcissa and several inline get functions. Full support of Table::Plain now (Ger modifications incasa::Table)

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 10.3 KB
Line 
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
14
15// STL
16#include <string>
17#include <vector>
18// AIPS++
19#include <casa/aips.h>
20#include <casa/Arrays/MaskedArray.h>
21#include <casa/BasicSL/String.h>
22#include <casa/Utilities/CountedPtr.h>
23
24#include <coordinates/Coordinates/SpectralCoordinate.h>
25
26#include <tables/Tables/Table.h>
27#include <tables/Tables/ArrayColumn.h>
28#include <tables/Tables/ScalarColumn.h>
29
30#include <measures/TableMeasures/ScalarMeasColumn.h>
31
32#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#include "STHistory.h"
41
42
43
44namespace asap {
45
46/**
47 * This class contains and wraps a casa::Table, which is used to store
48 * all the information. This can be either a MemoryTable or a
49 * disk based Table.
50 * It provides access functions to the underlying table
51 * It contains n subtables:
52 * @li weather
53 * @li frequencies
54 * @li molecules
55 * @li tcal
56 * @li focus
57 * @li fits
58 *
59 * @brief The main ASAP data container
60 * @author Malte Marquarding
61 * @date
62 * @version
63*/
64class Scantable : private SDLog
65{
66public:
67 /**
68 * Default constructor
69 */
70 Scantable(casa::Table::TableType ttype = casa::Table::Memory);
71
72 /**
73 * Create a Scantable object form an existing table on disk
74 * @param[in] name the name of the existing Scantable
75 */
76 Scantable(const std::string& name, casa::Table::TableType ttype = casa::Table::Memory);
77
78 /// @fixme this is only sensible for MemoryTables....
79 Scantable(const Scantable& other, bool clear=true);
80
81 /**
82 * Destructor
83 */
84 virtual ~Scantable();
85
86 /**
87 * get a const reference to the underlying casa::Table
88 * @return consantcasa::Table reference
89 */
90 const casa::Table& table() const;
91
92 /**
93 * get a reference to the underlying casa::Table with the Selection
94 * object applied if set
95 * @return casa::Table reference
96 */
97 casa::Table& table();
98
99
100 /**
101 * Get a handle to the selection object
102 * @return constant STSelector reference
103 */
104 const STSelector& getSelection() const { return selector_; }
105
106 /**
107 * Set the data to be a subset as defined by the STSelector
108 * @param selection a STSelector object
109 */
110 void setSelection(const STSelector& selection);
111
112 /**
113 * unset the selection of the data
114 */
115 void unsetSelection();
116 /**
117 * set the header
118 * @param[in] sdh an SDHeader object
119 */
120 void setHeader( const SDHeader& sdh );
121
122 /**
123 * get the header information
124 * @return an SDHeader object
125 */
126 SDHeader getHeader( ) const;
127 /**
128 * Checks if the "other" Scantable is conformant with this,
129 * i.e. if header values are the same.
130 * @param[in] other another Scantable
131 * @return true or false
132 */
133 bool conformant( const Scantable& other);
134
135 /**
136 * return the number of scans in the table
137 * @return number of scans in the table
138 */
139 int nscan() const;
140
141 //casa::MDirection::Types getDirectionReference() const;
142 //casa::MEpoch::Types getTimeReference() const;
143
144 /**
145 * Get global antenna position
146 * @return casa::MPosition
147 */
148 casa::MPosition getAntennaPosition() const;
149
150 /**
151 * Return the Flux unit of the data, e.g. "Jy" or "K"
152 * @return string
153 */
154 std::string getFluxUnit() const;
155
156 /**
157 * Set the Flux unit of the data
158 * @param unit a string representing the unit, e.g "Jy" or "K"
159 */
160 void setFluxUnit( const std::string& unit );
161
162 /**
163 *
164 * @param instrument a string representing an insturment. see xxx
165 */
166 void setInstrument( const std::string& instrument );
167
168 /**
169 * (Re)calculate the azimuth and elevationnfor all rows
170 */
171 void calculateAZEL();
172
173 /**
174 * "hard" flag the data, this flags everything selected in setSelection()
175 */
176 void flag();
177
178 /**
179 * Return a list of row numbers with respect to the original table.
180 * @return a lsi of rownumbers with respect to the original table
181 */
182 std::vector<unsigned int> rownumbers() const;
183
184
185 /**
186 * Get the number of beams in the data or a specific scan
187 * @param scanno the scan number to get the number of beams for.
188 * If scanno<0 the number is retrieved from the header.
189 * @return an integer number
190 */
191 int nbeam(int scanno=-1) const;
192 /**
193 * Get the number of IFs in the data or a specific scan
194 * @param scanno the scan number to get the number of IFs for.
195 * If scanno<0 the number is retrieved from the header.
196 * @return an integer number
197 */
198 int nif(int scanno=-1) const;
199 /**
200 * Get the number of polarizations in the data or a specific scan
201 * @param scanno the scan number to get the number of polarizations for.
202 * If scanno<0 the number is retrieved from the header.
203 * @return an integer number
204 */
205 int npol(int scanno=-1) const;
206
207 /**
208 * Get the number of channels in the data or a specific IF. This currently
209 * varies only with IF number
210 * @param ifno the IF number to get the number of channels for.
211 * If ifno<0 the number is retrieved from the header.
212 * @return an integer number
213 */
214 int nchan(int ifno=-1) const;
215
216 /**
217 * Get the number of integartion cycles
218 * @param scanno the scan number to get the number of rows for.
219 * If scanno<0 the number is retrieved from the header.
220 * @return
221 */
222 int nrow(int scanno=-1) const;
223
224 int ncycle(int scanno=-1) const;
225
226 int getBeam(int whichrow) const;
227 int getIF(int whichrow) const;
228 int getPol(int whichrow) const;
229 int getCycle(int whichrow) const { return cycleCol_(whichrow); }
230 int getScan(int whichrow) const { return scanCol_(whichrow); }
231
232 double getInterval(int whichrow) const
233 { return integrCol_(whichrow); }
234
235 float getTsys(int whichrow) const
236 { return casa::Vector<casa::Float>(tsysCol_(whichrow))(0); }
237 float getElevation(int whichrow) const
238 { return elCol_(whichrow); }
239 float getAzimuth(int whichrow) const
240 { return azCol_(whichrow); }
241 float getParAngle(int whichrow) const
242 { return paraCol_(whichrow); }
243
244 std::string getSourceName(int whichrow) const
245 { return srcnCol_(whichrow); }
246
247 std::vector<bool> getMask(int whichrow) const;
248 std::vector<float> getSpectrum(int whichrow) const;
249
250 std::vector<float> getStokesSpectrum( int whichrow=0,
251 bool dopol=false) const;
252 std::string getPolarizationLabel(bool linear, bool stokes,
253 bool linpol,
254 int polidx=-1) const;
255
256 /**
257 * Write the Scantable to disk
258 * @param filename the output file name
259 */
260 void makePersistent(const std::string& filename);
261
262 std::vector<std::string> getHistory() const
263 { return historyTable_.getHistory(); };
264
265 void addHistory(const std::string& hist) { historyTable_.addEntry(hist); }
266
267 void appendToHistoryTable(const STHistory& otherhist)
268 { historyTable_.append(otherhist); }
269
270 std::string summary(bool verbose=false);
271 std::string getTime(int whichrow=-1, bool showdate=true) const;
272
273 // returns unit, conversion frame, doppler, base-frame
274
275 /**
276 * Get the frequency set up
277 * This is forwarded to the STFrequencies subtable
278 * @return unit, frame, doppler
279 */
280 std::vector<std::string> getCoordInfo() const
281 { return freqTable_.getInfo(); };
282
283 void setCoordInfo(std::vector<string> theinfo)
284 { return freqTable_.setInfo(theinfo); };
285
286
287 std::vector<double> getAbcissa(int whichrow) const;
288
289 std::string getAbcissaLabel(int whichrow) const;
290 std::vector<double> getRestFrequencies() const
291 { return moleculeTable_.getRestFrequencies(); }
292
293 void setRestFrequencies(double rf, const std::string& = "Hz");
294 void setRestFrequencies(const std::string& name);
295
296 STFrequencies& frequencies() { return freqTable_; }
297 STWeather& weather() { return weatherTable_; }
298 STFocus& focus() { return focusTable_; }
299 STTcal& tcal() { return tcalTable_; }
300 STMolecules& molecules() { return moleculeTable_; }
301 STHistory& history() { return historyTable_; }
302
303private:
304 /**
305 * Turns a time vale into a formatted string
306 * @param x
307 * @return
308 */
309 std::string formatSec(casa::Double x) const;
310
311 std::string formatTime(const casa::MEpoch& me, bool showdate)const;
312
313 /**
314 * Turns a casa::MDirection into a nicely formatted string
315 * @param md an casa::MDirection
316 * @return
317 */
318 std::string formatDirection(const casa::MDirection& md) const;
319
320
321 /**
322 * Create a unique file name for the paged (temporary) table
323 * @return just the name
324 */
325 static casa::String generateName();
326
327 /**
328 * attach to cached columns
329 */
330 void attach();
331
332 /**
333 * Set up the main casa::Table
334 */
335 void setupMainTable();
336
337 void setupFitTable();
338
339 void attachSubtables();
340 void copySubtables(const Scantable& other);
341
342 /**
343 * Convert an "old" asap1 style row index into a new index
344 * @param[in] therow
345 * @return and index into @table_
346 */
347 int rowToScanIndex(int therow);
348
349 static const unsigned int version_ = 2;
350
351 STSelector selector_;
352
353 casa::Table::TableType type_;
354
355 // the actual data
356 casa::Table table_;
357 casa::Table originalTable_;
358
359 STTcal tcalTable_;
360 STFrequencies freqTable_;
361 STWeather weatherTable_;
362 STFocus focusTable_;
363 STMolecules moleculeTable_;
364 STHistory historyTable_;
365
366 casa::Table fitTable_;
367
368 // Cached Columns to avoid reconstructing them for each row get/put
369 casa::ScalarColumn<casa::Double> integrCol_;
370 casa::MDirection::ScalarColumn dirCol_;
371 casa::MEpoch::ScalarColumn timeCol_;
372 casa::ScalarColumn<casa::Double> azCol_;
373 casa::ScalarColumn<casa::Double> elCol_;
374 casa::ScalarColumn<casa::Float> paraCol_;
375 casa::ScalarColumn<casa::String> srcnCol_, fldnCol_;
376 casa::ScalarColumn<casa::uInt> scanCol_, beamCol_, ifCol_, polCol_, cycleCol_;
377 casa::ScalarColumn<casa::Int> rbeamCol_;
378 casa::ArrayColumn<casa::Float> specCol_, tsysCol_;
379 casa::ArrayColumn<casa::uChar> flagsCol_;
380
381 // id in frequencies table
382 casa::ScalarColumn<casa::uInt> mfreqidCol_;
383 // id in tcal table
384 casa::ScalarColumn<casa::uInt> mtcalidCol_;
385
386 casa::ArrayColumn<casa::String> histitemCol_;
387 casa::ScalarColumn<casa::uInt> mfitidCol_, fitidCol_;
388 // id in weather table and main table
389 casa::ScalarColumn<casa::uInt> mweatheridCol_;
390
391 casa::ScalarColumn<casa::uInt> mfocusidCol_;
392
393 casa::ScalarColumn<casa::uInt> mmolidCol_;
394
395};
396
397
398} // namespace
399
400#endif
Note: See TracBrowser for help on using the repository browser.