source: trunk/src/ScantableWrapper.h@ 2016

Last change on this file since 2016 was 2012, checked in by WataruKawasaki, 14 years ago

New Development: Yes

JIRA Issue: Yes (CAS-2373, CAS-2620)

Ready for Test: Yes

Interface Changes: Yes

What Interface Changed: For Scantable::polyBaseline(), parameters and return value have been changed.

Test Programs:

Put in Release Notes: Yes

Module(s): sdbaseline, sd.linefinder

Description: (1) CAS-2373-related:

(1.1) Modified Scantable::polyBaseline() to have the row-based loop inside.

Now it fits and subtracts baseline for all rows and also output info
about the fitting result to logger and text file, while in the
previous version this method just did baseline fitting/subtraction
for one row only and had to be put inside a row-based loop at the
python side ("poly_baseline()" in scantable.py) and result output had
also to be controlled at the python side. Using a test data from NRO
45m telescope (348,000 rows, 512 channels), the processing time of
scantable.poly_baseline() has reduced from 130 minutes to 5-6 minutes.

(1.2) For accelerating the another polynomial fitting function, namely

scantable.auto_poly_baseline(), added a method
Scantable::autoPolyBaseline(). This basically does the same thing
with Scantable::polyBaseline(), but uses linefinfer also to
automatically flag the line regions.

(1.3) To make linefinder usable in Scantable class, added a method

linefinder.setdata(). This makes it possible to apply linefinder
for a float-list data given as a parameter, without setting scantable,
while it was indispensable to set scantable to use linefinger previously.

(2) CAS-2620-related:

Added Scantable::cubicSplineBaseline() and autoCubicSplineBaseline() for
fit baseline using the cubic spline function. Parameters include npiece
(number of polynomial pieces), clipthresh (clipping threshold), and
clipniter (maximum iteration number).



  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 10.0 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 "STFitEntry.h"
