source: trunk/src/SDMemTable.h@ 245

Last change on this file since 245 was 236, checked in by kil064, 20 years ago

add set_instrumenbt function
and helper function convertInstrument

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 6.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++
[236]38 #include <casa/aips.h>
[80]39#include <casa/BasicSL/String.h>
40#include <tables/Tables/Table.h>
41#include <casa/Arrays/MaskedArray.h>
[236]42#include "SDDefs.h"
[2]43
[80]44#include <coordinates/Coordinates/SpectralCoordinate.h>
[39]45
[83]46namespace asap {
[2]47
48class SDContainer;
49class SDHeader;
50class SDFrequencyTable;
51
52
53class SDMemTable {
54public:
[19]55 // create a new (empty) SDMemTable
[18]56 SDMemTable();
[50]57 // create a SDMemTable from an (aips++) table on disk
[18]58 SDMemTable(const std::string& name);
[19]59
60 // Copy Construct a SDMemTable, if clear==True only header and
61 // skeleton are copied, otherwise the whole table is copied.
[147]62 SDMemTable(const SDMemTable& other, casa::Bool clear=casa::False);
[2]63
[161]64 // Copy Construct (copy semantics) a SDMemTable, give a scanid constraint
[19]65 // see also getScan()
[125]66 SDMemTable(const casa::Table& tab, const std::string& expr);
[161]67
68 // Assignment operator (copy semantics)
[138]69 SDMemTable &operator=(const SDMemTable& other);
70
[2]71 virtual ~SDMemTable();
[19]72
73 // put data from meta conatiner into the table
[39]74 bool putSDContainer(const SDContainer& sdc);
75 bool putSDHeader(const SDHeader& sdh);
76 bool putSDFreqTable(const SDFrequencyTable& sdft);
[21]77
[161]78 //get the data wrapped up in a meta container
[125]79 SDContainer getSDContainer(casa::uInt whichRow=0) const;
[39]80 SDHeader getSDHeader() const;
81 SDFrequencyTable getSDFreqTable() const;
[19]82 // get spectrum,mask and tsys for the given row, at the selected
[21]83 // cursor - all as stl vectors
[125]84 virtual std::vector<float> getSpectrum(casa::Int whichRow=0) const;
85 virtual std::vector<bool> getMask(casa::Int whichRow=0) const;
[21]86
[125]87 virtual casa::Float getTsys(casa::Int whichRow=0) const;
[21]88 // get all as aips++ Vectors
[125]89 virtual void getSpectrum(casa::Vector<casa::Float>& spectrum,
[164]90 casa::Int whichRow=0) const;
[2]91
[88]92 //virtual void getMask(Vector<Bool>& mask,Int whichRow=0) const;
93
[21]94 // get info for current row
[125]95 std::string getTime(casa::Int whichRow=0) const ;
96 std::string getSourceName(casa::Int whichRow=0) const;
97 double getInterval(casa::Int whichRow=0) const;
[50]98
[88]99 virtual void setSpectrum(std::vector<float> spectrum, int whichRow=0);
[125]100 virtual void setRestFreqs(std::vector<double> freqs,
101 const std::string& theunit);
[105]102 virtual void setCoordInfo(std::vector<string> theinfo);
[206]103
[218]104// Get/Set flux unit
[206]105 std::string getFluxUnit() const;
[218]106 void setFluxUnit (const std::string& unit);
[206]107
[236]108// Set Instrument
109 void setInstrument (const std::string& instrument);
110
[19]111 // set the current value
[125]112 virtual bool setIF(casa::Int whichIF=0);
113 virtual bool setBeam(casa::Int whichBeam=0);
114 virtual bool setPol(casa::Int whichPol=0);
[88]115
116 //sets the user mask applied to all spectra
[68]117 virtual bool setMask(std::vector<int> whichChans);
[88]118 // Hard flags the current spectrum, not reversible
119 virtual void flag(int whichRow);
120
[19]121 // return the currently selected values
[154]122 virtual casa::Int getIF() const { return IFSel_; }
123 virtual casa::Int getBeam() const { return beamSel_; }
124 virtual casa::Int getPol() const { return polSel_; }
[206]125 virtual std::vector<std::string> getCoordInfo() const;
[88]126
[50]127 // number of scans in table
[125]128 virtual casa::Int nScan() const;
[50]129
[206]130 // get a summary of the table
[105]131 virtual std::string summary();
[88]132
[206]133 std::vector<std::string> history(int whichRow=0) const;
134 bool appendHistory(const std::string& hist, int whichRow=0);
[19]135 // write to disk as aips++ table
[2]136 void makePersistent(const std::string& filename);
[19]137
[88]138 // get a new SDMemTable containing all rows with the same give SCANID
[164]139 SDMemTable getScan(casa::Int scanID) const;
140 SDMemTable getSource(const std::string& source) const;
[18]141
[125]142 const casa::TableRecord& getHeader() const {return table_.keywordSet();}
[19]143 // get a handle to the "raw" aips++ table
[138]144 const casa::Table& table() const { return table_; }
[2]145
[19]146 // return the number of values
[125]147 casa::Int nBeam() const;
148 casa::Int nIF() const;
149 casa::Int nPol() const;
150 casa::Int nChan() const;
[18]151
[22]152 // return the number of rows (integrations) in the table
[125]153 casa::Int nRow() const { return table_.nrow(); }
[22]154
[19]155 // return a row as a Masked array, internally converting uChar flags
156 // to bool mask
[125]157 casa::MaskedArray<casa::Float> rowAsMaskedArray(casa::uInt whichRow,
[206]158 casa::Bool useSelection =
159 casa::False) const;
[19]160
[125]161 casa::SpectralCoordinate getCoordinate(casa::uInt whichIdx) const;
162 casa::Bool setCoordinate(const casa::SpectralCoordinate& speccord,
163 casa::uInt whichIdx);
[50]164
[125]165 casa::Int nCoordinates() const;
[88]166
[206]167
[164]168 std::vector<double> getAbcissa(int whichRow=0) const;
169 std::string getAbcissaString(casa::Int whichRow=0) const;
[212]170
171// Get MDirection for this row
[206]172 casa::MDirection getDirection(casa::Int whichRow=0) const;
[105]173
[212]174// Get gloabl Direction reference
175 casa::MDirection::Types getDirectionReference () const;
176
177// Get global Time reference
178 casa::MEpoch::Types getTimeReference () const;
179
[236]180// Helper function to check instrument (antenna) name and give enum
181 static Instrument convertInstrument (const casa::String& instrument,
182 casa::Bool throwIt);
183
[2]184private:
[105]185 // utility func for nice printout
[125]186 casa::String formatSec(casa::Double x);
[2]187 void setup();
[19]188 // the current cursor into the array
[125]189 casa::Int IFSel_,beamSel_,polSel_;
[88]190 std::vector<bool> chanMask_;
[50]191 // the underlying memory table
[125]192 casa::Table table_;
[2]193};
194
195}// namespace
196#endif
Note: See TracBrowser for help on using the repository browser.