source: branches/alma/src/ScantableWrapper.h@ 1667

Last change on this file since 1667 was 1656, checked in by WataruKawasaki, 15 years ago

New Development: Yes

JIRA Issue: Yes (CAS-1433)

Ready to Release: Yes

Interface Changes: Yes

What Interface Changed: functionalities for row-based flagging added

Test Programs:

Put in Release Notes: No

Module(s): sdflag

Description: Added the following functionalities:

sd.scantable._flag_row()

  • to execute row-based flagging

sd.scantable._getflagrow()

  • to get row-based flagging info


  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 7.3 KB
Line 
1//
2// C++ Interface: Scantable
3//
4// Description:
5//
6//
7// Author: Malte Marquarding <asap@atnf.csiro.au>, (C) 2006
8//
9// Copyright: See COPYING file that comes with this distribution
10//
11//
12#ifndef ASAPSCANTABLEWRAPPER_H
13#define ASAPSCANTABLEWRAPPER_H
14
15#include <vector>
16#include <string>
17#include <casa/Arrays/Vector.h>
18
19#include "MathUtils.h"
20#include "STFit.h"
21#include "Scantable.h"
22
23namespace asap {
24/**
25 * This class contains and wraps a CountedPtr<Scantable>, as the CountedPtr
26 * class does not provide the dor operator which is need for references
27 * in boost::python
28 * see Scantable for interfce description
29 *
30 * @brief The main ASAP data container wrapper
31 * @author Malte Marquarding
32 * @date 2006-02-23
33 * @version 2.0a
34*/
35class ScantableWrapper {
36
37public:
38 explicit ScantableWrapper( const std::string& name,
39 int type=0)
40 {
41 casa::Table::TableType tp = casa::Table::Memory;
42 if ( type == 1 ) tp = casa::Table::Plain;
43 table_ = new Scantable(name, tp);
44 }
45
46 explicit ScantableWrapper(int type=0)
47 {
48 casa::Table::TableType tp = casa::Table::Memory;
49 if ( type == 1) tp = casa::Table::Plain;
50 table_= new Scantable(tp);
51 }
52
53 explicit ScantableWrapper(casa::CountedPtr<Scantable> cp) : table_(cp) {;}
54
55 ScantableWrapper(const ScantableWrapper& mt) :
56 table_(mt.getCP()) {;}
57
58 void assign(const ScantableWrapper& mt)
59 { table_= mt.getCP(); }
60
61 ScantableWrapper copy() {
62 return ScantableWrapper(new Scantable(*(this->getCP()), false));
63 }
64
65 std::vector<float> getSpectrum( int whichrow=0,
66 const std::string& poltype="" ) const {
67 return table_->getSpectrum(whichrow, poltype);
68 }
69 // std::string getPolarizationLabel(bool linear, bool stokes, bool linPol, int polIdx) const {
70 // Boost fails with 4 arguments.
71 std::string getPolarizationLabel(int index, const std::string& ptype) const {
72 return table_->getPolarizationLabel(index, ptype);
73 }
74
75 std::vector<double> getAbcissa(int whichrow=0) const
76 { return table_->getAbcissa(whichrow); }
77
78 std::string getAbcissaLabel(int whichrow=0) const
79 { return table_->getAbcissaLabel(whichrow); }
80
81 float getTsys(int whichrow=0) const
82 { return table_->getTsys(whichrow); }
83
84 std::string getTime(int whichrow=0) const
85 { return table_->getTime(whichrow); }
86
87 double getIntTime(int whichrow=0) const
88 { return table_->getIntTime(whichrow); }
89
90 std::string getDirectionString(int whichrow=0) const
91 { return table_->getDirectionString(whichrow); }
92
93 std::string getFluxUnit() const { return table_->getFluxUnit(); }
94
95 void setFluxUnit(const std::string& unit) { table_->setFluxUnit(unit); }
96
97 void setInstrument(const std::string& name) {table_->setInstrument(name);}
98 void setFeedType(const std::string& ftype) {table_->setFeedType(ftype);}
99
100 std::vector<bool> getMask(int whichrow=0) const
101 { return table_->getMask(whichrow); }
102
103 /**
104 void flag(const std::vector<bool>& msk=std::vector<bool>())
105 { table_->flag(msk); }
106 **/
107 void flag(const std::vector<bool>& msk=std::vector<bool>(), bool unflag=false)
108 { table_->flag(msk, unflag); }
109
110 void flagRow(const std::vector<casa::uInt>& rows=std::vector<casa::uInt>(), bool unflag=false)
111 { table_->flagRow(rows, unflag); }
112
113 bool getFlagRow(int whichrow=0) const
114 { return table_->getFlagRow(whichrow); }
115
116 std::string getSourceName(int whichrow=0) const
117 { return table_->getSourceName(whichrow); }
118
119 float getElevation(int whichrow=0) const
120 { return table_->getElevation(whichrow); }
121
122 float getAzimuth(int whichrow=0) const
123 { return table_->getAzimuth(whichrow); }
124
125 float getParAngle(int whichrow=0) const
126 { return table_->getParAngle(whichrow); }
127
128
129 void setSpectrum(std::vector<float> spectrum, int whichrow=0)
130 { table_->setSpectrum(spectrum, whichrow); }
131
132 std::vector<uint> getIFNos() { return table_->getIFNos(); }
133 int getIF(int whichrow) const {return table_->getIF(whichrow);}
134 std::vector<uint> getBeamNos() { return table_->getBeamNos(); }
135 int getBeam(int whichrow) const {return table_->getBeam(whichrow);}
136 std::vector<uint> getPolNos() { return table_->getPolNos(); }
137 int getPol(int whichrow) const {return table_->getPol(whichrow);}
138 int getCycle(int whichrow) const {return table_->getCycle(whichrow);}
139 std::vector<uint> getScanNos() { return table_->getScanNos(); }
140 int getScan(int whichrow) const {return table_->getScan(whichrow);}
141 std::vector<uint> getMolNos() { return table_->getMolNos();}
142
143 STSelector getSelection() const { return table_->getSelection(); }
144 void setSelection(const STSelector& sts)
145 { return table_->setSelection(sts);}
146
147 std::string getPolType() const { return table_->getPolType(); }
148
149 int nif(int scanno=-1) const {return table_->nif(scanno);}
150 int nbeam(int scanno=-1) const {return table_->nbeam(scanno);}
151 int npol(int scanno=-1) const {return table_->npol(scanno);}
152 int nchan(int ifno=-1) const {return table_->nchan(ifno);}
153 int nscan() const {return table_->nscan();}
154 int nrow() const {return table_->nrow();}
155 int ncycle(int scanno) const {return table_->ncycle(scanno);}
156
157 void makePersistent(const std::string& fname)
158 { table_->makePersistent(fname); }
159
160 void setSourceType(int stype)
161 { table_->setSourceType(stype); }
162
163 void shift(int npix)
164 { table_->shift(npix); }
165
166/**
167 commented out by TT
168 void setRestFrequencies(double rf, const std::string& name,
169 const std::string& unit)
170 { table_->setRestFrequencies(rf, name, unit); }
171**/
172 void setRestFrequencies(vector<double> rf, const vector<std::string>& name,
173 const std::string& unit)
174 { table_->setRestFrequencies(rf, name, unit); }
175
176/*
177 void setRestFrequencies(const std::string& name) {
178 table_->setRestFrequencies(name);
179 }
180*/
181
182/*
183 std::vector<double> getRestFrequencies() const
184 { return table_->getRestFrequencies(); }
185*/
186 std::vector<double> getRestFrequency(int id) const
187 { return table_->getRestFrequency(id); }
188
189 void setCoordInfo(std::vector<string> theinfo) {
190 table_->setCoordInfo(theinfo);
191 }
192 std::vector<string> getCoordInfo() const {
193 return table_->getCoordInfo();
194 }
195
196 void setDirection(const std::string& refstr="")
197 { table_->setDirectionRefString(refstr); }
198
199 casa::CountedPtr<Scantable> getCP() const {return table_;}
200 Scantable* getPtr() {return &(*table_);}
201
202 std::string summary(bool verbose=false) const {
203 return table_->summary(verbose);
204 }
205
206 std::vector<std::string> getHistory()const
207 { return table_->getHistory(); }
208
209 void addHistory(const std::string& hist)
210 { table_->addHistory(hist); }
211
212 void addFit(const STFitEntry& fit, int row)
213 { table_->addFit(fit, row); }
214
215 STFitEntry getFit(int whichrow) const
216 { return table_->getFit(whichrow); }
217
218 void calculateAZEL() { table_->calculateAZEL(); };
219
220 std::vector<std::string> columnNames() const
221 { return table_->columnNames(); }
222
223 std::string getAntennaName() const
224 { return table_->getAntennaName(); }
225
226 int checkScanInfo(const vector<int>& scanlist) const
227 { return table_->checkScanInfo(scanlist); }
228
229 std::vector<double> getDirectionVector(int whichrow) const
230 { return table_->getDirectionVector(whichrow); }
231
232 void reshapeSpectrum( int nmin, int nmax )
233 { table_->reshapeSpectrum( nmin, nmax ); }
234
235private:
236 casa::CountedPtr<Scantable> table_;
237};
238
239} // namespace
240#endif
241
Note: See TracBrowser for help on using the repository browser.