Context Navigation

source: trunk/src/Scantable.h@ 3005

Visit:

Last change on this file since 3005 was 2969, checked in by Kana Sugimoto, 10 years ago

New Development: No

JIRA Issue: Yes (CAS-6109)

Ready for Test: Yes

Interface Changes: No

What Interface Changed:

Test Programs: runUnitTest.main(test_sdlist)

Put in Release Notes: No

Module(s): scantable, sdlist

Description: Fixed a bug in time range calculation in scantable.summary (sdlist).

Also enhanced precision of time and direction listed in the method.
Added a parameter, prec, in a private funtion, Scantable::formatDirection to allow setting precision.

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

File size: 32.9 KB

Rev	Line
[824]	1	//
	2	// C++ Interface: Scantable
	3	//
	4	// Description:
	5	//
	6	//
	7	// Author: Malte Marquarding <asap@atnf.csiro.au>, (C) 2005
	8	//
	9	// Copyright: See COPYING file that comes with this distribution
	10	//
	11	//
	12	#ifndef ASAPSCANTABLE_H
	13	#define ASAPSCANTABLE_H
[2]	14
	15	// STL
[2186]	16	#include <fstream>
	17	#include <iostream>
	18	#include <sstream>
[2]	19	#include <string>
	20	#include <vector>
	21	// AIPS++
[455]	22	#include <casa/aips.h>
[322]	23	#include <casa/Arrays/MaskedArray.h>
[2186]	24	#include <casa/Arrays/Vector.h>
[80]	25	#include <casa/BasicSL/String.h>
[2186]	26	#include <casa/Containers/Record.h>
	27	#include <casa/Exceptions/Error.h>
	28	#include <casa/Quanta/Quantum.h>
[824]	29	#include <casa/Utilities/CountedPtr.h>
[2186]	30	#include <coordinates/Coordinates/SpectralCoordinate.h>
[824]	31	#include <measures/TableMeasures/ScalarMeasColumn.h>
[2186]	32	#include <scimath/Mathematics/FFTServer.h>
	33	#include <tables/Tables/ArrayColumn.h>
	34	#include <tables/Tables/ScalarColumn.h>
	35	#include <tables/Tables/Table.h>
[1819]	36
[2186]	37	#include "MathUtils.h"
[2767]	38	#include "STBaselineEnum.h"
[2186]	39	#include "STFit.h"
	40	#include "STFitEntry.h"
	41	#include "STFocus.h"
	42	#include "STFrequencies.h"
[901]	43	#include "STHeader.h"
[2186]	44	#include "STHistory.h"
[824]	45	#include "STMolecules.h"
[2186]	46	#include "STPol.h"
[824]	47	#include "STSelector.h"
[2186]	48	#include "STTcal.h"
	49	#include "STWeather.h"