22#include "Scantable.h"
23#include "STCoordinate.h"
24
25namespace asap {
26/**
27 * This class contains and wraps a CountedPtr<Scantable>, as the CountedPtr
28 * class does not provide the dor operator which is need for references
29 * in boost::python
30 * see Scantable for interfce description
31 *
32 * @brief The main ASAP data container wrapper
33 * @author Malte Marquarding
34 * @date 2006-02-23
35 * @version 2.0a
36*/
37class ScantableWrapper {
38
39public:
40 explicit ScantableWrapper( const std::string& name,
41 int type=0)
42 {
43 casa::Table::TableType tp = casa::Table::Memory;
44 if ( type == 1 ) tp = casa::Table::Plain;
45 table_ = new Scantable(name, tp);
46 }
47
48 explicit ScantableWrapper(int type=0)
49 {
50 casa::Table::TableType tp = casa::Table::Memory;
51 if ( type == 1) tp = casa::Table::Plain;
52 table_= new Scantable(tp);
53 }
54
55 explicit ScantableWrapper(casa::CountedPtr<Scantable> cp) : table_(cp) {;}
56
57 ScantableWrapper(const ScantableWrapper& mt) :
58 table_(mt.getCP()) {;}
59
60 void assign(const ScantableWrapper& mt)
61 { table_= mt.getCP(); }
62
63 ScantableWrapper copy() {
64 return ScantableWrapper(new Scantable(*(this->getCP()), false));
65 }
66
67 std::vector<float> getSpectrum( int whichrow=0,
68 const std::string& poltype="" ) const {
69 return table_->getSpectrum(whichrow, poltype);
70 }
71 // std::string getPolarizationLabel(bool linear, bool stokes, bool linPol, int polIdx) const {
72 // Boost fails with 4 arguments.
73 std::string getPolarizationLabel(int index, const std::string& ptype) const {
74 return table_->getPolarizationLabel(index, ptype);
75 }
76
77 std::vector<double> getAbcissa(int whichrow=0) const
78 { return table_->getAbcissa(whichrow); }
79
80 std::string getAbcissaLabel(int whichrow=0) const
81 { return table_->getAbcissaLabel(whichrow); }
82
83 float getTsys(int whichrow=0) const
84 { return table_->getTsys(whichrow); }
85
86 //std::string getTime(int whichrow=0) const
87 // { return table_->getTime(whichrow); }
88 std::string getTime(int whichrow=0, int prec = 0) const
89 { return table_->getTime(whichrow, true, casa::uInt(prec)); }
90
91 double getIntTime(int whichrow=0) const
92 { return table_->getIntTime(whichrow); }
93
94 std::string getDirectionString(int whichrow=0) const
95 { return table_->getDirectionString(whichrow); }
96
97 std::string getFluxUnit() const { return table_->getFluxUnit(); }
98
99 void setFluxUnit(const std::string& unit) { table_->setFluxUnit(unit); }
100
101 void setInstrument(const std::string& name) {table_->setInstrument(name);}
102 void setFeedType(const std::string& ftype) {table_->setFeedType(ftype);}
103
104 std::vector<bool> getMask(int whichrow=0) const
105 { return table_->getMask(whichrow); }
106
107 /**
108 void flag(const std::vector<bool>& msk=std::vector<bool>())
109 { table_->flag(msk); }
110 **/
111 /**
112 void flag(const std::vector<bool>& msk=std::vector<bool>(), bool unflag=false)
113 { table_->flag(msk, unflag); }
114 **/
115 void flag(int whichrow=-1, const std::vector<bool>& msk=std::vector<bool>(), bool unflag=false)
116 { table_->flag(whichrow, msk, unflag); }
117
118 void flagRow(const std::vector<casa::uInt>& rows=std::vector<casa::uInt>(), bool unflag=false)
119 { table_->flagRow(rows, unflag); }
120
121 bool getFlagRow(int whichrow=0) const
122 { return table_->getFlagRow(whichrow); }
123
124 void clip(const casa::Float uthres, const casa::Float dthres, bool clipoutside=true, bool unflag=false)
125 { table_->clip(uthres, dthres, clipoutside, unflag); }
126
127 std::vector<bool> getClipMask(int whichrow, const casa::Float uthres, const casa::Float dthres, bool clipoutside, bool unflag) const
128 { return table_->getClipMask(whichrow, uthres, dthres, clipoutside, unflag); }
129
130 std::string getSourceName(int whichrow=0) const
131 { return table_->getSourceName(whichrow); }
132
133 float getElevation(int whichrow=0) const
134 { return table_->getElevation(whichrow); }
135
136 float getAzimuth(int whichrow=0) const
137 { return table_->getAzimuth(whichrow); }
138
139 float getParAngle(int whichrow=0) const
140 { return table_->getParAngle(whichrow); }
141
142
143 void setSpectrum(std::vector<float> spectrum, int whichrow=0)
144 { table_->setSpectrum(spectrum, whichrow); }
145
146 std::vector<uint> getIFNos() { return table_->getIFNos(); }
147 int getIF(int whichrow) const {return table_->getIF(whichrow);}
148 std::vector<uint> getBeamNos() { return table_->getBeamNos(); }
149 int getBeam(int whichrow) const {return table_->getBeam(whichrow);}
150 std::vector<uint> getPolNos() { return table_->getPolNos(); }
151 int getPol(int whichrow) const {return table_->getPol(whichrow);}
152 int getCycle(int whichrow) const {return table_->getCycle(whichrow);}
153 std::vector<uint> getScanNos() { return table_->getScanNos(); }
154 int getScan(int whichrow) const {return table_->getScan(whichrow);}
155 std::vector<uint> getMolNos() { return table_->getMolNos();}
156
157 STSelector getSelection() const { return table_->getSelection(); }
158 void setSelection(const STSelector& sts)
159 { return table_->setSelection(sts);}
160
161 std::string getPolType() const { return table_->getPolType(); }
162
163 int nif(int scanno=-1) const {return table_->nif(scanno);}
164 int nbeam(int scanno=-1) const {return table_->nbeam(scanno);}
165 int npol(int scanno=-1) const {return table_->npol(scanno);}
166 int nchan(int ifno=-1) const {return table_->nchan(ifno);}
167 int nscan() const {return table_->nscan();}
168 int nrow() const {return table_->nrow();}
169 int ncycle(int scanno) const {return table_->ncycle(scanno);}
170
171 void makePersistent(const std::string& fname)
172 { table_->makePersistent(fname); }
173
174 void setSourceType(int stype)
175 { table_->setSourceType(stype); }
176
177 void shift(int npix)
178 { table_->shift(npix); }
179
180/**
181 commented out by TT
182 void setRestFrequencies(double rf, const std::string& name,
183 const std::string& unit)
184 { table_->setRestFrequencies(rf, name, unit); }
185**/
186 void setRestFrequencies(vector<double> rf, const vector<std::string>& name,
187 const std::string& unit)
188 { table_->setRestFrequencies(rf, name, unit); }
189
190/*
191 void setRestFrequencies(const std::string& name) {
192 table_->setRestFrequencies(name);
193 }
194*/
195
196/*
197 std::vector<double> getRestFrequencies() const
198 { return table_->getRestFrequencies(); }
199*/
200 std::vector<double> getRestFrequency(int id) const
201 { return table_->getRestFrequency(id); }
202
203 void setCoordInfo(std::vector<string> theinfo) {
204 table_->setCoordInfo(theinfo);
205 }
206 std::vector<string> getCoordInfo() const {
207 return table_->getCoordInfo();
208 }
209
210 void setDirection(const std::string& refstr="")
211 { table_->setDirectionRefString(refstr); }
212
213 casa::CountedPtr<Scantable> getCP() const {return table_;}
214 Scantable* getPtr() {return &(*table_);}
215
216 std::string summary(bool verbose=false) const {
217 return table_->summary(verbose);
218 }
219
220 std::vector<std::string> getHistory()const
221 { return table_->getHistory(); }
222
223 void addHistory(const std::string& hist)
224 { table_->addHistory(hist); }
225
226 void addFit(const STFitEntry& fit, int row)
227 { table_->addFit(fit, row); }
228
229 STFitEntry getFit(int whichrow) const
230 { return table_->getFit(whichrow); }
231
232 void calculateAZEL() { table_->calculateAZEL(); }
233
234 std::vector<std::string> columnNames() const
235 { return table_->columnNames(); }
236
237 std::string getAntennaName() const
238 { return table_->getAntennaName(); }
239
240 int checkScanInfo(const vector<int>& scanlist) const
241 { return table_->checkScanInfo(scanlist); }
242
243 std::vector<double> getDirectionVector(int whichrow) const
244 { return table_->getDirectionVector(whichrow); }
245
246 void parallactify(bool flag)
247 { table_->parallactify(flag); }
248
249 STCoordinate getCoordinate(int row) {
250 return STCoordinate(table_->getSpectralCoordinate(row));
251 }
252
253 std::vector<float> getWeather(int whichrow) const
254 { return table_->getWeather(whichrow); }
255
256 void reshapeSpectrum( int nmin, int nmax )
257 { table_->reshapeSpectrum( nmin, nmax ); }
258
259 void polyBaseline(const std::vector<bool>& mask, int order, bool outlog=false, const std::string& blfile="")
260 { table_->polyBaseline(mask, order, outlog, blfile); }
261
262 void autoPolyBaseline(const std::vector<bool>& mask, int order, const std::vector<int>& edge, float threshold=5.0, int chan_avg_limit=1, bool outlog=false, const std::string& blfile="")
263 { table_->autoPolyBaseline(mask, order, edge, threshold, chan_avg_limit, outlog, blfile); }
264
265 void cubicSplineBaseline(const std::vector<bool>& mask, int npiece, float clipthresh, int clipniter, bool outlog=false, const std::string& blfile="")
266 { table_->cubicSplineBaseline(mask, npiece, clipthresh, clipniter, outlog, blfile); }
267
268 void autoCubicSplineBaseline(const std::vector<bool>& mask, int npiece, float clipthresh, int clipniter, const std::vector<int>& edge, float threshold=5.0, int chan_avg_limit=1, bool outlog=false, const std::string& blfile="")
269 { table_->autoCubicSplineBaseline(mask, npiece, clipthresh, clipniter, edge, threshold, chan_avg_limit, outlog, blfile); }
270
271 float getRms(const std::vector<bool>& mask, int whichrow)
272 { return table_->getRms(mask, whichrow); }
273
274 std::string formatBaselineParams(const std::vector<float>& params, const std::vector<bool>& fixed, float rms, const std::string& masklist, int whichrow, bool verbose=false)
275 { return table_->formatBaselineParams(params, fixed, rms, masklist, whichrow, verbose); }
276
277 std::string formatPiecewiseBaselineParams(const std::vector<int>& ranges, const std::vector<float>& params, const std::vector<bool>& fixed, float rms, const std::string& masklist, int whichrow, bool verbose=false)
278 { return table_->formatPiecewiseBaselineParams(ranges, params, fixed, rms, masklist, whichrow, verbose); }
279
280 bool getFlagtraFast(int whichrow=0) const
281 { return table_->getFlagtraFast(whichrow); }
282
283
284
285private:
286 casa::CountedPtr<Scantable> table_;
287};
288
289} // namespace
290#endif
291
Note: See TracBrowser for help on using the repository browser.