source: branches/hpc33/src/STMath.h @ 2551

Last change on this file since 2551 was 2551, checked in by Takeshi Nakazato, 12 years ago

New Development: No

JIRA Issue: Yes CAS-4195

Ready for Test: 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...

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