[2]	50
[824]	51	namespace asap {
[2]	52
[2666]	53	class Fitter;
[2773]	54	class STLineFinder;
	55	class STBaselineTable;
[2666]	56
[824]	57	/**
	58	* This class contains and wraps a casa::Table, which is used to store
	59	* all the information. This can be either a MemoryTable or a
	60	* disk based Table.
	61	* It provides access functions to the underlying table
	62	* It contains n subtables:
	63	* @li weather
	64	* @li frequencies
	65	* @li molecules
	66	* @li tcal
	67	* @li focus
	68	* @li fits
	69	*
	70	* @brief The main ASAP data container
	71	* @author Malte Marquarding
	72	* @date
	73	* @version
	74	*/
[2658]	75	class Scantable
[824]	76	{
[902]	77
	78	friend class STMath;
	79
[2]	80	public:
[824]	81	/**
	82	* Default constructor
	83	*/
[1350]	84	explicit Scantable(casa::Table::TableType ttype = casa::Table::Memory);
[19]	85
[824]	86	/**
[2321]	87	* Create a Scantable object from an existing table on disk
[824]	88	* @param[in] name the name of the existing Scantable
	89	*/
[2321]	90	explicit Scantable(const std::string& name,
	91	casa::Table::TableType ttype = casa::Table::Memory);
[2]	92
[824]	93	/// @fixme this is only sensible for MemoryTables....
	94	Scantable(const Scantable& other, bool clear=true);
[161]	95
[824]	96	/**
	97	* Destructor
	98	*/
	99	virtual ~Scantable();
[745]	100
[824]	101	/**
	102	* get a const reference to the underlying casa::Table
[1104]	103	* @return const \ref casa::Table reference
[824]	104	*/
	105	const casa::Table& table() const;
[19]	106
[824]	107	/**
	108	* get a reference to the underlying casa::Table with the Selection
	109	* object applied if set
	110	* @return casa::Table reference
	111	*/
	112	casa::Table& table();
[21]	113
[845]	114
	115	/**
	116	* Get a handle to the selection object
	117	* @return constant STSelector reference
	118	*/
	119	const STSelector& getSelection() const { return selector_; }
	120
	121	/**
	122	* Set the data to be a subset as defined by the STSelector
	123	* @param selection a STSelector object
	124	*/
[824]	125	void setSelection(const STSelector& selection);
[845]	126
	127	/**
	128	* unset the selection of the data
	129	*/
[824]	130	void unsetSelection();
	131	/**
	132	* set the header
[1295]	133	* @param[in] sth an STHeader object
[824]	134	*/
[901]	135	void setHeader( const STHeader& sth );
[386]	136
[824]	137	/**
	138	* get the header information
[901]	139	* @return an STHeader object
[824]	140	*/
[901]	141	STHeader getHeader( ) const;
[1068]	142
[824]	143	/**
	144	* Checks if the "other" Scantable is conformant with this,
	145	* i.e. if header values are the same.
	146	* @param[in] other another Scantable
	147	* @return true or false
	148	*/
	149	bool conformant( const Scantable& other);
[430]	150
[824]	151	/**
[1068]	152	*
	153	* @param stype The type of the source, 0 = on, 1 = off
	154	*/
	155	void setSourceType(int stype);
	156
[2818]	157	/**
	158	*
	159	* @param stype The name of the source
	160	*/
	161	void setSourceName(const std::string& name);
[1068]	162
[2818]	163
[1068]	164	/**
[1104]	165	* The number of scans in the table
[824]	166	* @return number of scans in the table
	167	*/
[845]	168	int nscan() const;
[490]	169
[915]	170	casa::MEpoch::Types getTimeReference() const;
[21]	171
[1411]	172
	173	casa::MEpoch getEpoch(int whichrow) const;
	174
[824]	175	/**
	176	* Get global antenna position
[845]	177	* @return casa::MPosition
[824]	178	*/
	179	casa::MPosition getAntennaPosition() const;
[490]	180
[1441]	181	/**
	182	* the @ref casa::MDirection for a specific row
	183	* @param[in] whichrow the row number
	184	* return casa::MDirection
	185	*/
[987]	186	casa::MDirection getDirection( int whichrow ) const;
[1598]	187
[1441]	188	/**
	189	* get the direction type as a string, e.g. "J2000"
	190	* @param[in] whichrow the row number
	191	* return the direction string
	192	*/
[1068]	193	std::string getDirectionString( int whichrow ) const;
	194
[1441]	195	/**
	196	* set the direction type as a string, e.g. "J2000"
	197	* @param[in] refstr the direction type
	198	*/
[987]	199	void setDirectionRefString(const std::string& refstr="");
[1441]	200
[1104]	201	/**
	202	* get the direction reference string
	203	* @return a string describing the direction reference
	204	*/
[1598]	205	std::string getDirectionRefString() const;
[987]	206
[824]	207	/**
[845]	208	* Return the Flux unit of the data, e.g. "Jy" or "K"
	209	* @return string
[824]	210	*/
	211	std::string getFluxUnit() const;
[472]	212
[824]	213	/**
[845]	214	* Set the Flux unit of the data
	215	* @param unit a string representing the unit, e.g "Jy" or "K"
[824]	216	*/
	217	void setFluxUnit( const std::string& unit );
[472]	218
[824]	219	/**
[1189]	220	* Set the Stokes type of the data
[1295]	221	* @param feedtype a string representing the type, e.g "circular" or "linear"
[1189]	222	*/
	223	void setFeedType( const std::string& feedtype );
	224
	225	/**
[824]	226	*
[845]	227	* @param instrument a string representing an insturment. see xxx
[824]	228	*/
	229	void setInstrument( const std::string& instrument );
[2]	230
[845]	231	/**
	232	* (Re)calculate the azimuth and elevationnfor all rows
	233	*/
[824]	234	void calculateAZEL();
[745]	235
[824]	236	/**
[845]	237	* "hard" flag the data, this flags everything selected in setSelection()
[1104]	238	* param[in] msk a boolean mask of length nchan describing the points to
	239	* to be flagged
[824]	240	*/
[1430]	241	//void flag( const std::vector<bool>& msk = std::vector<bool>());
[1994]	242	//void flag( const std::vector<bool>& msk = std::vector<bool>(), bool unflag=false);
[455]	243
[1994]	244	void flag( int whichrow = -1, const std::vector<bool>& msk = std::vector<bool>(), bool unflag=false);
	245
[852]	246	/**
[1819]	247	* Flag the data in a row-based manner. (CAS-1433 Wataru Kawasaki)
	248	* param[in] rows list of row numbers to be flagged
	249	*/
	250	void flagRow( const std::vector<casa::uInt>& rows = std::vector<casa::uInt>(), bool unflag=false);
	251
	252	/**
	253	* Get flagRow info at the specified row. If true, the whole data
	254	* at the row should be flagged.
	255	*/
	256	bool getFlagRow(int whichrow) const
	257	{ return (flagrowCol_(whichrow) > 0); }
	258
	259	/**
	260	* Flag the data outside a specified range (in a channel-based manner).
	261	* (CAS-1807 Wataru Kawasaki)
	262	*/
	263	void clip(const casa::Float uthres, const casa::Float dthres, bool clipoutside, bool unflag);
	264
	265	/**
	266	* Return a list of booleans with the size of nchan for a specified row, to get info
	267	* about which channel is clipped.
	268	*/
	269	std::vector<bool> getClipMask(int whichrow, const casa::Float uthres, const casa::Float dthres, bool clipoutside, bool unflag);
	270	void srchChannelsToClip(casa::uInt whichrow, const casa::Float uthres, const casa::Float dthres, bool clipoutside, bool unflag,
	271	casa::Vector<casa::uChar> flgs);
	272
	273	/**
[852]	274	* Return a list of row numbers with respect to the original table.
[902]	275	* @return a list of unsigned ints
[852]	276	*/
	277	std::vector<unsigned int> rownumbers() const;
[845]	278
[852]	279
[845]	280	/**
	281	* Get the number of beams in the data or a specific scan
	282	* @param scanno the scan number to get the number of beams for.
	283	* If scanno<0 the number is retrieved from the header.
	284	* @return an integer number
	285	*/
[824]	286	int nbeam(int scanno=-1) const;
[845]	287	/**
	288	* Get the number of IFs in the data or a specific scan
	289	* @param scanno the scan number to get the number of IFs for.
	290	* If scanno<0 the number is retrieved from the header.
	291	* @return an integer number
	292	*/
[824]	293	int nif(int scanno=-1) const;
[845]	294	/**
	295	* Get the number of polarizations in the data or a specific scan
	296	* @param scanno the scan number to get the number of polarizations for.
	297	* If scanno<0 the number is retrieved from the header.
	298	* @return an integer number
	299	*/
[824]	300	int npol(int scanno=-1) const;
[794]	301
[896]	302	std::string getPolType() const;
	303
[845]	304
	305	/**
	306	* Get the number of integartion cycles
	307	* @param scanno the scan number to get the number of rows for.
	308	* If scanno<0 the number is retrieved from the header.
[1104]	309	* @return the number of rows (for the specified scanno)
[845]	310	*/
[824]	311	int nrow(int scanno=-1) const;
[794]	312
[1111]	313	int getBeam(int whichrow) const;
[1694]	314	std::vector<uint> getBeamNos() const { return getNumbers(beamCol_); }
[50]	315
[847]	316	int getIF(int whichrow) const;
[1694]	317	std::vector<uint> getIFNos() const { return getNumbers(ifCol_); }
[1111]	318
[847]	319	int getPol(int whichrow) const;
[1694]	320	std::vector<uint> getPolNos() const { return getNumbers(polCol_); }
[1111]	321
[1694]	322	std::vector<uint> getScanNos() const { return getNumbers(scanCol_); }
[865]	323	int getScan(int whichrow) const { return scanCol_(whichrow); }
[1111]	324
[2667]	325	std::vector<uint> getCycleNos() const { return getNumbers(cycleCol_); }
	326	int getCycle(int whichrow) const { return cycleCol_(whichrow); }
	327
[1819]	328	//TT addition
	329	std::vector<uint> getMolNos() {return getNumbers(mmolidCol_); }
	330
[1111]	331	/**
	332	* Get the number of channels in the data or a specific IF. This currently
	333	* varies only with IF number
	334	* @param ifno the IF number to get the number of channels for.
	335	* If ifno<0 the number is retrieved from the header.
	336	* @return an integer number
	337	*/
	338	int nchan(int ifno=-1) const;
[923]	339	int getChannels(int whichrow) const;
[206]	340
[1111]	341	int ncycle(int scanno=-1) const;
	342
[2667]	343
[847]	344	double getInterval(int whichrow) const
	345	{ return integrCol_(whichrow); }
[845]	346
[865]	347	float getTsys(int whichrow) const
	348	{ return casa::Vector<casa::Float>(tsysCol_(whichrow))(0); }
[2161]	349	std::vector<float> getTsysSpectrum(int whichrow) const ;
[2791]	350
	351	void setTsys(const std::vector<float>& newvals, int whichrow);
	352
[847]	353	float getElevation(int whichrow) const
	354	{ return elCol_(whichrow); }
	355	float getAzimuth(int whichrow) const
	356	{ return azCol_(whichrow); }
[865]	357	float getParAngle(int whichrow) const
[1819]	358	{ return focus().getParAngle(mfocusidCol_(whichrow)); }
	359	int getTcalId(int whichrow) const
	360	{ return mtcalidCol_(whichrow); }
[386]	361
[865]	362	std::string getSourceName(int whichrow) const
	363	{ return srcnCol_(whichrow); }
	364
[847]	365	std::vector<bool> getMask(int whichrow) const;
[896]	366	std::vector<float> getSpectrum(int whichrow,
[905]	367	const std::string& poltype = "" ) const;
[847]	368
[884]	369	void setSpectrum(const std::vector<float>& spec, int whichrow);
	370
[902]	371	std::string getPolarizationLabel(int index, const std::string& ptype) const
	372	{ return STPol::getPolLabel(index, ptype ); }
[401]	373
[845]	374	/**
	375	* Write the Scantable to disk
	376	* @param filename the output file name
	377	*/
[824]	378	void makePersistent(const std::string& filename);
[745]	379
[2820]	380	std::vector<std::string> getHistory(int nrow=-1, int start=0) const
	381	{ return historyTable_.getHistory(nrow, start); }
[483]	382
[2820]	383	uint historyLength()
	384	{ return historyTable_.nrow(); }
	385
	386	void dropHistory() { historyTable_.drop(); }
	387
[860]	388	void addHistory(const std::string& hist) { historyTable_.addEntry(hist); }
[488]	389
[860]	390	void appendToHistoryTable(const STHistory& otherhist)
	391	{ historyTable_.append(otherhist); }
	392
[2163]	393	std::string headerSummary();
[2290]	394	void summary(const std::string& filename="");
	395	std::string oldheaderSummary();
[2286]	396	// std::string summary();
[2290]	397	void oldsummary(const std::string& filename="");
	398
[1947]	399	//std::string getTime(int whichrow=-1, bool showdate=true) const;
[2818]	400	std::string getTime(int whichrow=-1, bool showdate=true,
	401	casa::uInt prec=0) const;
[1350]	402	double getIntTime(int whichrow) const { return integrCol_(whichrow); }
[19]	403
[847]	404	// returns unit, conversion frame, doppler, base-frame
[18]	405
[847]	406	/**
	407	* Get the frequency set up
	408	* This is forwarded to the STFrequencies subtable
	409	* @return unit, frame, doppler
	410	*/
	411	std::vector<std::string> getCoordInfo() const
	412	{ return freqTable_.getInfo(); };
	413
	414	void setCoordInfo(std::vector<string> theinfo)
	415	{ return freqTable_.setInfo(theinfo); };
	416
[865]	417
	418	std::vector<double> getAbcissa(int whichrow) const;
	419
[1730]	420	std::vector<float> getWeather(int whichrow) const;
	421
[847]	422	std::string getAbcissaLabel(int whichrow) const;
	423	std::vector<double> getRestFrequencies() const
	424	{ return moleculeTable_.getRestFrequencies(); }
[1819]	425	std::vector<double> getRestFrequency(int id) const
	426	{ return moleculeTable_.getRestFrequency(id); }
[847]	427
[1819]	428	/**
[1170]	429	void setRestFrequencies(double rf, const std::string& name = "",
	430	const std::string& = "Hz");
[1819]	431	**/
	432	// Modified by Takeshi Nakazato 05/09/2008
	433	/***
	434	void setRestFrequencies(vector<double> rf, const vector<std::string>& name = "",
	435	const std::string& = "Hz");
	436	***/
	437	void setRestFrequencies(vector<double> rf,
	438	const vector<std::string>& name = vector<std::string>(1,""),
	439	const std::string& = "Hz");
[847]	440
[1819]	441	//void setRestFrequencies(const std::string& name);
	442	void setRestFrequencies(const vector<std::string>& name);
	443
[1360]	444	void shift(int npix);
	445
[1598]	446	casa::SpectralCoordinate getSpectralCoordinate(int whichrow) const;
	447
[987]	448	void convertDirection(const std::string& newframe);
	449
[824]	450	STFrequencies& frequencies() { return freqTable_; }
[1375]	451	const STFrequencies& frequencies() const { return freqTable_; }
[824]	452	STWeather& weather() { return weatherTable_; }
[1375]	453	const STWeather& weather() const { return weatherTable_; }
[824]	454	STFocus& focus() { return focusTable_; }
[1375]	455	const STFocus& focus() const { return focusTable_; }
[824]	456	STTcal& tcal() { return tcalTable_; }
[1375]	457	const STTcal& tcal() const { return tcalTable_; }
[824]	458	STMolecules& molecules() { return moleculeTable_; }
[1375]	459	const STMolecules& molecules() const { return moleculeTable_; }
[860]	460	STHistory& history() { return historyTable_; }
[1375]	461	const STHistory& history() const { return historyTable_; }
[972]	462	STFit& fit() { return fitTable_; }
[1375]	463	const STFit& fit() const { return fitTable_; }
[2]	464
[902]	465	std::vector<std::string> columnNames() const;
[896]	466
[972]	467	void addFit(const STFitEntry& fit, int row);
	468	STFitEntry getFit(int row) const
	469	{ STFitEntry fe; fitTable_.getEntry(fe, mfitidCol_(row)); return fe; }
	470
[1391]	471	//Added by TT
	472	/**
	473	* Get the antenna name
	474	* @return antenna name string
	475	*/
[1819]	476	casa::String getAntennaName() const;
[1391]	477
	478	/**
	479	* For GBT MS data only. check a scan list
	480	* against the information found in GBT_GO table for
	481	* scan number orders to get correct pairs.
	482	* @param[in] scan list
	483	* @return status
	484	*/
	485	int checkScanInfo(const std::vector<int>& scanlist) const;
	486
	487	/**
	488	* Get the direction as a vector, for a specific row
	489	* @param[in] whichrow the row numbyyer
	490	* @return the direction in a vector
	491	*/
	492	std::vector<double> getDirectionVector(int whichrow) const;
	493
[1586]	494	/**
	495	* Set a flag indicating whether the data was parallactified
	496	* @param[in] flag true or false
	497	*/
[1598]	498	void parallactify(bool flag)
[2357]	499	{ focusTable_.setParallactify(flag); }
[1727]	500
[1819]	501	/**
	502	* Reshape spectrum
	503	* @param[in] nmin, nmax minimum and maximum channel
	504	* @param[in] irow row number
	505	*
	506	* 30/07/2008 Takeshi Nakazato
	507	**/
	508	void reshapeSpectrum( int nmin, int nmax ) throw( casa::AipsError );
	509	void reshapeSpectrum( int nmin, int nmax, int irow ) ;
	510
	511	/**
	512	* Change channel number under fixed bandwidth
	513	* @param[in] nchan, dnu new channel number and spectral resolution
	514	* @param[in] irow row number
	515	*
	516	* 27/08/2008 Takeshi Nakazato
	517	**/
	518	void regridChannel( int nchan, double dnu ) ;
	519	void regridChannel( int nchan, double dnu, int irow ) ;
[2595]	520	void regridChannel( int nchan, double dnu, double fmin, int irow ) ;
[2435]	521	void regridSpecChannel( double dnu, int nchan=-1 ) ;
	522
[2831]	523	bool isAllChannelsFlagged(casa::uInt whichrow);
[1819]	524
[2811]	525	std::vector<std::string> applyBaselineTable(const std::string& bltable,
	526	const bool returnfitresult,
	527	const std::string& outbltable,
	528	const bool outbltableexists,
	529	const bool overwrite);
	530	std::vector<std::string> subBaseline(const std::vector<std::string>& blInfoList,
	531	const bool returnfitresult,
	532	const std::string& outbltable,
	533	const bool outbltableexists,
	534	const bool overwrite);
[2767]	535	void polyBaseline(const std::vector<bool>& mask,
	536	int order,
	537	float thresClip,
	538	int nIterClip,
[2094]	539	bool getResidual=true,
[2189]	540	const std::string& progressInfo="true,1000",
[2767]	541	const bool outLogger=false,
	542	const std::string& blfile="",
	543	const std::string& bltable="");
[2012]	544	void autoPolyBaseline(const std::vector<bool>& mask,
[2767]	545	int order,
	546	float thresClip,
	547	int nIterClip,
	548	const std::vector<int>& edge,
	549	float threshold=3.0,
	550	int chanAvgLimit=1,
	551	bool getResidual=true,
	552	const std::string& progressInfo="true,1000",
	553	const bool outLogger=false,
	554	const std::string& blfile="",
	555	const std::string& bltable="");
[2645]	556	void chebyshevBaseline(const std::vector<bool>& mask,
	557	int order,
	558	float thresClip,
	559	int nIterClip,
	560	bool getResidual=true,
	561	const std::string& progressInfo="true,1000",
	562	const bool outLogger=false,
[2767]	563	const std::string& blfile="",
	564	const std::string& bltable="");
[2645]	565	void autoChebyshevBaseline(const std::vector<bool>& mask,
	566	int order,
	567	float thresClip,
	568	int nIterClip,
	569	const std::vector<int>& edge,
	570	float threshold=3.0,
	571	int chanAvgLimit=1,
	572	bool getResidual=true,
	573	const std::string& progressInfo="true,1000",
	574	const bool outLogger=false,
[2767]	575	const std::string& blfile="",
	576	const std::string& bltable="");
[2012]	577	void cubicSplineBaseline(const std::vector<bool>& mask,
	578	int nPiece,
	579	float thresClip,
	580	int nIterClip,
[2094]	581	bool getResidual=true,
[2189]	582	const std::string& progressInfo="true,1000",
	583	const bool outLogger=false,
[2767]	584	const std::string& blfile="",
	585	const std::string& bltable="");
[2012]	586	void autoCubicSplineBaseline(const std::vector<bool>& mask,
	587	int nPiece,
	588	float thresClip,
	589	int nIterClip,
	590	const std::vector<int>& edge,
	591	float threshold=3.0,
	592	int chanAvgLimit=1,
[2094]	593	bool getResidual=true,
[2189]	594	const std::string& progressInfo="true,1000",
	595	const bool outLogger=false,
[2767]	596	const std::string& blfile="",
	597	const std::string& bltable="");
[2047]	598	void sinusoidBaseline(const std::vector<bool>& mask,
[2767]	599	const std::string& fftInfo,
[2186]	600	const std::vector<int>& addNWaves,
	601	const std::vector<int>& rejectNWaves,
[2047]	602	float thresClip,
	603	int nIterClip,
[2081]	604	bool getResidual=true,
[2189]	605	const std::string& progressInfo="true,1000",
	606	const bool outLogger=false,
[2767]	607	const std::string& blfile="",
	608	const std::string& bltable="");
[2047]	609	void autoSinusoidBaseline(const std::vector<bool>& mask,
[2767]	610	const std::string& fftInfo,
[2186]	611	const std::vector<int>& addNWaves,
	612	const std::vector<int>& rejectNWaves,
[2047]	613	float thresClip,
	614	int nIterClip,
	615	const std::vector<int>& edge,
	616	float threshold=3.0,
	617	int chanAvgLimit=1,
[2081]	618	bool getResidual=true,
[2189]	619	const std::string& progressInfo="true,1000",
	620	const bool outLogger=false,
[2767]	621	const std::string& blfile="",
	622	const std::string& bltable="");
[2186]	623	std::vector<float> execFFT(const int whichrow,
	624	const std::vector<bool>& inMask,
	625	bool getRealImag=false,
	626	bool getAmplitudeOnly=false);
[2012]	627	float getRms(const std::vector<bool>& mask, int whichrow);
	628	std::string formatBaselineParams(const std::vector<float>& params,
	629	const std::vector<bool>& fixed,
	630	float rms,
[2193]	631	int nClipped,
[2012]	632	const std::string& masklist,
	633	int whichrow,
[2064]	634	bool verbose=false,
[2641]	635	bool csvformat=false,
[2064]	636	int start=-1,
	637	int count=-1,
	638	bool resetparamid=false) const;
[2012]	639	std::string formatPiecewiseBaselineParams(const std::vector<int>& ranges,
	640	const std::vector<float>& params,
	641	const std::vector<bool>& fixed,
	642	float rms,
[2193]	643	int nClipped,
[2012]	644	const std::string& masklist,
	645	int whichrow,
[2641]	646	bool verbose=false,
	647	bool csvformat=false) const;
[2591]	648	std::vector<uint> getMoleculeIdColumnData() const;
	649	void setMoleculeIdColumnData(const std::vector<uint>& molids);
[2888]	650
	651	/**
	652	* Get row idx of root table
	653	**/
	654	std::vector<uint> getRootTableRowNumbers() const;
	655
[2713]	656	double calculateModelSelectionCriteria(const std::string& valname,
	657	const std::string& blfunc,
	658	int order,
	659	const std::vector<bool>& inMask,
	660	int whichrow,
	661	bool useLineFinder,
	662	const std::vector<int>& edge,
	663	float threshold,
	664	int chanAvgLimit);
[2767]	665	static std::vector<bool> getMaskFromMaskList(const int nchan,
[2789]	666	const std::vector<int>& masklist);
	667	static casa::Vector<casa::uInt> getMaskListFromMask(
	668	const std::vector<bool>& mask);
	669	static std::vector<int> splitToIntList(const std::string& str,
	670	const char delim);
	671	static std::vector<string> splitToStringList(const std::string& str,
	672	const char delim);
[1907]	673
[2789]	674	void dropXPol();
[2012]	675
[824]	676	private:
[896]	677
	678	casa::Matrix<casa::Float> getPolMatrix( casa::uInt whichrow ) const;
	679
[824]	680	/**
[2005]	681	* Turns a time value into a formatted string
[824]	682	* @param x
	683	* @return
	684	*/
	685	std::string formatSec(casa::Double x) const;
[18]	686
[824]	687	std::string formatTime(const casa::MEpoch& me, bool showdate)const;
[2818]	688	std::string formatTime(const casa::MEpoch& me, bool showdate,
	689	casa::uInt prec)const;
[22]	690
[824]	691	/**
	692	* Turns a casa::MDirection into a nicely formatted string
	693	* @param md an casa::MDirection
[2969]	694	* @param prec output precision of direction
[824]	695	* @return
	696	*/
[2969]	697	std::string formatDirection(const casa::MDirection& md, casa::Int prec=7) const;
[19]	698
[824]	699	/**
	700	* Create a unique file name for the paged (temporary) table
	701	* @return just the name
	702	*/
	703	static casa::String generateName();
[286]	704
[824]	705	/**
	706	* attach to cached columns
	707	*/
	708	void attach();
[50]	709
[824]	710	/**
	711	* Set up the main casa::Table
	712	*/
	713	void setupMainTable();
[88]	714
[859]	715	void attachSubtables();
[865]	716	void copySubtables(const Scantable& other);
	717
[824]	718	/**
	719	* Convert an "old" asap1 style row index into a new index
	720	* @param[in] therow
	721	* @return and index into @table_
	722	*/
	723	int rowToScanIndex(int therow);
[212]	724
[1694]	725	std::vector<uint> getNumbers(const casa::ScalarColumn<casa::uInt>& col) const;
[1111]	726
[2321]	727	static const casa::uInt version_ = 4;
[286]	728
[824]	729	STSelector selector_;
[236]	730
[824]	731	casa::Table::TableType type_;
[465]	732
[824]	733	// the actual data
	734	casa::Table table_;
	735	casa::Table originalTable_;
[745]	736
[824]	737	STTcal tcalTable_;
	738	STFrequencies freqTable_;
	739	STWeather weatherTable_;
	740	STFocus focusTable_;
	741	STMolecules moleculeTable_;
[860]	742	STHistory historyTable_;
[960]	743	STFit fitTable_;
[860]	744
[824]	745	// Cached Columns to avoid reconstructing them for each row get/put
[847]	746	casa::ScalarColumn<casa::Double> integrCol_;
[824]	747	casa::MDirection::ScalarColumn dirCol_;
[847]	748	casa::MEpoch::ScalarColumn timeCol_;
[923]	749	casa::ScalarColumn<casa::Float> azCol_;
	750	casa::ScalarColumn<casa::Float> elCol_;
[824]	751	casa::ScalarColumn<casa::String> srcnCol_, fldnCol_;
[1819]	752	casa::ScalarColumn<casa::uInt> scanCol_, beamCol_, ifCol_, polCol_, cycleCol_, flagrowCol_;
[1068]	753	casa::ScalarColumn<casa::Int> rbeamCol_, srctCol_;
[865]	754	casa::ArrayColumn<casa::Float> specCol_, tsysCol_;
[824]	755	casa::ArrayColumn<casa::uChar> flagsCol_;
[430]	756
[824]	757	// id in frequencies table
	758	casa::ScalarColumn<casa::uInt> mfreqidCol_;
	759	// id in tcal table
	760	casa::ScalarColumn<casa::uInt> mtcalidCol_;
[430]	761
[824]	762	casa::ArrayColumn<casa::String> histitemCol_;
[972]	763	casa::ScalarColumn<casa::Int> mfitidCol_;
[824]	764	casa::ScalarColumn<casa::uInt> mweatheridCol_;
[322]	765
[824]	766	casa::ScalarColumn<casa::uInt> mfocusidCol_;
	767
	768	casa::ScalarColumn<casa::uInt> mmolidCol_;
	769
[896]	770	static std::map<std::string, STPol::STPolFactory *> factories_;
	771	void initFactories();
	772
[1819]	773	/**
	774	* Add an auxiliary column to the main table and attach it to a
	775	* cached column. Use for adding new columns that the original asap2
	776	* tables do not have.
	777	* @param[in] col reference to the cached column to be attached
	778	* @param[in] colName column name in asap table
	779	* @param[in] defValue default value to fill in the column
	780	*
	781	* 25/10/2009 Wataru Kawasaki
	782	*/
	783	template<class T, class T2> void attachAuxColumnDef(casa::ScalarColumn<T>&,
	784	const casa::String&,
	785	const T2&);
	786	template<class T, class T2> void attachAuxColumnDef(casa::ArrayColumn<T>&,
	787	const casa::String&,
	788	const casa::Array<T2>&);
[1907]	789
[2767]	790	double getNormalPolynomial(int n, double x);
[2645]	791	double getChebyshevPolynomial(int n, double x);
[2773]	792	std::vector<std::vector<double> > getPolynomialModel(int order,
	793	int nchan,
	794	double (Scantable::*pfunc)(int, double));
	795	std::vector<std::vector<std::vector<double> > > getPolynomialModelReservoir(int order,
	796	double (Scantable::*pfunc)(int, double),
	797	std::vector<int>& nChanNos);
[2767]	798	std::vector<float> doPolynomialFitting(const std::vector<float>& data,
	799	const std::vector<bool>& mask,
	800	int order,
	801	std::vector<float>& params,
	802	float& rms,
	803	std::vector<bool>& finalMask,
	804	float clipth,
	805	int clipn);
	806	std::vector<float> doPolynomialFitting(const std::vector<float>& data,
	807	const std::vector<bool>& mask,
	808	int order,
	809	std::vector<float>& params,
	810	float& rms,
	811	std::vector<bool>& finalMask,
	812	int& nClipped,
	813	float thresClip=3.0,
	814	int nIterClip=0,
	815	bool getResidual=true);
[2645]	816	std::vector<float> doChebyshevFitting(const std::vector<float>& data,
[2767]	817	const std::vector<bool>& mask,
	818	int order,
	819	std::vector<float>& params,
	820	float& rms,
	821	std::vector<bool>& finalMask,
	822	float clipth,
	823	int clipn);
	824	std::vector<float> doChebyshevFitting(const std::vector<float>& data,
	825	const std::vector<bool>& mask,
	826	int order,
	827	std::vector<float>& params,
	828	float& rms,
	829	std::vector<bool>& finalMask,
	830	int& nClipped,
	831	float thresClip=3.0,
	832	int nIterClip=0,
	833	bool getResidual=true);
	834	std::vector<float> doLeastSquareFitting(const std::vector<float>& data,
	835	const std::vector<bool>& mask,
[2773]	836	const std::vector<std::vector<double> >& model,
[2767]	837	std::vector<float>& params,
	838	float& rms,
	839	std::vector<bool>& finalMask,
	840	int& nClipped,
	841	float thresClip=3.0,
	842	int nIterClip=0,
	843	bool getResidual=true);
	844	std::vector<float> doCubicSplineFitting(const std::vector<float>& data,
[2645]	845	const std::vector<bool>& mask,
[2767]	846	std::vector<int>& idxEdge,
[2645]	847	std::vector<float>& params,
[2767]	848	float& rms,
[2737]	849	std::vector<bool>& finalMask,
[2767]	850	float clipth,
	851	int clipn);
	852	std::vector<float> doCubicSplineFitting(const std::vector<float>& data,
	853	const std::vector<bool>& mask,
	854	int nPiece,
	855	std::vector<int>& idxEdge,
	856	std::vector<float>& params,
[2737]	857	float& rms,
[2767]	858	std::vector<bool>& finalMask,
	859	float clipth,
	860	int clipn);
[2012]	861	std::vector<float> doCubicSplineFitting(const std::vector<float>& data,
	862	const std::vector<bool>& mask,
[2081]	863	int nPiece,
[2767]	864	bool useGivenPieceBoundary,
[2064]	865	std::vector<int>& idxEdge,
[2012]	866	std::vector<float>& params,
[2767]	867	float& rms,
	868	std::vector<bool>& finalMask,
[2193]	869	int& nClipped,
[2012]	870	float thresClip=3.0,
[2767]	871	int nIterClip=0,
[2094]	872	bool getResidual=true);
[2773]	873	std::vector<float> doCubicSplineLeastSquareFitting(const std::vector<float>& data,
	874	const std::vector<bool>& mask,
	875	const std::vector<std::vector<double> >& model,
	876	int nPiece,
	877	bool useGivenPieceBoundary,
	878	std::vector<int>& idxEdge,
	879	std::vector<float>& params,
	880	float& rms,
	881	std::vector<bool>& finalMask,
	882	int& nClipped,
	883	float thresClip=3.0,
	884	int nIterClip=0,
	885	bool getResidual=true);
[2047]	886	std::vector<float> doSinusoidFitting(const std::vector<float>& data,
	887	const std::vector<bool>& mask,
[2081]	888	const std::vector<int>& waveNumbers,
[2047]	889	std::vector<float>& params,
[2767]	890	float& rms,
	891	std::vector<bool>& finalMask,
	892	float clipth,
	893	int clipn);
	894	std::vector<float> doSinusoidFitting(const std::vector<float>& data,
	895	const std::vector<bool>& mask,
	896	const std::vector<int>& waveNumbers,
	897	std::vector<float>& params,
	898	float& rms,
	899	std::vector<bool>& finalMask,
[2193]	900	int& nClipped,
[2047]	901	float thresClip=3.0,
[2767]	902	int nIterClip=0,
[2094]	903	bool getResidual=true);
[2773]	904	std::vector<std::vector<double> > getSinusoidModel(const std::vector<int>& waveNumbers, int nchan);
	905	std::vector<std::vector<std::vector<double> > > getSinusoidModelReservoir(const std::vector<int>& waveNumbers,
	906	std::vector<int>& nChanNos);
	907	std::vector<int> selectWaveNumbers(const std::vector<int>& addNWaves,
	908	const std::vector<int>& rejectNWaves);
	909	std::vector<int> selectWaveNumbers(const int whichrow,
	910	const std::vector<bool>& chanMask,
	911	//const std::string& fftInfo,
	912	const bool applyFFT,
	913	const std::string& fftMethod,
	914	const std::string& fftThresh,
	915	const std::vector<int>& addNWaves,
	916	const std::vector<int>& rejectNWaves);
	917	int getIdxOfNchan(const int nChan, const std::vector<int>& nChanNos);
[2767]	918	void parseFFTInfo(const std::string& fftInfo,
	919	bool& applyFFT,
	920	std::string& fftMethod,
	921	std::string& fftThresh);
[2773]	922	void parseFFTThresholdInfo(const std::string& fftThresh,
	923	std::string& fftThAttr,
	924	float& fftThSigma,
	925	int& fftThTop);
[2186]	926	void doSelectWaveNumbers(const int whichrow,
	927	const std::vector<bool>& chanMask,
	928	const std::string& fftMethod,
	929	const float fftThSigma,
	930	const int fftThTop,
	931	const std::string& fftThAttr,
	932	std::vector<int>& nWaves);
[2411]	933	void addAuxWaveNumbers(const int whichrow,
	934	const std::vector<int>& addNWaves,
[2186]	935	const std::vector<int>& rejectNWaves,
	936	std::vector<int>& nWaves);
[2411]	937	void setWaveNumberListUptoNyquistFreq(const int whichrow,
	938	std::vector<int>& nWaves);
[2773]	939	void initialiseBaselining(const std::string& blfile,
	940	std::ofstream& ofs,
	941	const bool outLogger,
	942	bool& outTextFile,
	943	bool& csvFormat,
	944	casa::String& coordInfo,
	945	bool& hasSameNchan,
	946	const std::string& progressInfo,
	947	bool& showProgress,
	948	int& minNRow,
	949	casa::Vector<casa::Double>& timeSecCol);
	950	void finaliseBaselining(const bool outBaselineTable,
	951	STBaselineTable* pbt,
	952	const string& bltable,
	953	const bool outTextFile,
	954	std::ofstream& ofs);
	955	void initLineFinder(const std::vector<int>& edge,
	956	const float threshold,
	957	const int chanAvgLimit,
	958	STLineFinder& lineFinder);
[2012]	959	bool hasSameNchanOverIFs();
	960	std::string getMaskRangeList(const std::vector<bool>& mask,
	961	int whichrow,
	962	const casa::String& coordInfo,
[2047]	963	bool hasSameNchan,
	964	bool verbose=false);
	965	std::vector<int> getMaskEdgeIndices(const std::vector<bool>& mask);
[2641]	966	std::string formatBaselineParamsHeader(int whichrow, const std::string& masklist, bool verbose, bool csvformat) const;
	967	std::string formatBaselineParamsFooter(float rms, int nClipped, bool verbose, bool csvformat) const;
[2012]	968	std::vector<bool> getCompositeChanMask(int whichrow, const std::vector<bool>& inMask);
[2773]	969	std::vector<bool> getCompositeChanMask(int whichrow, const std::vector<bool>& inMask, const std::vector<int>& edge, std::vector<int>& currEdge, STLineFinder& lineFinder);
[2641]	970	void outputFittingResult(bool outLogger, bool outTextFile, bool csvFormat, const std::vector<bool>& chanMask, int whichrow, const casa::String& coordInfo, bool hasSameNchan, std::ofstream& ofs, const casa::String& funcName, const std::vector<int>& edge, const std::vector<float>& params, const int nClipped);
	971	void outputFittingResult(bool outLogger, bool outTextFile, bool csvFormat, const std::vector<bool>& chanMask, int whichrow, const casa::String& coordInfo, bool hasSameNchan, std::ofstream& ofs, const casa::String& funcName, const std::vector<float>& params, const int nClipped);
[2189]	972	void parseProgressInfo(const std::string& progressInfo, bool& showProgress, int& minNRow);
	973	void showProgressOnTerminal(const int nProcessed, const int nTotal, const bool showProgress=true, const int nTotalThreshold=1000);
[1994]	974
	975	void applyChanFlag( casa::uInt whichrow, const std::vector<bool>& msk, casa::uChar flagval);
	976
[2713]	977	double doCalculateModelSelectionCriteria(const std::string& valname,
	978	const std::vector<float>& spec,
	979	const std::vector<bool>& mask,
	980	const std::string& blfunc,
	981	int order);
[2737]	982	double doGetRms(const std::vector<bool>& mask, const casa::Vector<casa::Float>& spec);
[2767]	983	std::string packFittingResults(const int irow, const std::vector<float>& params, const float rms);
	984	void parseBlInfo(const std::string& blInfo, int& whichrow, STBaselineFunc::FuncName& ftype, std::vector<int>& fpar, std::vector<bool>& mask, float& thresClip, int& nIterClip, bool& useLineFinder, float& thresLF, std::vector<int>& edgeLF, int& avgLF);
	985	std::vector<float> doApplyBaselineTable(std::vector<float>& spec, std::vector<bool>& mask, const STBaselineFunc::FuncName ftype, std::vector<int>& fpar, std::vector<float>& params, float&rms);
	986	std::vector<float> doSubtractBaseline(std::vector<float>& spec, std::vector<bool>& mask, const STBaselineFunc::FuncName ftype, std::vector<int>& fpar, std::vector<float>& params, float&rms, std::vector<bool>& finalmask, float clipth, int clipn, bool uself, int irow, float lfth, std::vector<int>& lfedge, int lfavg);
[2713]	987
[2]	988	};
[824]	989	} // namespace
	990
[2]	991	#endif

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

Download in other formats: