source: trunk/src/SDMemTable.h @ 490

Last change on this file since 490 was 490, checked in by kil064, 19 years ago

add functions

stokesLength
getStokesSpectrumLabel
getCircularSpectrumLabel

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