source: branches/Release12/src/SDMemTable.h@ 828

Last change on this file since 828 was 800, checked in by mar637, 19 years ago

Request: added channel based flagging

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 11.6 KB
RevLine 
[2]1//#---------------------------------------------------------------------------
2//# SDMemTable.h: A MemoryTable container for single dish integrations
3//#---------------------------------------------------------------------------
4//# Copyright (C) 2004
[125]5//# ATNF
[2]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//#---------------------------------------------------------------------------
[125]31#ifndef SDMEMTABLE_H
32#define SDMEMTABLE_H
[2]33
34// STL
35#include <string>
36#include <vector>
37// AIPS++
[455]38#include <casa/aips.h>
[322]39#include <casa/Arrays/MaskedArray.h>
[80]40#include <casa/BasicSL/String.h>
[322]41#include <coordinates/Coordinates/SpectralCoordinate.h>
[80]42#include <tables/Tables/Table.h>
[322]43#include <tables/Tables/ArrayColumn.h>
44#include <tables/Tables/ScalarColumn.h>
45
[236]46#include "SDDefs.h"
[465]47#include "SDFitTable.h"
[717]48#include "SDLog.h"
[2]49
[83]50namespace asap {
[745]51
[2]52class SDContainer;
53class SDHeader;
54class SDFrequencyTable;
[455]55class SDFitTable;
[2]56
57
[717]58class SDMemTable : private SDLog {
[2]59public:
[19]60 // create a new (empty) SDMemTable
[18]61 SDMemTable();
[50]62 // create a SDMemTable from an (aips++) table on disk
[18]63 SDMemTable(const std::string& name);
[19]64
65 // Copy Construct a SDMemTable, if clear==True only header and
66 // skeleton are copied, otherwise the whole table is copied.
[147]67 SDMemTable(const SDMemTable& other, casa::Bool clear=casa::False);
[2]68
[161]69 // Copy Construct (copy semantics) a SDMemTable, give a scanid constraint
[19]70 // see also getScan()
[125]71 SDMemTable(const casa::Table& tab, const std::string& expr);
[161]72
[745]73 // Assignment operator (copy semantics)
[138]74 SDMemTable &operator=(const SDMemTable& other);
[745]75
[2]76 virtual ~SDMemTable();
[19]77
78 // put data from meta conatiner into the table
[39]79 bool putSDContainer(const SDContainer& sdc);
80 bool putSDHeader(const SDHeader& sdh);
81 bool putSDFreqTable(const SDFrequencyTable& sdft);
[21]82
[161]83 //get the data wrapped up in a meta container
[386]84
[125]85 SDContainer getSDContainer(casa::uInt whichRow=0) const;
[39]86 SDHeader getSDHeader() const;
[293]87
[745]88 // Get SD Frequency table.
[39]89 SDFrequencyTable getSDFreqTable() const;
[306]90
[19]91 // get spectrum,mask and tsys for the given row, at the selected
[21]92 // cursor - all as stl vectors
[125]93 virtual std::vector<float> getSpectrum(casa::Int whichRow=0) const;
94 virtual std::vector<bool> getMask(casa::Int whichRow=0) const;
[430]95
[490]96 // Get length of STokes spectrum. XX & YY -> I
97 // Anything else the length stays the same.
[493]98 int nStokes() const;
[490]99
[527]100 // Get specific Stokes at cursor location. One of either I,Q,U,V or
101 // I,P,PA,V (doPol=True) (determined by the polSel cursor location
102 // 0->3) If the latter, you can add a PA offset (degrees)
[745]103 virtual std::vector<float> getStokesSpectrum(casa::Int whichRow=0,
[504]104 casa::Bool doPol=casa::False) const;
[21]105
[527]106 // Returns Label for polarization selected by polSel_ (or
107 // over-ridden with arg. polIdx). If doStokes is False, returns
108 // label for raw correlations (linear or circular). If True returns
109 // label for Stokes. If doPol=False, I,Q,U,V else I,P,PA,V
[745]110 std::string getPolarizationLabel(casa::Bool linear, casa::Bool stokes,
111 casa::Bool linPol,
112 casa::Int polIdx=-1) const;
[490]113
[527]114 // Convert Stokes to linear or circular polarizations (specified by
115 // polIdx=0:3). Presently, only conversion to RR or LL is
116 // supported.
117 virtual std::vector<float> stokesToPolSpectrum(casa::Int whichRow,
[745]118 casa::Bool toLinear,
119 casa::Int polIdx) const;
[430]120
[472]121 // Get all Stokes at the specified Beam/IF cursor location (ignoring
122 // the internal cursor). -1 means all on that axis. Really, this function
123 // should not be here, and the SDContainer should hold the stokes spectrum
124 // as well. However, because the Stokes column is virtual, and its shape
125 // is not the same as nPol(), I have put it here for direct access as needed
126 virtual casa::Array<casa::Float> getStokesSpectrum(casa::Int whichRow=0,
[745]127 casa::Int iBeam=-1,
[472]128 casa::Int iIF=-1) const;
129
130 // Get Tsys at cursor location
[125]131 virtual casa::Float getTsys(casa::Int whichRow=0) const;
[472]132
[21]133 // get all as aips++ Vectors
[745]134 virtual void getSpectrum(casa::Vector<casa::Float>& spectrum,
135 casa::Int whichRow=0) const;
[2]136
[472]137 // Get rest frequencies
[251]138 std::vector<double> getRestFreqs() const;
[745]139
140 // get info for current row
[281]141 // if whichRow == -1 the Header time is given
[745]142 std::string getTime(casa::Int whichRow=0,
143 casa::Bool showDate=casa::False) const ;
144 casa::MEpoch getEpoch(casa::Int whichRow=0) const;
[286]145 casa::MDirection getDirection(casa::Int whichRow=0,
[745]146 casa::Bool refBeam=casa::False) const;
[455]147
[125]148 std::string getSourceName(casa::Int whichRow=0) const;
[787]149
150 float getElevation(casa::Int whichRow=0) const;
151 float getAzimuth(casa::Int whichRow=0) const;
152 float getParAngle(casa::Int whichRow=0) const;
153
[125]154 double getInterval(casa::Int whichRow=0) const;
[50]155
[88]156 virtual void setSpectrum(std::vector<float> spectrum, int whichRow=0);
[105]157 virtual void setCoordInfo(std::vector<string> theinfo);
[206]158
[455]159 // Set RestFreqID. source="" and IF=-1 means select all
[745]160 virtual casa::Bool setRestFreqs(const casa::Vector<casa::Double>& restFreqs,
161 const casa::String& unit,
162 const std::vector<std::string>& lines,
163 const casa::String& source,
164 casa::Int whichIF=-1);
[386]165
[455]166 // List lines
[717]167 std::string spectralLines() const;
[401]168
[455]169 // Get/Set flux unit
[206]170 std::string getFluxUnit() const;
[218]171 void setFluxUnit (const std::string& unit);
[745]172
[455]173 // Set Instrument
[236]174 void setInstrument (const std::string& instrument);
175
[19]176 // set the current value
[125]177 virtual bool setIF(casa::Int whichIF=0);
178 virtual bool setBeam(casa::Int whichBeam=0);
179 virtual bool setPol(casa::Int whichPol=0);
[88]180
[303]181 // REset cursor to 0
182 virtual void resetCursor();
183
[800]184 // Hard flags the current spectrum, (currently) not reversible
185 virtual void flagSpectrum(const std::vector<bool>& flags, int whichRow);
[88]186
[19]187 // return the currently selected values
[154]188 virtual casa::Int getIF() const { return IFSel_; }
189 virtual casa::Int getBeam() const { return beamSel_; }
190 virtual casa::Int getPol() const { return polSel_; }
[263]191
192 // returns unit, conversion frame, doppler, base-frame
[206]193 virtual std::vector<std::string> getCoordInfo() const;
[88]194
[50]195 // number of scans in table
[125]196 virtual casa::Int nScan() const;
[50]197
[206]198 // get a summary of the table
[380]199 virtual std::string summary(bool verbose=false) const;
[88]200
[483]201 // get/set the history
202 std::vector<std::string> getHistory() const;
203 void addHistory(const std::string& hist);
204
[488]205 casa::Table getHistoryTable() const;
206 void appendToHistoryTable(const casa::Table& otherHist);
207
[19]208 // write to disk as aips++ table
[2]209 void makePersistent(const std::string& filename);
[19]210
[88]211 // get a new SDMemTable containing all rows with the same give SCANID
[164]212 SDMemTable getScan(casa::Int scanID) const;
213 SDMemTable getSource(const std::string& source) const;
[18]214
[125]215 const casa::TableRecord& getHeader() const {return table_.keywordSet();}
[19]216 // get a handle to the "raw" aips++ table
[138]217 const casa::Table& table() const { return table_; }
[2]218
[19]219 // return the number of values
[125]220 casa::Int nBeam() const;
221 casa::Int nIF() const;
222 casa::Int nPol() const;
223 casa::Int nChan() const;
[18]224
[22]225 // return the number of rows (integrations) in the table
[125]226 casa::Int nRow() const { return table_.nrow(); }
[22]227
[19]228 // return a row as a Masked array, internally converting uChar flags
229 // to bool mask
[745]230 casa::MaskedArray<casa::Float> rowAsMaskedArray(casa::uInt whichRow,
[447]231 casa::Bool toStokes=casa::False) const;
[19]232
[286]233 // Return SC, setting only the basic construction state (i.e.
[306]234 // no conversion or velocity or rest frequency state).
235 // Specify the index of the FreqID you want
[286]236 casa::SpectralCoordinate getSpectralCoordinate(casa::uInt whichIdx) const;
237
[386]238 // Return SC. Set velocity conversion state (unit,doppler), and
239 // rest frequency. If row number given (>=0), also set
[286]240 // frame conversion layer (needs direction & time which require row)
[745]241 casa::SpectralCoordinate getSpectralCoordinate(casa::uInt freqID,
[386]242 casa::uInt restFreqID,
243 casa::uInt row) const;
[286]244
245 // Set just the reference value, pixel and increment into the table
246 // No other state is extracted.
[745]247 casa::Bool setCoordinate(const casa::SpectralCoordinate& speccord,
248 casa::uInt whichIdx);
[50]249
[125]250 casa::Int nCoordinates() const;
[88]251
[164]252 std::vector<double> getAbcissa(int whichRow=0) const;
253 std::string getAbcissaString(casa::Int whichRow=0) const;
[212]254
[286]255// Get global reference types
[281]256 casa::MDirection::Types getDirectionReference() const;
257 casa::MEpoch::Types getTimeReference() const;
[212]258
[286]259// Get global antenna position
260 casa::MPosition getAntennaPosition() const;
261
[455]262 bool putSDFitTable(const SDFitTable& sdft);
263 SDFitTable getSDFitTable() const;
[465]264 SDFitTable getSDFitTable(casa::uInt whichRow) const;
[236]265
[455]266 void addFit(casa::uInt whichRow,
[745]267 const casa::Vector<casa::Double>& p,
268 const casa::Vector<casa::Bool>& m,
269 const casa::Vector<casa::String>& f,
270 const casa::Vector<casa::Int>& c);
[465]271
[745]272
[773]273 void calculateAZEL();
274
[2]275private:
[105]276 // utility func for nice printout
[260]277 casa::String formatSec(casa::Double x) const;
[281]278 casa::String formatDirection(const casa::MDirection& md) const;
[455]279 std::vector<float> getFloatSpectrum(const casa::Array<casa::Float>& arr) const;
[2]280 void setup();
[322]281 void attach();
[380]282 void renumber();
[430]283
284 // Generate start and end for shape and current cursor selection
[745]285 void getCursorSlice(casa::IPosition& start, casa::IPosition& end,
286 const casa::IPosition& shape) const;
[430]287
[19]288 // the current cursor into the array
[125]289 casa::Int IFSel_,beamSel_,polSel_;
[50]290 // the underlying memory table
[125]291 casa::Table table_;
[483]292 // The current table version
293 static const casa::uInt version_ = 1;
[322]294
[455]295 // Cached Columns to avoid reconstructing them for each row get/put
[322]296 casa::ScalarColumn<casa::Double> timeCol_, integrCol_;
297 casa::ScalarColumn<casa::Float> azCol_, elCol_, paraCol_;
298 casa::ScalarColumn<casa::String> srcnCol_, fldnCol_, tcaltCol_;
299 casa::ScalarColumn<casa::Int> scanCol_, rbeamCol_;
300 casa::ArrayColumn<casa::Float> specCol_, tsCol_, tcalCol_;
301 casa::ArrayColumn<casa::Double> dirCol_;
302 casa::ArrayColumn<casa::uChar> flagsCol_;
[386]303 casa::ArrayColumn<casa::uInt> freqidCol_, restfreqidCol_;
[322]304 casa::ArrayColumn<casa::String> histCol_;
[455]305 casa::ArrayColumn<casa::Int> fitCol_;
[439]306 casa::ROArrayColumn<casa::Float> stokesCol_;
[2]307};
308
309}// namespace
310#endif
Note: See TracBrowser for help on using the repository browser.