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

Last change on this file since 1673 was 1673, checked in by Takeshi Nakazato, 14 years ago

New Development: No

JIRA Issue: Yes CAS-1799

Ready to Release: No

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...

Calibration algorithm for ALMA data (data from OSF) is updated.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 15.7 KB
RevLine 
[805]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
[2]14
[38]15#include <string>
[805]16#include <map>
17
[130]18#include <casa/aips.h>
[81]19#include <casa/Utilities/CountedPtr.h>
[805]20#include <casa/BasicSL/String.h>
21#include <casa/Arrays/Vector.h>
22#include <scimath/Mathematics/InterpolateArray1D.h>
[294]23
[805]24#include "Scantable.h"
[834]25#include "STDefs.h"
[896]26#include "STPol.h"
[894]27#include "Logger.h"
[2]28
[83]29namespace asap {
[2]30
[805]31/**
[1106]32        * Mathmatical operations on Scantable objects
33        * @author Malte Marquarding
[805]34*/
[890]35class STMath : private Logger {
[716]36public:
[1106]37        // typedef for long method name
[805]38  typedef casa::InterpolateArray1D<casa::Double,
39                                   casa::Float>::InterpolationMethod imethod;
[299]40
[1106]41  // typedef for std::map
[805]42  typedef std::map<std::string, imethod> imap;
[177]43
[1106]44/**
45  * whether to operate on the given Scantable or return a new one
46  * @param insitu the toggle for this behaviour
47  */
[1353]48  explicit STMath(bool insitu=true);
[221]49
[995]50  virtual ~STMath();
[227]51
[805]52  /**
[1295]53   * get the currnt @attr inistu_ state
[805]54   */
55  bool insitu() const { return insitu_;};
[1143]56
[1106]57  /**
58   * set the currnt @attr inistu state
59   * @param b the new state
60   */
[805]61  void setInsitu(bool b) { insitu_ = b; };
[262]62
[1106]63
[1140]64  /**
65    * average a vector of Scantables
66    * @param in the vector of Scantables to average
[1603]67    * @param mask an optional mask to apply on specific weights
[1140]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    */
[805]73  casa::CountedPtr<Scantable>
74    average( const std::vector<casa::CountedPtr<Scantable> >& in,
[858]75             const std::vector<bool>& mask = std::vector<bool>(),
76             const std::string& weight = "NONE",
[977]77             const std::string& avmode = "SCAN");
[1066]78
[1140]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    */
[1069]87  casa::CountedPtr<Scantable>
88    averageChannel( const casa::CountedPtr<Scantable> & in,
[1078]89                    const std::string& mode = "MEDIAN",
90                    const std::string& avmode = "SCAN");
[1069]91
[1140]92  /**
[1145]93    * Average polarisations together. really only useful if only linears are
94    * available.
[1140]95    * @param in the input Scantable
96    * @param mask an optional mask if weight allows one
97    * @param weight weighting scheme
[1143]98    * @return
[1140]99    */
[940]100  casa::CountedPtr< Scantable >
101    averagePolarisations( const casa::CountedPtr< Scantable > & in,
[1140]102                          const std::vector<bool>& mask,
103                          const std::string& weight );
[234]104
[1145]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
[805]117  casa::CountedPtr<Scantable>
118    unaryOperate( const casa::CountedPtr<Scantable>& in, float val,
119                  const std::string& mode, bool tsys=false );
[169]120
[1308]121  casa::CountedPtr<Scantable>
122    binaryOperate( const casa::CountedPtr<Scantable>& left,
123                   const casa::CountedPtr<Scantable>& right,
124                   const std::string& mode);
125
[1066]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,
[805]132                                        bool preserve = true );
[169]133
[1388]134  /**
135    * Calibrate total power scans (translated from GBTIDL)
[1446]136    * @param calon uncalibrated Scantable with CAL noise signal
[1388]137    * @param caloff uncalibrated Scantable with no CAL signal
138    * @param tcal optional scalar Tcal, CAL temperature (K)
[1446]139    * @return casa::CountedPtr<Scantable> which holds a calibrated Scantable
[1388]140    * (spectrum - average of the two CAL on and off spectra;
141    * tsys - mean Tsys = <caloff>*Tcal/<calon-caloff> + Tcal/2)
[1446]142    */             
[1388]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)
[1446]153    * @param tsysv optional scalar Tsys value at the zenith, required to
154    * set tau, as well
[1388]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
[1446]165  /**
[1388]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
[1446]172    * @param tau optional scalar Tau value
[1388]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
[1609]201  /**
[1633]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  /**
[1609]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,
[1633]237                                      casa::Double choffset,
238                                      casa::Double choffset = 0.0 );
[1388]239
[1673]240  /**
241   * ALMA calibration
242   **/
243  casa::CountedPtr<Scantable> almacal( const casa::CountedPtr<Scantable>& s,
244                                       const casa::String calmode ) ;
245  casa::CountedPtr<Scantable> almacalfs( const casa::CountedPtr<Scantable>& s ) ;
246
[805]247  casa::CountedPtr<Scantable>
248    freqSwitch( const casa::CountedPtr<Scantable>& in );
[716]249
[805]250  std::vector<float> statistic(const casa::CountedPtr<Scantable>& in,
251                               const std::vector<bool>& mask,
252                               const std::string& which);
[457]253
[1516]254  std::vector< int > minMaxChan(const casa::CountedPtr<Scantable>& in,
255                                const std::vector<bool>& mask,
256                                const std::string& which);
[1514]257
[805]258  casa::CountedPtr<Scantable> bin( const casa::CountedPtr<Scantable>& in,
259                                   int width=5);
260  casa::CountedPtr<Scantable>
261    resample(const casa::CountedPtr<Scantable>& in,
262             const std::string& method, float width);
[457]263
[805]264  casa::CountedPtr<Scantable>
265    smooth(const casa::CountedPtr<Scantable>& in, const std::string& kernel,
[995]266                      float width);
[169]267
[805]268  casa::CountedPtr<Scantable>
269    gainElevation(const casa::CountedPtr<Scantable>& in,
[867]270                  const std::vector<float>& coeff,
[805]271                  const std::string& fileName,
[995]272                  const std::string& method);
[805]273  casa::CountedPtr<Scantable>
274    convertFlux(const casa::CountedPtr<Scantable>& in, float d,
275                float etaap, float jyperk);
[152]276
[805]277  casa::CountedPtr<Scantable> opacity(const casa::CountedPtr<Scantable>& in,
278                                      float tau);
[144]279
[841]280  casa::CountedPtr<Scantable>
281    merge(const std::vector<casa::CountedPtr<Scantable> >& in);
282
[896]283  casa::CountedPtr<Scantable>
284    invertPhase( const casa::CountedPtr<Scantable>& in);
[912]285
[896]286  casa::CountedPtr<Scantable>
287    rotateXYPhase( const casa::CountedPtr<Scantable>& in, float phase);
[912]288
[896]289  casa::CountedPtr<Scantable>
290    rotateLinPolPhase( const casa::CountedPtr<Scantable>& in, float phase);
291
292  casa::CountedPtr<Scantable>
293    swapPolarisations(const casa::CountedPtr<Scantable>& in);
294
[917]295  casa::CountedPtr<Scantable>
296    frequencyAlign( const casa::CountedPtr<Scantable>& in,
[927]297                    const std::string& refTime = "",
298                    const std::string& method = "cubic" );
[917]299
[992]300  casa::CountedPtr<Scantable>
301    convertPolarisation( const casa::CountedPtr<Scantable>& in,
302                         const std::string& newtype);
[1143]303
[1140]304  casa::CountedPtr<Scantable>
[1143]305    mxExtract( const casa::CountedPtr<Scantable>& in,
306               const std::string& srctype = "on");
[992]307
[1192]308  /**
309   * "hard" flag the data, this flags everything selected in setSelection()
310   * @param frequency the frequency to remove
311   * @param width the number of lags to flag left to the side of the frequency
312   */
313  casa::CountedPtr<Scantable>
314    lagFlag( const casa::CountedPtr<Scantable>& in, double frequency,
[1200]315              double width);
[1192]316
[1446]317  // test for average spectra with different channel/resolution
318  casa::CountedPtr<Scantable>
319    new_average( const std::vector<casa::CountedPtr<Scantable> >& in,
320                 const bool& compel,
321                 const std::vector<bool>& mask = std::vector<bool>(),
322                 const std::string& weight = "NONE",
323                 const std::string& avmode = "SCAN" )
324    throw (casa::AipsError) ;
325
[805]326private:
[896]327  casa::CountedPtr<Scantable>  applyToPol( const casa::CountedPtr<Scantable>& in,
328                                           STPol::polOperation fptr,
329                                           casa::Float phase);
330
[805]331  static imethod stringToIMethod(const std::string& in);
332  static WeightType stringToWeight(const std::string& in);
[146]333
[805]334  void scaleByVector(casa::Table& in,
335                     const casa::Vector<casa::Float>& factor,
336                     bool dotsys);
[152]337
[805]338  void scaleFromAsciiTable(casa::Table& in, const std::string& filename,
339                           const std::string& method,
340                           const casa::Vector<casa::Float>& xout,
341                           bool dotsys);
[162]342
[805]343  void scaleFromTable(casa::Table& in, const casa::Table& table,
344                      const std::string& method,
345                      const casa::Vector<casa::Float>& xout, bool dotsys);
[227]346
[805]347  void convertBrightnessUnits(casa::CountedPtr<Scantable>& in,
348                              bool tokelvin, float cfac);
[227]349
[1374]350  casa::CountedPtr< Scantable >
351    smoothOther( const casa::CountedPtr< Scantable >& in,
352                 const std::string& kernel,
353                 float width );
354
[805]355  casa::CountedPtr< Scantable >
356    getScantable(const casa::CountedPtr< Scantable >& in, bool droprows);
[230]357
[805]358  casa::MaskedArray<casa::Float>
359    maskedArray( const casa::Vector<casa::Float>& s,
360                 const casa::Vector<casa::uChar>& f );
[1607]361  casa::MaskedArray<casa::Double>
362    maskedArray( const casa::Vector<casa::Double>& s,
363                 const casa::Vector<casa::uChar>& f );
[805]364  casa::Vector<casa::uChar>
365    flagsFromMA(const casa::MaskedArray<casa::Float>& ma);
[230]366
[1633]367  vector<float> getSpectrumFromTime( string reftime, casa::CountedPtr<Scantable>& s, string mode = "before" ) ;
368  vector<float> getTcalFromTime( string reftime, casa::CountedPtr<Scantable>& s, string mode="before" ) ;
[1634]369  vector<float> getTsysFromTime( string reftime, casa::CountedPtr<Scantable>& s, string mode="before" ) ;
[1633]370  vector<int> getRowIdFromTime( string reftime, casa::CountedPtr<Scantable>& s ) ;
[1673]371
372  // Chopper-Wheel type calibration
[1633]373  vector<float> getCalibratedSpectra( casa::CountedPtr<Scantable>& on,
374                                      casa::CountedPtr<Scantable>& off,
375                                      casa::CountedPtr<Scantable>& sky,
376                                      casa::CountedPtr<Scantable>& hot,
377                                      casa::CountedPtr<Scantable>& cold,
378                                      int index,
379                                      string antname ) ;
[1673]380  // Tsys * (ON-OFF)/OFF
381  vector<float> getCalibratedSpectra( casa::CountedPtr<Scantable>& on,
382                                      casa::CountedPtr<Scantable>& off,
383                                      int index ) ;
[1633]384  vector<float> getFSCalibratedSpectra( casa::CountedPtr<Scantable>& sig,
385                                        casa::CountedPtr<Scantable>& ref,
386                                        casa::CountedPtr<Scantable>& sky,
387                                        casa::CountedPtr<Scantable>& hot,
388                                        casa::CountedPtr<Scantable>& cold,
389                                        int index ) ;
390  vector<float> getFSCalibratedSpectra( casa::CountedPtr<Scantable>& sig,
391                                        casa::CountedPtr<Scantable>& ref,
392                                        vector< casa::CountedPtr<Scantable> >& sky,
393                                        vector< casa::CountedPtr<Scantable> >& hot,
394                                        vector< casa::CountedPtr<Scantable> >& cold,
395                                        int index ) ;
396  double getMJD( string strtime ) ;
397
[805]398  bool insitu_;
399};
[234]400
[805]401}
[165]402#endif
Note: See TracBrowser for help on using the repository browser.