source: tags/asap-4.1.0/src/STMath.h @ 2662

Last change on this file since 2662 was 2662, checked in by Malte Marquarding, 12 years ago

merge from trunk into release candidate
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 17.9 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 "Scantable.h"
26#include "STDefs.h"
27#include "STPol.h"
28
29namespace asap {
30
31/**
32        * Mathmatical operations on Scantable objects
33        * @author Malte Marquarding
34*/
35class STMath {
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 choffset2 = 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<float> statisticRow(const casa::CountedPtr<Scantable>& in,
281                               const std::vector<bool>& mask,
282                               const std::string& which,
283                               int row);
284
285  std::vector< int > minMaxChan(const casa::CountedPtr<Scantable>& in,
286                                const std::vector<bool>& mask,
287                                const std::string& which);
288
289  casa::CountedPtr<Scantable> bin( const casa::CountedPtr<Scantable>& in,
290                                   int width=5);
291  casa::CountedPtr<Scantable>
292    resample(const casa::CountedPtr<Scantable>& in,
293             const std::string& method, float width);
294
295  casa::CountedPtr<Scantable>
296    smooth(const casa::CountedPtr<Scantable>& in, const std::string& kernel,
297                      float width, int order=2);
298
299  casa::CountedPtr<Scantable>
300    gainElevation(const casa::CountedPtr<Scantable>& in,
301                  const std::vector<float>& coeff,
302                  const std::string& fileName,
303                  const std::string& method);
304  casa::CountedPtr<Scantable>
305    convertFlux(const casa::CountedPtr<Scantable>& in, float d,
306                float etaap, float jyperk);
307
308  casa::CountedPtr<Scantable> opacity(const casa::CountedPtr<Scantable>& in,
309                                      const std::vector<float>& tau);
310
311  casa::CountedPtr<Scantable>
312    merge(const std::vector<casa::CountedPtr<Scantable> >& in);
313
314  casa::CountedPtr<Scantable>
315    invertPhase( const casa::CountedPtr<Scantable>& in);
316
317  casa::CountedPtr<Scantable>
318    rotateXYPhase( const casa::CountedPtr<Scantable>& in, float phase);
319
320  casa::CountedPtr<Scantable>
321    rotateLinPolPhase( const casa::CountedPtr<Scantable>& in, float phase);
322
323  casa::CountedPtr<Scantable>
324    swapPolarisations(const casa::CountedPtr<Scantable>& in);
325
326  casa::CountedPtr<Scantable>
327    frequencyAlign( const casa::CountedPtr<Scantable>& in,
328                    const std::string& refTime = "",
329                    const std::string& method = "cubic" );
330
331  casa::CountedPtr<Scantable>
332    convertPolarisation( const casa::CountedPtr<Scantable>& in,
333                         const std::string& newtype);
334
335  casa::CountedPtr<Scantable>
336    mxExtract( const casa::CountedPtr<Scantable>& in,
337               const std::string& srctype = "on");
338
339  /**
340   * "hard" flag the data, this flags everything selected in setSelection()
341   * @param frequency the frequency to remove
342   * @param width the number of lags to flag left to the side of the frequency
343   */
344  casa::CountedPtr<Scantable>
345    lagFlag( const casa::CountedPtr<Scantable>& in, double start,
346             double end, const std::string& mode="frequency");
347
348  std::vector<float>
349    fft( const casa::CountedPtr<Scantable>& in,
350         const std::vector<int>& whichrow,
351         bool getRealImag=false );
352
353  // test for average spectra with different channel/resolution
354  casa::CountedPtr<Scantable>
355    new_average( const std::vector<casa::CountedPtr<Scantable> >& in,
356                 const bool& compel,
357                 const std::vector<bool>& mask = std::vector<bool>(),
358                 const std::string& weight = "NONE",
359                 const std::string& avmode = "SCAN" )
360    throw (casa::AipsError) ;
361
362private:
363  casa::CountedPtr<Scantable>  applyToPol( const casa::CountedPtr<Scantable>& in,
364                                           STPol::polOperation fptr,
365                                           casa::Float phase);
366
367  static imethod stringToIMethod(const std::string& in);
368  static WeightType stringToWeight(const std::string& in);
369
370  void scaleByVector(casa::Table& in,
371                     const casa::Vector<casa::Float>& factor,
372                     bool dotsys);
373
374  void scaleFromAsciiTable(casa::Table& in, const std::string& filename,
375                           const std::string& method,
376                           const casa::Vector<casa::Float>& xout,
377                           bool dotsys);
378
379  void scaleFromTable(casa::Table& in, const casa::Table& table,
380                      const std::string& method,
381                      const casa::Vector<casa::Float>& xout, bool dotsys);
382
383  void convertBrightnessUnits(casa::CountedPtr<Scantable>& in,
384                              bool tokelvin, float cfac);
385
386  casa::CountedPtr< Scantable >
387    smoothOther( const casa::CountedPtr< Scantable >& in,
388                 const std::string& kernel,
389                 float width, int order=2 );
390
391  casa::CountedPtr< Scantable >
392    getScantable(const casa::CountedPtr< Scantable >& in, bool droprows);
393
394  casa::MaskedArray<casa::Float>
395    maskedArray( const casa::Vector<casa::Float>& s,
396                 const casa::Vector<casa::uChar>& f );
397  casa::MaskedArray<casa::Double>
398    maskedArray( const casa::Vector<casa::Double>& s,
399                 const casa::Vector<casa::uChar>& f );
400  casa::Vector<casa::uChar>
401    flagsFromMA(const casa::MaskedArray<casa::Float>& ma);
402
403  casa::Vector<casa::Float> getSpectrumFromTime( double reftime, const casa::Vector<casa::Double> &v, const vector<int> &idx, const casa::Matrix<casa::Float>& sp, string mode = "before" ) ;
404  casa::Vector<casa::Float> getTcalFromTime( double reftime, const casa::Vector<casa::Double> &v, const vector<int> &idx, const casa::CountedPtr<Scantable>& s, string mode="before" ) ;
405  casa::Vector<casa::Float> getTsysFromTime( double reftime, const casa::Vector<casa::Double> &v, const vector<int> &idx, const casa::CountedPtr<Scantable>& s, string mode="before" ) ;
406  vector<int> getRowIdFromTime( double reftime, const casa::Vector<casa::Double>& t ) ;
407
408  // Chopper-Wheel type calibration
409  void calibrateCW( casa::CountedPtr<Scantable> &out,
410                    const casa::CountedPtr<Scantable> &on,
411                    const casa::CountedPtr<Scantable> &off,
412                    const casa::CountedPtr<Scantable> &sky,
413                    const casa::CountedPtr<Scantable> &hot,
414                    const casa::CountedPtr<Scantable> &cold,
415                    const casa::Vector<casa::uInt> &rows,
416                    const casa::String &antname ) ;
417
418  // Tsys * (ON-OFF)/OFF
419  void calibrateALMA( casa::CountedPtr<Scantable>& out,
420                      const casa::CountedPtr<Scantable>& on,
421                      const casa::CountedPtr<Scantable>& off,
422                      const casa::Vector<casa::uInt>& rows ) ;
423
424  // Frequency switching
425  void calibrateFS( casa::CountedPtr<Scantable> &sig,
426                    casa::CountedPtr<Scantable> &ref,
427                    const casa::CountedPtr<Scantable> &rsig,
428                    const casa::CountedPtr<Scantable> &rref,
429                    const casa::CountedPtr<Scantable> &sky,
430                    const casa::CountedPtr<Scantable> &hot,
431                    const casa::CountedPtr<Scantable> &cold,
432                    const casa::Vector<casa::uInt> &rows ) ;
433  void calibrateAPEXFS( casa::CountedPtr<Scantable> &sig,
434                        casa::CountedPtr<Scantable> &ref,
435                        const vector< casa::CountedPtr<Scantable> > &on,
436                        const vector< casa::CountedPtr<Scantable> > &sky,
437                        const vector< casa::CountedPtr<Scantable> > &hot,
438                        const vector< casa::CountedPtr<Scantable> > &cold,
439                        const casa::Vector<casa::uInt> &rows ) ;
440  void copyRows( casa::Table &out,
441                 const casa::Table &in,
442                 casa::uInt startout,
443                 casa::uInt startin,
444                 casa::uInt nrow,
445                 casa::Bool copySpectra=true,
446                 casa::Bool copyFlagtra=true,
447                 casa::Bool copyTsys=true ) ;
448  casa::CountedPtr<Scantable> averageWithinSession( casa::CountedPtr<Scantable> &s,
449                                                    vector<bool> &mask,
450                                                    string weight ) ;
451
452  bool insitu_;
453};
454
455}
456#endif
Note: See TracBrowser for help on using the repository browser.