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

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

New Development: No

JIRA Issue: Yes CAS-1448

Ready to Release: No

Interface Changes: Yes/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...

I have defined a function for folding frequency-switch data.
It is still experimental. Test data is needed.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 12.3 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 /**
202 * Folding frequency-switch data
203 * @param sig
204 * @param ref
205 * @param choffset
206 **/
207 casa::CountedPtr<Scantable> dofold( const casa::CountedPtr<Scantable> &sig,
208 const casa::CountedPtr<Scantable> &ref,
209 casa::Int choffset );
[1388]210
[805]211 casa::CountedPtr<Scantable>
212 freqSwitch( const casa::CountedPtr<Scantable>& in );
[716]213
[805]214 std::vector<float> statistic(const casa::CountedPtr<Scantable>& in,
215 const std::vector<bool>& mask,
216 const std::string& which);
[457]217
[1516]218 std::vector< int > minMaxChan(const casa::CountedPtr<Scantable>& in,
219 const std::vector<bool>& mask,
220 const std::string& which);
[1514]221
[805]222 casa::CountedPtr<Scantable> bin( const casa::CountedPtr<Scantable>& in,
223 int width=5);
224 casa::CountedPtr<Scantable>
225 resample(const casa::CountedPtr<Scantable>& in,
226 const std::string& method, float width);
[457]227
[805]228 casa::CountedPtr<Scantable>
229 smooth(const casa::CountedPtr<Scantable>& in, const std::string& kernel,
[995]230 float width);
[169]231
[805]232 casa::CountedPtr<Scantable>
233 gainElevation(const casa::CountedPtr<Scantable>& in,
[867]234 const std::vector<float>& coeff,
[805]235 const std::string& fileName,
[995]236 const std::string& method);
[805]237 casa::CountedPtr<Scantable>
238 convertFlux(const casa::CountedPtr<Scantable>& in, float d,
239 float etaap, float jyperk);
[152]240
[805]241 casa::CountedPtr<Scantable> opacity(const casa::CountedPtr<Scantable>& in,
242 float tau);
[144]243
[841]244 casa::CountedPtr<Scantable>
245 merge(const std::vector<casa::CountedPtr<Scantable> >& in);
246
[896]247 casa::CountedPtr<Scantable>
248 invertPhase( const casa::CountedPtr<Scantable>& in);
[912]249
[896]250 casa::CountedPtr<Scantable>
251 rotateXYPhase( const casa::CountedPtr<Scantable>& in, float phase);
[912]252
[896]253 casa::CountedPtr<Scantable>
254 rotateLinPolPhase( const casa::CountedPtr<Scantable>& in, float phase);
255
256 casa::CountedPtr<Scantable>
257 swapPolarisations(const casa::CountedPtr<Scantable>& in);
258
[917]259 casa::CountedPtr<Scantable>
260 frequencyAlign( const casa::CountedPtr<Scantable>& in,
[927]261 const std::string& refTime = "",
262 const std::string& method = "cubic" );
[917]263
[992]264 casa::CountedPtr<Scantable>
265 convertPolarisation( const casa::CountedPtr<Scantable>& in,
266 const std::string& newtype);
[1143]267
[1140]268 casa::CountedPtr<Scantable>
[1143]269 mxExtract( const casa::CountedPtr<Scantable>& in,
270 const std::string& srctype = "on");
[992]271
[1192]272 /**
273 * "hard" flag the data, this flags everything selected in setSelection()
274 * @param frequency the frequency to remove
275 * @param width the number of lags to flag left to the side of the frequency
276 */
277 casa::CountedPtr<Scantable>
278 lagFlag( const casa::CountedPtr<Scantable>& in, double frequency,
[1200]279 double width);
[1192]280
[1446]281 // test for average spectra with different channel/resolution
282 casa::CountedPtr<Scantable>
283 new_average( const std::vector<casa::CountedPtr<Scantable> >& in,
284 const bool& compel,
285 const std::vector<bool>& mask = std::vector<bool>(),
286 const std::string& weight = "NONE",
287 const std::string& avmode = "SCAN" )
288 throw (casa::AipsError) ;
289
290
[805]291private:
[896]292 casa::CountedPtr<Scantable> applyToPol( const casa::CountedPtr<Scantable>& in,
293 STPol::polOperation fptr,
294 casa::Float phase);
295
[805]296 static imethod stringToIMethod(const std::string& in);
297 static WeightType stringToWeight(const std::string& in);
[146]298
[805]299 void scaleByVector(casa::Table& in,
300 const casa::Vector<casa::Float>& factor,
301 bool dotsys);
[152]302
[805]303 void scaleFromAsciiTable(casa::Table& in, const std::string& filename,
304 const std::string& method,
305 const casa::Vector<casa::Float>& xout,
306 bool dotsys);
[162]307
[805]308 void scaleFromTable(casa::Table& in, const casa::Table& table,
309 const std::string& method,
310 const casa::Vector<casa::Float>& xout, bool dotsys);
[227]311
[805]312 void convertBrightnessUnits(casa::CountedPtr<Scantable>& in,
313 bool tokelvin, float cfac);
[227]314
[1374]315 casa::CountedPtr< Scantable >
316 smoothOther( const casa::CountedPtr< Scantable >& in,
317 const std::string& kernel,
318 float width );
319
[805]320 casa::CountedPtr< Scantable >
321 getScantable(const casa::CountedPtr< Scantable >& in, bool droprows);
[230]322
[805]323 casa::MaskedArray<casa::Float>
324 maskedArray( const casa::Vector<casa::Float>& s,
325 const casa::Vector<casa::uChar>& f );
[1607]326 casa::MaskedArray<casa::Double>
327 maskedArray( const casa::Vector<casa::Double>& s,
328 const casa::Vector<casa::uChar>& f );
[805]329 casa::Vector<casa::uChar>
330 flagsFromMA(const casa::MaskedArray<casa::Float>& ma);
[230]331
[805]332 bool insitu_;
333};
[234]334
[805]335}
[165]336#endif
Note: See TracBrowser for help on using the repository browser.