Context Navigation

source: branches/mergetest/src/STMath.h @ 1779

Visit:

Last change on this file since 1779 was 1779, checked in by Kana Sugimoto, 14 years ago

New Development: Yes

JIRA Issue: No (test merging alma branch)

Ready for Test: Yes

Interface Changes: Yes

What Interface Changed:

Test Programs:

Put in Release Notes: No

Module(s):

Description:

Property svn:eol-style set to native
Property svn:keywords set to Author Date Id Revision

File size: 16.8 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
29	namespace asap {
30
31	/**
32	* Mathmatical operations on Scantable objects
33	* @author Malte Marquarding
34	*/
35	class STMath : private Logger {
36	public:
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, int order=2);
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	const std::vector<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 start,
341	double end, const std::string& mode="frequency");
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
352	private:
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, int order=2 );
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.

Download in other formats: