Context Navigation

STMath.h@ 1734

Visit:

Last change on this file since 1734 was 1680, checked in by Takeshi Nakazato, 15 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

Rev	Line
[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]	29	namespace asap {
[2]	30
[805]	31	/**
[1106]	32	* Mathmatical operations on Scantable objects
	33	* @author Malte Marquarding
[805]	34	*/
[890]	35	class STMath : private Logger {
[716]	36	public:
[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
[1677]	121	// array operation
[1308]	122	casa::CountedPtr<Scantable>
[1677]	123	arrayOperate( const casa::CountedPtr<Scantable>& in,
	124	const std::vector<float> val,
[1680]	125	const std::string& mode,
	126	const std::string& opmode="channel",
	127	bool tsys=false );
[1677]	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>
[1308]	148	binaryOperate( const casa::CountedPtr<Scantable>& left,
	149	const casa::CountedPtr<Scantable>& right,
	150	const std::string& mode);
	151
[1066]	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,
[805]	158	bool preserve = true );
[169]	159
[1388]	160	/**
	161	* Calibrate total power scans (translated from GBTIDL)
[1446]	162	* @param calon uncalibrated Scantable with CAL noise signal
[1388]	163	* @param caloff uncalibrated Scantable with no CAL signal
	164	* @param tcal optional scalar Tcal, CAL temperature (K)
[1446]	165	* @return casa::CountedPtr<Scantable> which holds a calibrated Scantable
[1388]	166	* (spectrum - average of the two CAL on and off spectra;
	167	* tsys - mean Tsys = <caloff>*Tcal/<calon-caloff> + Tcal/2)
[1446]	168	*/
[1388]	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)
[1446]	179	* @param tsysv optional scalar Tsys value at the zenith, required to
	180	* set tau, as well
[1388]	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
[1446]	191	/**
[1388]	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
[1446]	198	* @param tau optional scalar Tau value
[1388]	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
[1609]	227	/**
[1633]	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	/**
[1609]	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,
[1633]	263	casa::Double choffset,
	264	casa::Double choffset = 0.0 );
[1388]	265
[1673]	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
[805]	273	casa::CountedPtr<Scantable>
	274	freqSwitch( const casa::CountedPtr<Scantable>& in );
[716]	275
[805]	276	std::vector<float> statistic(const casa::CountedPtr<Scantable>& in,
	277	const std::vector<bool>& mask,
	278	const std::string& which);
[457]	279
[1516]	280	std::vector< int > minMaxChan(const casa::CountedPtr<Scantable>& in,
	281	const std::vector<bool>& mask,
	282	const std::string& which);
[1514]	283
[805]	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);
[457]	289
[805]	290	casa::CountedPtr<Scantable>
	291	smooth(const casa::CountedPtr<Scantable>& in, const std::string& kernel,
[995]	292	float width);
[169]	293
[805]	294	casa::CountedPtr<Scantable>
	295	gainElevation(const casa::CountedPtr<Scantable>& in,
[867]	296	const std::vector<float>& coeff,
[805]	297	const std::string& fileName,
[995]	298	const std::string& method);
[805]	299	casa::CountedPtr<Scantable>
	300	convertFlux(const casa::CountedPtr<Scantable>& in, float d,
	301	float etaap, float jyperk);
[152]	302
[805]	303	casa::CountedPtr<Scantable> opacity(const casa::CountedPtr<Scantable>& in,
	304	float tau);
[144]	305
[841]	306	casa::CountedPtr<Scantable>
	307	merge(const std::vector<casa::CountedPtr<Scantable> >& in);
	308
[896]	309	casa::CountedPtr<Scantable>
	310	invertPhase( const casa::CountedPtr<Scantable>& in);
[912]	311
[896]	312	casa::CountedPtr<Scantable>
	313	rotateXYPhase( const casa::CountedPtr<Scantable>& in, float phase);
[912]	314
[896]	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
[917]	321	casa::CountedPtr<Scantable>
	322	frequencyAlign( const casa::CountedPtr<Scantable>& in,
[927]	323	const std::string& refTime = "",
	324	const std::string& method = "cubic" );
[917]	325
[992]	326	casa::CountedPtr<Scantable>
	327	convertPolarisation( const casa::CountedPtr<Scantable>& in,
	328	const std::string& newtype);
[1143]	329
[1140]	330	casa::CountedPtr<Scantable>
[1143]	331	mxExtract( const casa::CountedPtr<Scantable>& in,
	332	const std::string& srctype = "on");
[992]	333
[1192]	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,
[1200]	341	double width);
[1192]	342
[1446]	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
[805]	352	private:
[896]	353	casa::CountedPtr<Scantable> applyToPol( const casa::CountedPtr<Scantable>& in,
	354	STPol::polOperation fptr,
	355	casa::Float phase);
	356
[805]	357	static imethod stringToIMethod(const std::string& in);
	358	static WeightType stringToWeight(const std::string& in);
[146]	359
[805]	360	void scaleByVector(casa::Table& in,
	361	const casa::Vector<casa::Float>& factor,
	362	bool dotsys);
[152]	363
[805]	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);
[162]	368
[805]	369	void scaleFromTable(casa::Table& in, const casa::Table& table,
	370	const std::string& method,
	371	const casa::Vector<casa::Float>& xout, bool dotsys);
[227]	372
[805]	373	void convertBrightnessUnits(casa::CountedPtr<Scantable>& in,
	374	bool tokelvin, float cfac);
[227]	375
[1374]	376	casa::CountedPtr< Scantable >
	377	smoothOther( const casa::CountedPtr< Scantable >& in,
	378	const std::string& kernel,
	379	float width );
	380
[805]	381	casa::CountedPtr< Scantable >
	382	getScantable(const casa::CountedPtr< Scantable >& in, bool droprows);
[230]	383
[805]	384	casa::MaskedArray<casa::Float>
	385	maskedArray( const casa::Vector<casa::Float>& s,
	386	const casa::Vector<casa::uChar>& f );
[1607]	387	casa::MaskedArray<casa::Double>
	388	maskedArray( const casa::Vector<casa::Double>& s,
	389	const casa::Vector<casa::uChar>& f );
[805]	390	casa::Vector<casa::uChar>
	391	flagsFromMA(const casa::MaskedArray<casa::Float>& ma);
[230]	392
[1633]	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" ) ;
[1634]	395	vector<float> getTsysFromTime( string reftime, casa::CountedPtr<Scantable>& s, string mode="before" ) ;
[1633]	396	vector<int> getRowIdFromTime( string reftime, casa::CountedPtr<Scantable>& s ) ;
[1673]	397
	398	// Chopper-Wheel type calibration
[1633]	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 ) ;
[1673]	406	// Tsys * (ON-OFF)/OFF
	407	vector<float> getCalibratedSpectra( casa::CountedPtr<Scantable>& on,
	408	casa::CountedPtr<Scantable>& off,
	409	int index ) ;
[1633]	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
[805]	424	bool insitu_;
	425	};
[234]	426
[805]	427	}
[165]	428	#endif

Note: See TracBrowser for help on using the repository browser.

Context Navigation

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

Download in other formats: