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

Last change on this file since 1728 was 1680, checked in by Takeshi Nakazato, 15 years ago

New Development: No

JIRA Issue: Yes CAS-1823

Ready to Release: Yes

Interface Changes: No

What Interface Changed: Please list interface changes

Test Programs: List test programs

Put in Release Notes: Yes/No

Module(s): Module Names change impacts.

Description: Describe your changes here...

  1. Bug fix

In scantable.py, self._math = stmath() should be
self._math = stmath( rcParamsinsitu ).

  1. Delete operation mode

I have deleted operation mode parameter which is used for a function
to do an operation of scantable with 1D list, since I have implemented
the operation of scantable with 2D list.

  1. Extend operation of scantable

Now, operation of scantable with 2D list is available.

  1. Accept integer input for operation

Operation of scantable with int as well as int list is working
in addition to operation with float or float list.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 16.7 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 // array operation
122 casa::CountedPtr<Scantable>
123 arrayOperate( const casa::CountedPtr<Scantable>& in,
124 const std::vector<float> val,
125 const std::string& mode,
126 const std::string& opmode="channel",
127 bool tsys=false );
128
129 // channel operation
130 casa::CountedPtr<Scantable>
131 arrayOperateChannel( const casa::CountedPtr<Scantable>& in,
132 const std::vector<float> val,
133 const std::string& mode, bool tsys=false );
134
135 // row operation
136 casa::CountedPtr<Scantable>
137 arrayOperateRow( const casa::CountedPtr<Scantable>& in,
138 const std::vector<float> val,
139 const std::string& mode, bool tsys=false );
140
141 // 2d array operation
142 casa::CountedPtr<Scantable>
143 array2dOperate( const casa::CountedPtr<Scantable>& in,
144 const std::vector< std::vector<float> > val,
145 const std::string& mode, bool tsys=false );
146
147 casa::CountedPtr<Scantable>
148 binaryOperate( const casa::CountedPtr<Scantable>& left,
149 const casa::CountedPtr<Scantable>& right,
150 const std::string& mode);
151
152 casa::CountedPtr<Scantable> autoQuotient(const casa::CountedPtr<Scantable>& in,
153 const std::string& mode = "NEAREST",
154 bool preserve = true);
155
156 casa::CountedPtr<Scantable> quotient( const casa::CountedPtr<Scantable>& on,
157 const casa::CountedPtr<Scantable>& off,
158 bool preserve = true );
159
160 /**
161 * Calibrate total power scans (translated from GBTIDL)
162 * @param calon uncalibrated Scantable with CAL noise signal
163 * @param caloff uncalibrated Scantable with no CAL signal
164 * @param tcal optional scalar Tcal, CAL temperature (K)
165 * @return casa::CountedPtr<Scantable> which holds a calibrated Scantable
166 * (spectrum - average of the two CAL on and off spectra;
167 * tsys - mean Tsys = <caloff>*Tcal/<calon-caloff> + Tcal/2)
168 */
169 casa::CountedPtr<Scantable> dototalpower( const casa::CountedPtr<Scantable>& calon,
170 const casa::CountedPtr<Scantable>& caloff,
171 casa::Float tcal=1.0 );
172
173 /**
174 * Combine signal and reference scans (translated from GBTIDL)
175 * @param sig Scantable which contains signal scans
176 * @param ref Scantable which contains reference scans
177 * @param smoothref optional Boxcar smooth width of the reference scans
178 * default: no smoothing (=1)
179 * @param tsysv optional scalar Tsys value at the zenith, required to
180 * set tau, as well
181 * @param tau optional scalar Tau value
182 * @return casa::CountedPtr<Scantable> which holds combined scans
183 * (spectrum = (sig-ref)/ref * Tsys )
184 */
185 casa::CountedPtr<Scantable> dosigref( const casa::CountedPtr<Scantable>& sig,
186 const casa::CountedPtr<Scantable>& ref,
187 int smoothref=1,
188 casa::Float tsysv=0.0,
189 casa::Float tau=0.0 );
190
191 /**
192 * Calibrate GBT Nod scan pairs (translated from GBTIDL)
193 * @param s Scantable which contains Nod scans
194 * @param scans Vector of scan numbers
195 * @param smoothref optional Boxcar smooth width of the reference scans
196 * @param tsysv optional scalar Tsys value at the zenith, required to
197 * set tau, as well
198 * @param tau optional scalar Tau value
199 * @param tcal optional scalar Tcal, CAL temperature (K)
200 * @return casa::CountedPtr<Scantable> which holds calibrated scans
201 */
202 casa::CountedPtr<Scantable> donod( const casa::CountedPtr<Scantable>& s,
203 const std::vector<int>& scans,
204 int smoothref=1,
205 casa::Float tsysv=0.0,
206 casa::Float tau=0.0,
207 casa::Float tcal=0.0 );
208
209 /**
210 * Calibrate frequency switched scans (translated from GBTIDL)
211 * @param s Scantable which contains frequency switched scans
212 * @param scans Vector of scan numbers
213 * @param smoothref optional Boxcar smooth width of the reference scans
214 * @param tsysv optional scalar Tsys value at the zenith, required to
215 * set tau, as well
216 * @param tau optional scalar Tau value
217 * @param tcal optional scalar Tcal, CAL temperature (K)
218 * @return casa::CountedPtr<Scantable> which holds calibrated scans
219 */
220 casa::CountedPtr<Scantable> dofs( const casa::CountedPtr<Scantable>& s,
221 const std::vector<int>& scans,
222 int smoothref=1,
223 casa::Float tsysv=0.0,
224 casa::Float tau=0.0,
225 casa::Float tcal=0.0 );
226
227 /**
228 * Calibrate data with Chopper-Wheel like calibration method
229 * which adopts position switching by antenna motion,
230 * wobbler (nutator) switching and On-The-Fly observation.
231 *
232 * The method is applicable to APEX, and other telescopes other than GBT.
233 *
234 * @param a Scantable which contains ON and OFF scans
235 * @param a string that indicates calibration mode
236 * @param a string that indicates antenna name
237 **/
238 casa::CountedPtr<Scantable> cwcal( const casa::CountedPtr<Scantable>& s,
239 const casa::String calmode,
240 const casa::String antname );
241
242 /**
243 * Calibrate frequency switched scans with Chopper-Wheel like
244 * calibration method.
245 *
246 * The method is applicable to APEX, and other telescopes other than GBT.
247 *
248 * @param a Scantable which contains ON and OFF scans
249 * @param a string that indicates antenna name
250 **/
251 casa::CountedPtr<Scantable> cwcalfs( const casa::CountedPtr<Scantable>& s,
252 const casa::String antname );
253
254
255 /**
256 * Folding frequency-switch data
257 * @param sig
258 * @param ref
259 * @param choffset
260 **/
261 casa::CountedPtr<Scantable> dofold( const casa::CountedPtr<Scantable> &sig,
262 const casa::CountedPtr<Scantable> &ref,
263 casa::Double choffset,
264 casa::Double choffset = 0.0 );
265
266 /**
267 * ALMA calibration
268 **/
269 casa::CountedPtr<Scantable> almacal( const casa::CountedPtr<Scantable>& s,
270 const casa::String calmode ) ;
271 casa::CountedPtr<Scantable> almacalfs( const casa::CountedPtr<Scantable>& s ) ;
272
273 casa::CountedPtr<Scantable>
274 freqSwitch( const casa::CountedPtr<Scantable>& in );
275
276 std::vector<float> statistic(const casa::CountedPtr<Scantable>& in,
277 const std::vector<bool>& mask,
278 const std::string& which);
279
280 std::vector< int > minMaxChan(const casa::CountedPtr<Scantable>& in,
281 const std::vector<bool>& mask,
282 const std::string& which);
283
284 casa::CountedPtr<Scantable> bin( const casa::CountedPtr<Scantable>& in,
285 int width=5);
286 casa::CountedPtr<Scantable>
287 resample(const casa::CountedPtr<Scantable>& in,
288 const std::string& method, float width);
289
290 casa::CountedPtr<Scantable>
291 smooth(const casa::CountedPtr<Scantable>& in, const std::string& kernel,
292 float width);
293
294 casa::CountedPtr<Scantable>
295 gainElevation(const casa::CountedPtr<Scantable>& in,
296 const std::vector<float>& coeff,
297 const std::string& fileName,
298 const std::string& method);
299 casa::CountedPtr<Scantable>
300 convertFlux(const casa::CountedPtr<Scantable>& in, float d,
301 float etaap, float jyperk);
302
303 casa::CountedPtr<Scantable> opacity(const casa::CountedPtr<Scantable>& in,
304 float tau);
305
306 casa::CountedPtr<Scantable>
307 merge(const std::vector<casa::CountedPtr<Scantable> >& in);
308
309 casa::CountedPtr<Scantable>
310 invertPhase( const casa::CountedPtr<Scantable>& in);
311
312 casa::CountedPtr<Scantable>
313 rotateXYPhase( const casa::CountedPtr<Scantable>& in, float phase);
314
315 casa::CountedPtr<Scantable>
316 rotateLinPolPhase( const casa::CountedPtr<Scantable>& in, float phase);
317
318 casa::CountedPtr<Scantable>
319 swapPolarisations(const casa::CountedPtr<Scantable>& in);
320
321 casa::CountedPtr<Scantable>
322 frequencyAlign( const casa::CountedPtr<Scantable>& in,
323 const std::string& refTime = "",
324 const std::string& method = "cubic" );
325
326 casa::CountedPtr<Scantable>
327 convertPolarisation( const casa::CountedPtr<Scantable>& in,
328 const std::string& newtype);
329
330 casa::CountedPtr<Scantable>
331 mxExtract( const casa::CountedPtr<Scantable>& in,
332 const std::string& srctype = "on");
333
334 /**
335 * "hard" flag the data, this flags everything selected in setSelection()
336 * @param frequency the frequency to remove
337 * @param width the number of lags to flag left to the side of the frequency
338 */
339 casa::CountedPtr<Scantable>
340 lagFlag( const casa::CountedPtr<Scantable>& in, double frequency,
341 double width);
342
343 // test for average spectra with different channel/resolution
344 casa::CountedPtr<Scantable>
345 new_average( const std::vector<casa::CountedPtr<Scantable> >& in,
346 const bool& compel,
347 const std::vector<bool>& mask = std::vector<bool>(),
348 const std::string& weight = "NONE",
349 const std::string& avmode = "SCAN" )
350 throw (casa::AipsError) ;
351
352private:
353 casa::CountedPtr<Scantable> applyToPol( const casa::CountedPtr<Scantable>& in,
354 STPol::polOperation fptr,
355 casa::Float phase);
356
357 static imethod stringToIMethod(const std::string& in);
358 static WeightType stringToWeight(const std::string& in);
359
360 void scaleByVector(casa::Table& in,
361 const casa::Vector<casa::Float>& factor,
362 bool dotsys);
363
364 void scaleFromAsciiTable(casa::Table& in, const std::string& filename,
365 const std::string& method,
366 const casa::Vector<casa::Float>& xout,
367 bool dotsys);
368
369 void scaleFromTable(casa::Table& in, const casa::Table& table,
370 const std::string& method,
371 const casa::Vector<casa::Float>& xout, bool dotsys);
372
373 void convertBrightnessUnits(casa::CountedPtr<Scantable>& in,
374 bool tokelvin, float cfac);
375
376 casa::CountedPtr< Scantable >
377 smoothOther( const casa::CountedPtr< Scantable >& in,
378 const std::string& kernel,
379 float width );
380
381 casa::CountedPtr< Scantable >
382 getScantable(const casa::CountedPtr< Scantable >& in, bool droprows);
383
384 casa::MaskedArray<casa::Float>
385 maskedArray( const casa::Vector<casa::Float>& s,
386 const casa::Vector<casa::uChar>& f );
387 casa::MaskedArray<casa::Double>
388 maskedArray( const casa::Vector<casa::Double>& s,
389 const casa::Vector<casa::uChar>& f );
390 casa::Vector<casa::uChar>
391 flagsFromMA(const casa::MaskedArray<casa::Float>& ma);
392
393 vector<float> getSpectrumFromTime( string reftime, casa::CountedPtr<Scantable>& s, string mode = "before" ) ;
394 vector<float> getTcalFromTime( string reftime, casa::CountedPtr<Scantable>& s, string mode="before" ) ;
395 vector<float> getTsysFromTime( string reftime, casa::CountedPtr<Scantable>& s, string mode="before" ) ;
396 vector<int> getRowIdFromTime( string reftime, casa::CountedPtr<Scantable>& s ) ;
397
398 // Chopper-Wheel type calibration
399 vector<float> getCalibratedSpectra( casa::CountedPtr<Scantable>& on,
400 casa::CountedPtr<Scantable>& off,
401 casa::CountedPtr<Scantable>& sky,
402 casa::CountedPtr<Scantable>& hot,
403 casa::CountedPtr<Scantable>& cold,
404 int index,
405 string antname ) ;
406 // Tsys * (ON-OFF)/OFF
407 vector<float> getCalibratedSpectra( casa::CountedPtr<Scantable>& on,
408 casa::CountedPtr<Scantable>& off,
409 int index ) ;
410 vector<float> getFSCalibratedSpectra( casa::CountedPtr<Scantable>& sig,
411 casa::CountedPtr<Scantable>& ref,
412 casa::CountedPtr<Scantable>& sky,
413 casa::CountedPtr<Scantable>& hot,
414 casa::CountedPtr<Scantable>& cold,
415 int index ) ;
416 vector<float> getFSCalibratedSpectra( casa::CountedPtr<Scantable>& sig,
417 casa::CountedPtr<Scantable>& ref,
418 vector< casa::CountedPtr<Scantable> >& sky,
419 vector< casa::CountedPtr<Scantable> >& hot,
420 vector< casa::CountedPtr<Scantable> >& cold,
421 int index ) ;
422 double getMJD( string strtime ) ;
423
424 bool insitu_;
425};
426
427}
428#endif
Note: See TracBrowser for help on using the repository browser.