source: branches/alma/src/Scantable.h @ 1603

Last change on this file since 1603 was 1603, checked in by TakTsutsumi, 15 years ago

New Development: No, merge with asap2.3.1

JIRA Issue: Yes CAS-1450

Ready to Release: Yes/No?

Interface Changes: Yes/No?

What Interface Changed: Please list interface changes

Test Programs: List test programs

Put in Release Notes: Yes

Module(s): single dish

Description: Upgrade of alma branch based on ASAP2.2.0

(rev.1562) to ASAP2.3.1 (rev.1561)


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