source: branches/alma/src/STMath.h@ 1633

Last change on this file since 1633 was 1633, checked in by Takeshi Nakazato, 16 years ago

New Development: No

JIRA Issue: Yes CAS-1422

Ready to Release: Yes

Interface Changes: Yes

What Interface Changed: Defined calibrate() and almacal() in python/asapmath.py

Defined cwcal() in STMath class

Test Programs: List test programs

Put in Release Notes: Yes

Module(s): task_sdaverage

Description: Describe your changes here...

asapmath.py is changed to be able to calibrate data for APEX.
This modification is tentatively considered a calibration of ALMA
single-dish data. However, it must be updated in the future since
I don't know how raw ALMA data are provided and I have to change
code along with read ALMA data.

The calibrate() function takes calibration mode from its argument and
looks antenna name of the input scantable, and calls appropriate calibration
function depending on the calibration mode and antenna name.
If antenna name include 'APEX' or 'ALMA', newly defined calibration function
apexcal() is called. For other antenna name, one of the existing calibration
functions (calps, calnod, calfs, auto_quotient) is called.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 15.1 KB
Line 
1//
2// C++ Interface: STMath
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 ASAPSTMATH_H
13#define ASAPSTMATH_H
14
15#include <string>
16#include <map>
17
18#include <casa/aips.h>
19#include <casa/Utilities/CountedPtr.h>
20#include <casa/BasicSL/String.h>
21#include <casa/Arrays/Vector.h>
22#include <scimath/Mathematics/InterpolateArray1D.h>
23
24#include "Scantable.h"
25#include "STDefs.h"
26#include "STPol.h"
27#include "Logger.h"
28
29namespace asap {
30
31/**
32 * Mathmatical operations on Scantable objects
33 * @author Malte Marquarding
34*/
35class STMath : private Logger {
36public:
37 // typedef for long method name
38 typedef casa::InterpolateArray1D<casa::Double,
39 casa::Float>::InterpolationMethod imethod;
40
41 // typedef for std::map
42 typedef std::map<std::string, imethod> imap;
43
44/**
45 * whether to operate on the given Scantable or return a new one
46 * @param insitu the toggle for this behaviour
47 */
48 explicit STMath(bool insitu=true);
49
50 virtual ~STMath();
51
52 /**
53 * get the currnt @attr inistu_ state
54 */
55 bool insitu() const { return insitu_;};
56
57 /**
58 * set the currnt @attr inistu state
59 * @param b the new state
60 */
61 void setInsitu(bool b) { insitu_ = b; };
62
63
64 /**
65 * average a vector of Scantables
66 * @param in the vector of Scantables to average
67 * @param mask an optional mask to apply on specific weights
68 * @param weight weighting scheme
69 * @param avmode the mode ov averaging. Per "SCAN" or "ALL".
70 * @return a casa::CountedPtr<Scantable> which either holds a new Scantable
71 * or returns the imput pointer.
72 */
73 casa::CountedPtr<Scantable>
74 average( const std::vector<casa::CountedPtr<Scantable> >& in,
75 const std::vector<bool>& mask = std::vector<bool>(),
76 const std::string& weight = "NONE",
77 const std::string& avmode = "SCAN");
78
79 /**
80 * median average a vector of Scantables. See also STMath::average
81 * @param in the Scantable to average
82 * @param mode the averaging mode. Currently only "MEDIAN"
83 * @param avmode the mode ov averaging. Per "SCAN" or "ALL".
84 * @return a casa::CountedPtr<Scantable> which either holds a new Scantable
85 * or returns the imput pointer.
86 */
87 casa::CountedPtr<Scantable>
88 averageChannel( const casa::CountedPtr<Scantable> & in,
89 const std::string& mode = "MEDIAN",
90 const std::string& avmode = "SCAN");
91
92 /**
93 * Average polarisations together. really only useful if only linears are
94 * available.
95 * @param in the input Scantable
96 * @param mask an optional mask if weight allows one
97 * @param weight weighting scheme
98 * @return
99 */
100 casa::CountedPtr< Scantable >
101 averagePolarisations( const casa::CountedPtr< Scantable > & in,
102 const std::vector<bool>& mask,
103 const std::string& weight );
104
105 /**
106 * Average beams together.
107 * @param in the input Scantable
108 * @param mask an optional mask if weight allows one
109 * @param weight weighting scheme
110 * @return
111 */
112 casa::CountedPtr< Scantable >
113 averageBeams( const casa::CountedPtr< Scantable > & in,
114 const std::vector<bool>& mask,
115 const std::string& weight );
116
117 casa::CountedPtr<Scantable>
118 unaryOperate( const casa::CountedPtr<Scantable>& in, float val,
119 const std::string& mode, bool tsys=false );
120
121 casa::CountedPtr<Scantable>
122 binaryOperate( const casa::CountedPtr<Scantable>& left,
123 const casa::CountedPtr<Scantable>& right,
124 const std::string& mode);
125
126 casa::CountedPtr<Scantable> autoQuotient(const casa::CountedPtr<Scantable>& in,
127 const std::string& mode = "NEAREST",
128 bool preserve = true);
129
130 casa::CountedPtr<Scantable> quotient( const casa::CountedPtr<Scantable>& on,
131 const casa::CountedPtr<Scantable>& off,
132 bool preserve = true );
133
134 /**
135 * Calibrate total power scans (translated from GBTIDL)
136 * @param calon uncalibrated Scantable with CAL noise signal
137 * @param caloff uncalibrated Scantable with no CAL signal
138 * @param tcal optional scalar Tcal, CAL temperature (K)
139 * @return casa::CountedPtr<Scantable> which holds a calibrated Scantable
140 * (spectrum - average of the two CAL on and off spectra;
141 * tsys - mean Tsys = <caloff>*Tcal/<calon-caloff> + Tcal/2)
142 */
143 casa::CountedPtr<Scantable> dototalpower( const casa::CountedPtr<Scantable>& calon,
144 const casa::CountedPtr<Scantable>& caloff,
145 casa::Float tcal=1.0 );
146
147 /**
148 * Combine signal and reference scans (translated from GBTIDL)
149 * @param sig Scantable which contains signal scans
150 * @param ref Scantable which contains reference scans
151 * @param smoothref optional Boxcar smooth width of the reference scans
152 * default: no smoothing (=1)
153 * @param tsysv optional scalar Tsys value at the zenith, required to
154 * set tau, as well
155 * @param tau optional scalar Tau value
156 * @return casa::CountedPtr<Scantable> which holds combined scans
157 * (spectrum = (sig-ref)/ref * Tsys )
158 */
159 casa::CountedPtr<Scantable> dosigref( const casa::CountedPtr<Scantable>& sig,
160 const casa::CountedPtr<Scantable>& ref,
161 int smoothref=1,
162 casa::Float tsysv=0.0,
163 casa::Float tau=0.0 );
164
165 /**
166 * Calibrate GBT Nod scan pairs (translated from GBTIDL)
167 * @param s Scantable which contains Nod scans
168 * @param scans Vector of scan numbers
169 * @param smoothref optional Boxcar smooth width of the reference scans
170 * @param tsysv optional scalar Tsys value at the zenith, required to
171 * set tau, as well
172 * @param tau optional scalar Tau value
173 * @param tcal optional scalar Tcal, CAL temperature (K)
174 * @return casa::CountedPtr<Scantable> which holds calibrated scans
175 */
176 casa::CountedPtr<Scantable> donod( const casa::CountedPtr<Scantable>& s,
177 const std::vector<int>& scans,
178 int smoothref=1,
179 casa::Float tsysv=0.0,
180 casa::Float tau=0.0,
181 casa::Float tcal=0.0 );
182
183 /**
184 * Calibrate frequency switched scans (translated from GBTIDL)
185 * @param s Scantable which contains frequency switched scans
186 * @param scans Vector of scan numbers
187 * @param smoothref optional Boxcar smooth width of the reference scans
188 * @param tsysv optional scalar Tsys value at the zenith, required to
189 * set tau, as well
190 * @param tau optional scalar Tau value
191 * @param tcal optional scalar Tcal, CAL temperature (K)
192 * @return casa::CountedPtr<Scantable> which holds calibrated scans
193 */
194 casa::CountedPtr<Scantable> dofs( const casa::CountedPtr<Scantable>& s,
195 const std::vector<int>& scans,
196 int smoothref=1,
197 casa::Float tsysv=0.0,
198 casa::Float tau=0.0,
199 casa::Float tcal=0.0 );
200
201 /**
202 * Calibrate data with Chopper-Wheel like calibration method
203 * which adopts position switching by antenna motion,
204 * wobbler (nutator) switching and On-The-Fly observation.
205 *
206 * The method is applicable to APEX, and other telescopes other than GBT.
207 *
208 * @param a Scantable which contains ON and OFF scans
209 * @param a string that indicates calibration mode
210 * @param a string that indicates antenna name
211 **/
212 casa::CountedPtr<Scantable> cwcal( const casa::CountedPtr<Scantable>& s,
213 const casa::String calmode,
214 const casa::String antname );
215
216 /**
217 * Calibrate frequency switched scans with Chopper-Wheel like
218 * calibration method.
219 *
220 * The method is applicable to APEX, and other telescopes other than GBT.
221 *
222 * @param a Scantable which contains ON and OFF scans
223 * @param a string that indicates antenna name
224 **/
225 casa::CountedPtr<Scantable> cwcalfs( const casa::CountedPtr<Scantable>& s,
226 const casa::String antname );
227
228
229 /**
230 * Folding frequency-switch data
231 * @param sig
232 * @param ref
233 * @param choffset
234 **/
235 casa::CountedPtr<Scantable> dofold( const casa::CountedPtr<Scantable> &sig,
236 const casa::CountedPtr<Scantable> &ref,
237 casa::Double choffset,
238 casa::Double choffset = 0.0 );
239
240 casa::CountedPtr<Scantable>
241 freqSwitch( const casa::CountedPtr<Scantable>& in );
242
243 std::vector<float> statistic(const casa::CountedPtr<Scantable>& in,
244 const std::vector<bool>& mask,
245 const std::string& which);
246
247 std::vector< int > minMaxChan(const casa::CountedPtr<Scantable>& in,
248 const std::vector<bool>& mask,
249 const std::string& which);
250
251 casa::CountedPtr<Scantable> bin( const casa::CountedPtr<Scantable>& in,
252 int width=5);
253 casa::CountedPtr<Scantable>
254 resample(const casa::CountedPtr<Scantable>& in,
255 const std::string& method, float width);
256
257 casa::CountedPtr<Scantable>
258 smooth(const casa::CountedPtr<Scantable>& in, const std::string& kernel,
259 float width);
260
261 casa::CountedPtr<Scantable>
262 gainElevation(const casa::CountedPtr<Scantable>& in,
263 const std::vector<float>& coeff,
264 const std::string& fileName,
265 const std::string& method);
266 casa::CountedPtr<Scantable>
267 convertFlux(const casa::CountedPtr<Scantable>& in, float d,
268 float etaap, float jyperk);
269
270 casa::CountedPtr<Scantable> opacity(const casa::CountedPtr<Scantable>& in,
271 float tau);
272
273 casa::CountedPtr<Scantable>
274 merge(const std::vector<casa::CountedPtr<Scantable> >& in);
275
276 casa::CountedPtr<Scantable>
277 invertPhase( const casa::CountedPtr<Scantable>& in);
278
279 casa::CountedPtr<Scantable>
280 rotateXYPhase( const casa::CountedPtr<Scantable>& in, float phase);
281
282 casa::CountedPtr<Scantable>
283 rotateLinPolPhase( const casa::CountedPtr<Scantable>& in, float phase);
284
285 casa::CountedPtr<Scantable>
286 swapPolarisations(const casa::CountedPtr<Scantable>& in);
287
288 casa::CountedPtr<Scantable>
289 frequencyAlign( const casa::CountedPtr<Scantable>& in,
290 const std::string& refTime = "",
291 const std::string& method = "cubic" );
292
293 casa::CountedPtr<Scantable>
294 convertPolarisation( const casa::CountedPtr<Scantable>& in,
295 const std::string& newtype);
296
297 casa::CountedPtr<Scantable>
298 mxExtract( const casa::CountedPtr<Scantable>& in,
299 const std::string& srctype = "on");
300
301 /**
302 * "hard" flag the data, this flags everything selected in setSelection()
303 * @param frequency the frequency to remove
304 * @param width the number of lags to flag left to the side of the frequency
305 */
306 casa::CountedPtr<Scantable>
307 lagFlag( const casa::CountedPtr<Scantable>& in, double frequency,
308 double width);
309
310 // test for average spectra with different channel/resolution
311 casa::CountedPtr<Scantable>
312 new_average( const std::vector<casa::CountedPtr<Scantable> >& in,
313 const bool& compel,
314 const std::vector<bool>& mask = std::vector<bool>(),
315 const std::string& weight = "NONE",
316 const std::string& avmode = "SCAN" )
317 throw (casa::AipsError) ;
318
319
320private:
321 casa::CountedPtr<Scantable> applyToPol( const casa::CountedPtr<Scantable>& in,
322 STPol::polOperation fptr,
323 casa::Float phase);
324
325 static imethod stringToIMethod(const std::string& in);
326 static WeightType stringToWeight(const std::string& in);
327
328 void scaleByVector(casa::Table& in,
329 const casa::Vector<casa::Float>& factor,
330 bool dotsys);
331
332 void scaleFromAsciiTable(casa::Table& in, const std::string& filename,
333 const std::string& method,
334 const casa::Vector<casa::Float>& xout,
335 bool dotsys);
336
337 void scaleFromTable(casa::Table& in, const casa::Table& table,
338 const std::string& method,
339 const casa::Vector<casa::Float>& xout, bool dotsys);
340
341 void convertBrightnessUnits(casa::CountedPtr<Scantable>& in,
342 bool tokelvin, float cfac);
343
344 casa::CountedPtr< Scantable >
345 smoothOther( const casa::CountedPtr< Scantable >& in,
346 const std::string& kernel,
347 float width );
348
349 casa::CountedPtr< Scantable >
350 getScantable(const casa::CountedPtr< Scantable >& in, bool droprows);
351
352 casa::MaskedArray<casa::Float>
353 maskedArray( const casa::Vector<casa::Float>& s,
354 const casa::Vector<casa::uChar>& f );
355 casa::MaskedArray<casa::Double>
356 maskedArray( const casa::Vector<casa::Double>& s,
357 const casa::Vector<casa::uChar>& f );
358 casa::Vector<casa::uChar>
359 flagsFromMA(const casa::MaskedArray<casa::Float>& ma);
360
361 vector<float> getSpectrumFromTime( string reftime, casa::CountedPtr<Scantable>& s, string mode = "before" ) ;
362 vector<float> getTcalFromTime( string reftime, casa::CountedPtr<Scantable>& s, string mode="before" ) ;
363 vector<int> getRowIdFromTime( string reftime, casa::CountedPtr<Scantable>& s ) ;
364 vector<float> getCalibratedSpectra( casa::CountedPtr<Scantable>& on,
365 casa::CountedPtr<Scantable>& off,
366 casa::CountedPtr<Scantable>& sky,
367 casa::CountedPtr<Scantable>& hot,
368 casa::CountedPtr<Scantable>& cold,
369 int index,
370 string antname ) ;
371 vector<float> getFSCalibratedSpectra( casa::CountedPtr<Scantable>& sig,
372 casa::CountedPtr<Scantable>& ref,
373 casa::CountedPtr<Scantable>& sky,
374 casa::CountedPtr<Scantable>& hot,
375 casa::CountedPtr<Scantable>& cold,
376 int index ) ;
377 vector<float> getFSCalibratedSpectra( casa::CountedPtr<Scantable>& sig,
378 casa::CountedPtr<Scantable>& ref,
379 vector< casa::CountedPtr<Scantable> >& sky,
380 vector< casa::CountedPtr<Scantable> >& hot,
381 vector< casa::CountedPtr<Scantable> >& cold,
382 int index ) ;
383 double getMJD( string strtime ) ;
384
385 bool insitu_;
386};
387
388}
389#endif
Note: See TracBrowser for help on using the repository browser.