source: trunk/src/SDMemTable.h@ 402

Last change on this file since 402 was 401, checked in by kil064, 20 years ago

add rest freq specification by line name
add function spectraLines to list known lines

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 8.8 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++
[236]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"
[2]47
[39]48
[322]49
[83]50namespace asap {
[2]51
52class SDContainer;
53class SDHeader;
54class SDFrequencyTable;
55
56
[322]57
58
[2]59class SDMemTable {
60public:
[19]61 // create a new (empty) SDMemTable
[18]62 SDMemTable();
[50]63 // create a SDMemTable from an (aips++) table on disk
[18]64 SDMemTable(const std::string& name);
[19]65
66 // Copy Construct a SDMemTable, if clear==True only header and
67 // skeleton are copied, otherwise the whole table is copied.
[147]68 SDMemTable(const SDMemTable& other, casa::Bool clear=casa::False);
[2]69
[161]70 // Copy Construct (copy semantics) a SDMemTable, give a scanid constraint
[19]71 // see also getScan()
[125]72 SDMemTable(const casa::Table& tab, const std::string& expr);
[161]73
74 // Assignment operator (copy semantics)
[138]75 SDMemTable &operator=(const SDMemTable& other);
76
[2]77 virtual ~SDMemTable();
[19]78
79 // put data from meta conatiner into the table
[39]80 bool putSDContainer(const SDContainer& sdc);
81 bool putSDHeader(const SDHeader& sdh);
82 bool putSDFreqTable(const SDFrequencyTable& sdft);
[21]83
[161]84 //get the data wrapped up in a meta container
[386]85
[125]86 SDContainer getSDContainer(casa::uInt whichRow=0) const;
[39]87 SDHeader getSDHeader() const;
[293]88
[306]89 // Get SD Frequency table.
[39]90 SDFrequencyTable getSDFreqTable() const;
[306]91
[19]92 // get spectrum,mask and tsys for the given row, at the selected
[21]93 // cursor - all as stl vectors
[125]94 virtual std::vector<float> getSpectrum(casa::Int whichRow=0) const;
95 virtual std::vector<bool> getMask(casa::Int whichRow=0) const;
[21]96
[125]97 virtual casa::Float getTsys(casa::Int whichRow=0) const;
[21]98 // get all as aips++ Vectors
[125]99 virtual void getSpectrum(casa::Vector<casa::Float>& spectrum,
[164]100 casa::Int whichRow=0) const;
[2]101
[88]102 //virtual void getMask(Vector<Bool>& mask,Int whichRow=0) const;
[251]103 std::vector<double> getRestFreqs() const;
104
[281]105 // get info for current row
106 // if whichRow == -1 the Header time is given
107 std::string getTime(casa::Int whichRow=0,
108 casa::Bool showDate=casa::False) const ;
[286]109 casa::MEpoch getEpoch(casa::Int whichRow=0) const;
110 casa::MDirection getDirection(casa::Int whichRow=0,
111 casa::Bool refBeam=casa::False) const;
112//
[125]113 std::string getSourceName(casa::Int whichRow=0) const;
114 double getInterval(casa::Int whichRow=0) const;
[50]115
[88]116 virtual void setSpectrum(std::vector<float> spectrum, int whichRow=0);
[105]117 virtual void setCoordInfo(std::vector<string> theinfo);
[206]118
[392]119// Set RestFreqID. source="" and IF=-1 means select all
120 virtual casa::Bool setRestFreqs (const casa::Vector<casa::Double>& restFreqs,
121 const casa::String& unit,
[401]122 const std::vector<std::string>& lines,
[392]123 const casa::String& source,
124 casa::Int whichIF=-1);
[386]125
[401]126// List lines
127 void spectralLines() const;
128
[218]129// Get/Set flux unit
[206]130 std::string getFluxUnit() const;
[218]131 void setFluxUnit (const std::string& unit);
[206]132
[236]133// Set Instrument
134 void setInstrument (const std::string& instrument);
135
[19]136 // set the current value
[125]137 virtual bool setIF(casa::Int whichIF=0);
138 virtual bool setBeam(casa::Int whichBeam=0);
139 virtual bool setPol(casa::Int whichPol=0);
[88]140
[303]141 // REset cursor to 0
142 virtual void resetCursor();
143
[88]144 //sets the user mask applied to all spectra
[68]145 virtual bool setMask(std::vector<int> whichChans);
[88]146 // Hard flags the current spectrum, not reversible
147 virtual void flag(int whichRow);
148
[19]149 // return the currently selected values
[154]150 virtual casa::Int getIF() const { return IFSel_; }
151 virtual casa::Int getBeam() const { return beamSel_; }
152 virtual casa::Int getPol() const { return polSel_; }
[263]153
154 // returns unit, conversion frame, doppler, base-frame
[206]155 virtual std::vector<std::string> getCoordInfo() const;
[88]156
[50]157 // number of scans in table
[125]158 virtual casa::Int nScan() const;
[50]159
[206]160 // get a summary of the table
[380]161 virtual std::string summary(bool verbose=false) const;
[88]162
[206]163 std::vector<std::string> history(int whichRow=0) const;
164 bool appendHistory(const std::string& hist, int whichRow=0);
[19]165 // write to disk as aips++ table
[2]166 void makePersistent(const std::string& filename);
[19]167
[88]168 // get a new SDMemTable containing all rows with the same give SCANID
[164]169 SDMemTable getScan(casa::Int scanID) const;
170 SDMemTable getSource(const std::string& source) const;
[18]171
[125]172 const casa::TableRecord& getHeader() const {return table_.keywordSet();}
[19]173 // get a handle to the "raw" aips++ table
[138]174 const casa::Table& table() const { return table_; }
[2]175
[19]176 // return the number of values
[125]177 casa::Int nBeam() const;
178 casa::Int nIF() const;
179 casa::Int nPol() const;
180 casa::Int nChan() const;
[18]181
[22]182 // return the number of rows (integrations) in the table
[125]183 casa::Int nRow() const { return table_.nrow(); }
[22]184
[19]185 // return a row as a Masked array, internally converting uChar flags
186 // to bool mask
[125]187 casa::MaskedArray<casa::Float> rowAsMaskedArray(casa::uInt whichRow,
[206]188 casa::Bool useSelection =
189 casa::False) const;
[19]190
[286]191 // Return SC, setting only the basic construction state (i.e.
[306]192 // no conversion or velocity or rest frequency state).
193 // Specify the index of the FreqID you want
[286]194 casa::SpectralCoordinate getSpectralCoordinate(casa::uInt whichIdx) const;
195
[386]196 // Return SC. Set velocity conversion state (unit,doppler), and
197 // rest frequency. If row number given (>=0), also set
[286]198 // frame conversion layer (needs direction & time which require row)
[386]199 casa::SpectralCoordinate getSpectralCoordinate(casa::uInt freqID,
200 casa::uInt restFreqID,
201 casa::uInt row) const;
[286]202
203 // Set just the reference value, pixel and increment into the table
204 // No other state is extracted.
[125]205 casa::Bool setCoordinate(const casa::SpectralCoordinate& speccord,
206 casa::uInt whichIdx);
[50]207
[125]208 casa::Int nCoordinates() const;
[88]209
[164]210 std::vector<double> getAbcissa(int whichRow=0) const;
211 std::string getAbcissaString(casa::Int whichRow=0) const;
[212]212
[286]213// Get global reference types
[281]214 casa::MDirection::Types getDirectionReference() const;
215 casa::MEpoch::Types getTimeReference() const;
[212]216
[286]217// Get global antenna position
218 casa::MPosition getAntennaPosition() const;
219
[236]220// Helper function to check instrument (antenna) name and give enum
[281]221 static Instrument convertInstrument(const casa::String& instrument,
222 casa::Bool throwIt);
[236]223
[2]224private:
[105]225 // utility func for nice printout
[260]226 casa::String formatSec(casa::Double x) const;
[281]227 casa::String formatDirection(const casa::MDirection& md) const;
[2]228 void setup();
[322]229 void attach();
[380]230 void renumber();
[19]231 // the current cursor into the array
[125]232 casa::Int IFSel_,beamSel_,polSel_;
[88]233 std::vector<bool> chanMask_;
[50]234 // the underlying memory table
[125]235 casa::Table table_;
[322]236
237// Cached Columns to avoid reconstructing them for each row get/put
238 casa::ScalarColumn<casa::Double> timeCol_, integrCol_;
239 casa::ScalarColumn<casa::Float> azCol_, elCol_, paraCol_;
240 casa::ScalarColumn<casa::String> srcnCol_, fldnCol_, tcaltCol_;
241 casa::ScalarColumn<casa::Int> scanCol_, rbeamCol_;
242 casa::ArrayColumn<casa::Float> specCol_, tsCol_, tcalCol_;
243 casa::ArrayColumn<casa::Double> dirCol_;
244 casa::ArrayColumn<casa::uChar> flagsCol_;
[386]245 casa::ArrayColumn<casa::uInt> freqidCol_, restfreqidCol_;
[322]246 casa::ArrayColumn<casa::String> histCol_;
[2]247};
248
249}// namespace
250#endif
Note: See TracBrowser for help on using the repository browser.