Context Navigation

STMath.h @ 1680

Visit:

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

New Development: No

JIRA Issue: Yes CAS-1823

Ready to Release: 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...

Bug fix

In scantable.py, self._math = stmath() should be
self._math = stmath( rcParamsinsitu? ).

Delete operation mode

I have deleted operation mode parameter which is used for a function
to do an operation of scantable with 1D list, since I have implemented
the operation of scantable with 2D list.

Extend operation of scantable

Now, operation of scantable with 2D list is available.

Accept integer input for operation

Operation of scantable with int as well as int list is working
in addition to operation with float or float list.

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

File size: 16.7 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);
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	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 frequency,
341	double width);
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 );
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.

Context Navigation

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

Download in other formats: