source: trunk/src/Scantable.h@ 1114

Last change on this file since 1114 was 1111, checked in by mar637, 18 years ago

add getNumbers utility function, which is now called by all function which retrieve numbers from the Scantable

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