Context Navigation

source: trunk/src/Scantable.h @ 2645

Visit:

Last change on this file since 2645 was 2645, checked in by WataruKawasaki, 12 years ago

New Development: Yes

JIRA Issue: Yes CAS-4145

Ready for Test: Yes

Interface Changes: No

What Interface Changed:

Test Programs:

Put in Release Notes: Yes

Module(s): scantable

Description: added scantable methods [auto_]chebyshev_baseline() to subtract baseline using Chebyshev polynomials.

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

File size: 25.5 KB

Line
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
14
15	// STL
16	#include <fstream>
17	#include <iostream>
18	#include <sstream>
19	#include <string>
20	#include <vector>
21	// AIPS++
22	#include <casa/aips.h>
23	#include <casa/Arrays/MaskedArray.h>
24	#include <casa/Arrays/Vector.h>
25	#include <casa/BasicSL/String.h>
26	#include <casa/Containers/Record.h>
27	#include <casa/Exceptions/Error.h>
28	#include <casa/Quanta/Quantum.h>
29	#include <casa/Utilities/CountedPtr.h>
30
31	#include <coordinates/Coordinates/SpectralCoordinate.h>
32
33	#include <measures/TableMeasures/ScalarMeasColumn.h>
34
35	#include <scimath/Mathematics/FFTServer.h>
36
37	#include <tables/Tables/ArrayColumn.h>
38	#include <tables/Tables/ScalarColumn.h>
39	#include <tables/Tables/Table.h>
40
41	#include "Logger.h"
42	#include "MathUtils.h"
43	#include "STFit.h"
44	#include "STFitEntry.h"
45	#include "STFitter.h"
46	#include "STFocus.h"
47	#include "STFrequencies.h"
48	#include "STHeader.h"
49	#include "STHistory.h"
50	#include "STMolecules.h"
51	#include "STPol.h"
52	#include "STSelector.h"
53	#include "STTcal.h"
54	#include "STWeather.h"
55
56	namespace asap {
57
58	/**
59	* This class contains and wraps a casa::Table, which is used to store
60	* all the information. This can be either a MemoryTable or a
61	* disk based Table.
62	* It provides access functions to the underlying table
63	* It contains n subtables:
64	* @li weather
65	* @li frequencies
66	* @li molecules
67	* @li tcal
68	* @li focus
69	* @li fits
70	*
71	* @brief The main ASAP data container
72	* @author Malte Marquarding
73	* @date
74	* @version
75	*/
76	class Scantable : private Logger
77	{
78
79	friend class STMath;
80
81	public:
82	/**
83	* Default constructor
84	*/
85	explicit Scantable(casa::Table::TableType ttype = casa::Table::Memory);
86
87	/**
88	* Create a Scantable object from an existing table on disk
89	* @param[in] name the name of the existing Scantable
90	*/
91	explicit Scantable(const std::string& name,
92	casa::Table::TableType ttype = casa::Table::Memory);
93
94	/// @fixme this is only sensible for MemoryTables....
95	Scantable(const Scantable& other, bool clear=true);
96
97	/**
98	* Destructor
99	*/
100	virtual ~Scantable();
101
102	/**
103	* get a const reference to the underlying casa::Table
104	* @return const \ref casa::Table reference
105	*/
106	const casa::Table& table() const;
107
108	/**
109	* get a reference to the underlying casa::Table with the Selection
110	* object applied if set
111	* @return casa::Table reference
112	*/
113	casa::Table& table();
114
115
116	/**
117	* Get a handle to the selection object
118	* @return constant STSelector reference
119	*/
120	const STSelector& getSelection() const { return selector_; }
121
122	/**
123	* Set the data to be a subset as defined by the STSelector
124	* @param selection a STSelector object
125	*/
126	void setSelection(const STSelector& selection);
127
128	/**
129	* unset the selection of the data
130	*/
131	void unsetSelection();
132	/**
133	* set the header
134	* @param[in] sth an STHeader object
135	*/
136	void setHeader( const STHeader& sth );
137
138	/**
139	* get the header information
140	* @return an STHeader object
141	*/
142	STHeader getHeader( ) const;
143
144	/**
145	* Checks if the "other" Scantable is conformant with this,
146	* i.e. if header values are the same.
147	* @param[in] other another Scantable
148	* @return true or false
149	*/
150	bool conformant( const Scantable& other);
151
152	/**
153	*
154	* @param stype The type of the source, 0 = on, 1 = off
155	*/
156	void setSourceType(int stype);
157
158
159	/**
160	* The number of scans in the table
161	* @return number of scans in the table
162	*/
163	int nscan() const;
164
165	casa::MEpoch::Types getTimeReference() const;
166
167
168	casa::MEpoch getEpoch(int whichrow) const;
169
170	/**
171	* Get global antenna position
172	* @return casa::MPosition
173	*/
174	casa::MPosition getAntennaPosition() const;
175
176	/**
177	* the @ref casa::MDirection for a specific row
178	* @param[in] whichrow the row number
179	* return casa::MDirection
180	*/
181	casa::MDirection getDirection( int whichrow ) const;
182
183	/**
184	* get the direction type as a string, e.g. "J2000"
185	* @param[in] whichrow the row number
186	* return the direction string
187	*/
188	std::string getDirectionString( int whichrow ) const;
189
190	/**
191	* set the direction type as a string, e.g. "J2000"
192	* @param[in] refstr the direction type
193	*/
194	void setDirectionRefString(const std::string& refstr="");
195
196	/**
197	* get the direction reference string
198	* @return a string describing the direction reference
199	*/
200	std::string getDirectionRefString() const;
201
202	/**
203	* Return the Flux unit of the data, e.g. "Jy" or "K"
204	* @return string
205	*/
206	std::string getFluxUnit() const;
207
208	/**
209	* Set the Flux unit of the data
210	* @param unit a string representing the unit, e.g "Jy" or "K"
211	*/
212	void setFluxUnit( const std::string& unit );
213
214	/**
215	* Set the Stokes type of the data
216	* @param feedtype a string representing the type, e.g "circular" or "linear"
217	*/
218	void setFeedType( const std::string& feedtype );
219
220	/**
221	*
222	* @param instrument a string representing an insturment. see xxx
223	*/
224	void setInstrument( const std::string& instrument );
225
226	/**
227	* (Re)calculate the azimuth and elevationnfor all rows
228	*/
229	void calculateAZEL();
230
231	/**
232	* "hard" flag the data, this flags everything selected in setSelection()
233	* param[in] msk a boolean mask of length nchan describing the points to
234	* to be flagged
235	*/
236	//void flag( const std::vector<bool>& msk = std::vector<bool>());
237	//void flag( const std::vector<bool>& msk = std::vector<bool>(), bool unflag=false);
238
239	void flag( int whichrow = -1, const std::vector<bool>& msk = std::vector<bool>(), bool unflag=false);
240
241	/**
242	* Flag the data in a row-based manner. (CAS-1433 Wataru Kawasaki)
243	* param[in] rows list of row numbers to be flagged
244	*/
245	void flagRow( const std::vector<casa::uInt>& rows = std::vector<casa::uInt>(), bool unflag=false);
246
247	/**
248	* Get flagRow info at the specified row. If true, the whole data
249	* at the row should be flagged.
250	*/
251	bool getFlagRow(int whichrow) const
252	{ return (flagrowCol_(whichrow) > 0); }
253
254	/**
255	* Flag the data outside a specified range (in a channel-based manner).
256	* (CAS-1807 Wataru Kawasaki)
257	*/
258	void clip(const casa::Float uthres, const casa::Float dthres, bool clipoutside, bool unflag);
259
260	/**
261	* Return a list of booleans with the size of nchan for a specified row, to get info
262	* about which channel is clipped.
263	*/
264	std::vector<bool> getClipMask(int whichrow, const casa::Float uthres, const casa::Float dthres, bool clipoutside, bool unflag);
265	void srchChannelsToClip(casa::uInt whichrow, const casa::Float uthres, const casa::Float dthres, bool clipoutside, bool unflag,
266	casa::Vector<casa::uChar> flgs);
267
268	/**
269	* Return a list of row numbers with respect to the original table.
270	* @return a list of unsigned ints
271	*/
272	std::vector<unsigned int> rownumbers() const;
273
274
275	/**
276	* Get the number of beams in the data or a specific scan
277	* @param scanno the scan number to get the number of beams for.
278	* If scanno<0 the number is retrieved from the header.
279	* @return an integer number
280	*/
281	int nbeam(int scanno=-1) const;
282	/**
283	* Get the number of IFs in the data or a specific scan
284	* @param scanno the scan number to get the number of IFs for.
285	* If scanno<0 the number is retrieved from the header.
286	* @return an integer number
287	*/
288	int nif(int scanno=-1) const;
289	/**
290	* Get the number of polarizations in the data or a specific scan
291	* @param scanno the scan number to get the number of polarizations for.
292	* If scanno<0 the number is retrieved from the header.
293	* @return an integer number
294	*/
295	int npol(int scanno=-1) const;
296
297	std::string getPolType() const;
298
299
300	/**
301	* Get the number of integartion cycles
302	* @param scanno the scan number to get the number of rows for.
303	* If scanno<0 the number is retrieved from the header.
304	* @return the number of rows (for the specified scanno)
305	*/
306	int nrow(int scanno=-1) const;
307
308	int getBeam(int whichrow) const;
309	std::vector<uint> getBeamNos() const { return getNumbers(beamCol_); }
310
311	int getIF(int whichrow) const;
312	std::vector<uint> getIFNos() const { return getNumbers(ifCol_); }
313
314	int getPol(int whichrow) const;
315	std::vector<uint> getPolNos() const { return getNumbers(polCol_); }
316
317	std::vector<uint> getScanNos() const { return getNumbers(scanCol_); }
318	int getScan(int whichrow) const { return scanCol_(whichrow); }
319
320	//TT addition
321	std::vector<uint> getMolNos() {return getNumbers(mmolidCol_); }
322
323	/**
324	* Get the number of channels in the data or a specific IF. This currently
325	* varies only with IF number
326	* @param ifno the IF number to get the number of channels for.
327	* If ifno<0 the number is retrieved from the header.
328	* @return an integer number
329	*/
330	int nchan(int ifno=-1) const;
331	int getChannels(int whichrow) const;
332
333	int ncycle(int scanno=-1) const;
334	int getCycle(int whichrow) const { return cycleCol_(whichrow); }
335
336	double getInterval(int whichrow) const
337	{ return integrCol_(whichrow); }
338
339	float getTsys(int whichrow) const
340	{ return casa::Vector<casa::Float>(tsysCol_(whichrow))(0); }
341	std::vector<float> getTsysSpectrum(int whichrow) const ;
342	float getElevation(int whichrow) const
343	{ return elCol_(whichrow); }
344	float getAzimuth(int whichrow) const
345	{ return azCol_(whichrow); }
346	float getParAngle(int whichrow) const
347	{ return focus().getParAngle(mfocusidCol_(whichrow)); }
348	int getTcalId(int whichrow) const
349	{ return mtcalidCol_(whichrow); }
350
351	std::string getSourceName(int whichrow) const
352	{ return srcnCol_(whichrow); }
353
354	std::vector<bool> getMask(int whichrow) const;
355	std::vector<float> getSpectrum(int whichrow,
356	const std::string& poltype = "" ) const;
357
358	void setSpectrum(const std::vector<float>& spec, int whichrow);
359
360	std::string getPolarizationLabel(int index, const std::string& ptype) const
361	{ return STPol::getPolLabel(index, ptype ); }
362
363	/**
364	* Write the Scantable to disk
365	* @param filename the output file name
366	*/
367	void makePersistent(const std::string& filename);
368
369	std::vector<std::string> getHistory() const
370	{ return historyTable_.getHistory(); };
371
372	void addHistory(const std::string& hist) { historyTable_.addEntry(hist); }
373
374	void appendToHistoryTable(const STHistory& otherhist)
375	{ historyTable_.append(otherhist); }
376
377	std::string headerSummary();
378	void summary(const std::string& filename="");
379	std::string oldheaderSummary();
380	// std::string summary();
381	void oldsummary(const std::string& filename="");
382
383	//std::string getTime(int whichrow=-1, bool showdate=true) const;
384	std::string getTime(int whichrow=-1, bool showdate=true, casa::uInt prec=0) const;
385	double getIntTime(int whichrow) const { return integrCol_(whichrow); }
386
387	// returns unit, conversion frame, doppler, base-frame
388
389	/**
390	* Get the frequency set up
391	* This is forwarded to the STFrequencies subtable
392	* @return unit, frame, doppler
393	*/
394	std::vector<std::string> getCoordInfo() const
395	{ return freqTable_.getInfo(); };
396
397	void setCoordInfo(std::vector<string> theinfo)
398	{ return freqTable_.setInfo(theinfo); };
399
400
401	std::vector<double> getAbcissa(int whichrow) const;
402
403	std::vector<float> getWeather(int whichrow) const;
404
405	std::string getAbcissaLabel(int whichrow) const;
406	std::vector<double> getRestFrequencies() const
407	{ return moleculeTable_.getRestFrequencies(); }
408	std::vector<double> getRestFrequency(int id) const
409	{ return moleculeTable_.getRestFrequency(id); }
410
411	/**
412	void setRestFrequencies(double rf, const std::string& name = "",
413	const std::string& = "Hz");
414	**/
415	// Modified by Takeshi Nakazato 05/09/2008
416	/***
417	void setRestFrequencies(vector<double> rf, const vector<std::string>& name = "",
418	const std::string& = "Hz");
419	***/
420	void setRestFrequencies(vector<double> rf,
421	const vector<std::string>& name = vector<std::string>(1,""),
422	const std::string& = "Hz");
423
424	//void setRestFrequencies(const std::string& name);
425	void setRestFrequencies(const vector<std::string>& name);
426
427	void shift(int npix);
428
429	casa::SpectralCoordinate getSpectralCoordinate(int whichrow) const;
430
431	void convertDirection(const std::string& newframe);
432
433	STFrequencies& frequencies() { return freqTable_; }
434	const STFrequencies& frequencies() const { return freqTable_; }
435	STWeather& weather() { return weatherTable_; }
436	const STWeather& weather() const { return weatherTable_; }
437	STFocus& focus() { return focusTable_; }
438	const STFocus& focus() const { return focusTable_; }
439	STTcal& tcal() { return tcalTable_; }
440	const STTcal& tcal() const { return tcalTable_; }
441	STMolecules& molecules() { return moleculeTable_; }
442	const STMolecules& molecules() const { return moleculeTable_; }
443	STHistory& history() { return historyTable_; }
444	const STHistory& history() const { return historyTable_; }
445	STFit& fit() { return fitTable_; }
446	const STFit& fit() const { return fitTable_; }
447
448	std::vector<std::string> columnNames() const;
449
450	void addFit(const STFitEntry& fit, int row);
451	STFitEntry getFit(int row) const
452	{ STFitEntry fe; fitTable_.getEntry(fe, mfitidCol_(row)); return fe; }
453
454	//Added by TT
455	/**
456	* Get the antenna name
457	* @return antenna name string
458	*/
459	casa::String getAntennaName() const;
460
461	/**
462	* For GBT MS data only. check a scan list
463	* against the information found in GBT_GO table for
464	* scan number orders to get correct pairs.
465	* @param[in] scan list
466	* @return status
467	*/
468	int checkScanInfo(const std::vector<int>& scanlist) const;
469
470	/**
471	* Get the direction as a vector, for a specific row
472	* @param[in] whichrow the row numbyyer
473	* @return the direction in a vector
474	*/
475	std::vector<double> getDirectionVector(int whichrow) const;
476
477	/**
478	* Set a flag indicating whether the data was parallactified
479	* @param[in] flag true or false
480	*/
481	void parallactify(bool flag)
482	{ focusTable_.setParallactify(flag); }
483
484	/**
485	* Reshape spectrum
486	* @param[in] nmin, nmax minimum and maximum channel
487	* @param[in] irow row number
488	*
489	* 30/07/2008 Takeshi Nakazato
490	**/
491	void reshapeSpectrum( int nmin, int nmax ) throw( casa::AipsError );
492	void reshapeSpectrum( int nmin, int nmax, int irow ) ;
493
494	/**
495	* Change channel number under fixed bandwidth
496	* @param[in] nchan, dnu new channel number and spectral resolution
497	* @param[in] irow row number
498	*
499	* 27/08/2008 Takeshi Nakazato
500	**/
501	void regridChannel( int nchan, double dnu ) ;
502	void regridChannel( int nchan, double dnu, int irow ) ;
503	void regridChannel( int nchan, double dnu, double fmin, int irow ) ;
504
505	void regridSpecChannel( double dnu, int nchan=-1 ) ;
506
507	bool getFlagtraFast(casa::uInt whichrow);
508
509	void polyBaseline(const std::vector<bool>& mask,
510	int order,
511	bool getResidual=true,
512	const std::string& progressInfo="true,1000",
513	const bool outLogger=false,
514	const std::string& blfile="");
515	void autoPolyBaseline(const std::vector<bool>& mask,
516	int order,
517	const std::vector<int>& edge,
518	float threshold=3.0,
519	int chanAvgLimit=1,
520	bool getResidual=true,
521	const std::string& progressInfo="true,1000",
522	const bool outLogger=false,
523	const std::string& blfile="");
524	void chebyshevBaseline(const std::vector<bool>& mask,
525	int order,
526	float thresClip,
527	int nIterClip,
528	bool getResidual=true,
529	const std::string& progressInfo="true,1000",
530	const bool outLogger=false,
531	const std::string& blfile="");
532	void autoChebyshevBaseline(const std::vector<bool>& mask,
533	int order,
534	float thresClip,
535	int nIterClip,
536	const std::vector<int>& edge,
537	float threshold=3.0,
538	int chanAvgLimit=1,
539	bool getResidual=true,
540	const std::string& progressInfo="true,1000",
541	const bool outLogger=false,
542	const std::string& blfile="");
543	void cubicSplineBaseline(const std::vector<bool>& mask,
544	int nPiece,
545	float thresClip,
546	int nIterClip,
547	bool getResidual=true,
548	const std::string& progressInfo="true,1000",
549	const bool outLogger=false,
550	const std::string& blfile="");
551	void autoCubicSplineBaseline(const std::vector<bool>& mask,
552	int nPiece,
553	float thresClip,
554	int nIterClip,
555	const std::vector<int>& edge,
556	float threshold=3.0,
557	int chanAvgLimit=1,
558	bool getResidual=true,
559	const std::string& progressInfo="true,1000",
560	const bool outLogger=false,
561	const std::string& blfile="");
562	void sinusoidBaseline(const std::vector<bool>& mask,
563	const bool applyFFT,
564	const std::string& fftMethod,
565	const std::string& fftThresh,
566	const std::vector<int>& addNWaves,
567	const std::vector<int>& rejectNWaves,
568	float thresClip,
569	int nIterClip,
570	bool getResidual=true,
571	const std::string& progressInfo="true,1000",
572	const bool outLogger=false,
573	const std::string& blfile="");
574	void autoSinusoidBaseline(const std::vector<bool>& mask,
575	const bool applyFFT,
576	const std::string& fftMethod,
577	const std::string& fftThresh,
578	const std::vector<int>& addNWaves,
579	const std::vector<int>& rejectNWaves,
580	float thresClip,
581	int nIterClip,
582	const std::vector<int>& edge,
583	float threshold=3.0,
584	int chanAvgLimit=1,
585	bool getResidual=true,
586	const std::string& progressInfo="true,1000",
587	const bool outLogger=false,
588	const std::string& blfile="");
589	std::vector<float> execFFT(const int whichrow,
590	const std::vector<bool>& inMask,
591	bool getRealImag=false,
592	bool getAmplitudeOnly=false);
593	float getRms(const std::vector<bool>& mask, int whichrow);
594	std::string formatBaselineParams(const std::vector<float>& params,
595	const std::vector<bool>& fixed,
596	float rms,
597	int nClipped,
598	const std::string& masklist,
599	int whichrow,
600	bool verbose=false,
601	bool csvformat=false,
602	int start=-1,
603	int count=-1,
604	bool resetparamid=false) const;
605	std::string formatPiecewiseBaselineParams(const std::vector<int>& ranges,
606	const std::vector<float>& params,
607	const std::vector<bool>& fixed,
608	float rms,
609	int nClipped,
610	const std::string& masklist,
611	int whichrow,
612	bool verbose=false,
613	bool csvformat=false) const;
614	std::vector<uint> getMoleculeIdColumnData() const;
615	void setMoleculeIdColumnData(const std::vector<uint>& molids);
616
617
618	private:
619
620	casa::Matrix<casa::Float> getPolMatrix( casa::uInt whichrow ) const;
621
622	/**
623	* Turns a time value into a formatted string
624	* @param x
625	* @return
626	*/
627	std::string formatSec(casa::Double x) const;
628
629	std::string formatTime(const casa::MEpoch& me, bool showdate)const;
630	std::string formatTime(const casa::MEpoch& me, bool showdate, casa::uInt prec)const;
631
632	/**
633	* Turns a casa::MDirection into a nicely formatted string
634	* @param md an casa::MDirection
635	* @return
636	*/
637	std::string formatDirection(const casa::MDirection& md) const;
638
639	/**
640	* Create a unique file name for the paged (temporary) table
641	* @return just the name
642	*/
643	static casa::String generateName();
644
645	/**
646	* attach to cached columns
647	*/
648	void attach();
649
650	/**
651	* Set up the main casa::Table
652	*/
653	void setupMainTable();
654
655	void attachSubtables();
656	void copySubtables(const Scantable& other);
657
658	/**
659	* Convert an "old" asap1 style row index into a new index
660	* @param[in] therow
661	* @return and index into @table_
662	*/
663	int rowToScanIndex(int therow);
664
665	std::vector<uint> getNumbers(const casa::ScalarColumn<casa::uInt>& col) const;
666
667	static const casa::uInt version_ = 4;
668
669	STSelector selector_;
670
671	casa::Table::TableType type_;
672
673	// the actual data
674	casa::Table table_;
675	casa::Table originalTable_;
676
677	STTcal tcalTable_;
678	STFrequencies freqTable_;
679	STWeather weatherTable_;
680	STFocus focusTable_;
681	STMolecules moleculeTable_;
682	STHistory historyTable_;
683	STFit fitTable_;
684
685	// Cached Columns to avoid reconstructing them for each row get/put
686	casa::ScalarColumn<casa::Double> integrCol_;
687	casa::MDirection::ScalarColumn dirCol_;
688	casa::MEpoch::ScalarColumn timeCol_;
689	casa::ScalarColumn<casa::Float> azCol_;
690	casa::ScalarColumn<casa::Float> elCol_;
691	casa::ScalarColumn<casa::String> srcnCol_, fldnCol_;
692	casa::ScalarColumn<casa::uInt> scanCol_, beamCol_, ifCol_, polCol_, cycleCol_, flagrowCol_;
693	casa::ScalarColumn<casa::Int> rbeamCol_, srctCol_;
694	casa::ArrayColumn<casa::Float> specCol_, tsysCol_;
695	casa::ArrayColumn<casa::uChar> flagsCol_;
696
697	// id in frequencies table
698	casa::ScalarColumn<casa::uInt> mfreqidCol_;
699	// id in tcal table
700	casa::ScalarColumn<casa::uInt> mtcalidCol_;
701
702	casa::ArrayColumn<casa::String> histitemCol_;
703	casa::ScalarColumn<casa::Int> mfitidCol_;
704	casa::ScalarColumn<casa::uInt> mweatheridCol_;
705
706	casa::ScalarColumn<casa::uInt> mfocusidCol_;
707
708	casa::ScalarColumn<casa::uInt> mmolidCol_;
709
710	static std::map<std::string, STPol::STPolFactory *> factories_;
711	void initFactories();
712
713	/**
714	* Add an auxiliary column to the main table and attach it to a
715	* cached column. Use for adding new columns that the original asap2
716	* tables do not have.
717	* @param[in] col reference to the cached column to be attached
718	* @param[in] colName column name in asap table
719	* @param[in] defValue default value to fill in the column
720	*
721	* 25/10/2009 Wataru Kawasaki
722	*/
723	template<class T, class T2> void attachAuxColumnDef(casa::ScalarColumn<T>&,
724	const casa::String&,
725	const T2&);
726	template<class T, class T2> void attachAuxColumnDef(casa::ArrayColumn<T>&,
727	const casa::String&,
728	const casa::Array<T2>&);
729
730	void fitBaseline(const std::vector<bool>& mask, int whichrow, Fitter& fitter);
731	double getChebyshevPolynomial(int n, double x);
732	std::vector<float> doChebyshevFitting(const std::vector<float>& data,
733	const std::vector<bool>& mask,
734	int order,
735	std::vector<float>& params,
736	int& nClipped,
737	float thresClip=3.0,
738	int nIterClip=1,
739	bool getResidual=true);
740	std::vector<float> doCubicSplineFitting(const std::vector<float>& data,
741	const std::vector<bool>& mask,
742	int nPiece,
743	std::vector<int>& idxEdge,
744	std::vector<float>& params,
745	int& nClipped,
746	float thresClip=3.0,
747	int nIterClip=1,
748	bool getResidual=true);
749	std::vector<float> doSinusoidFitting(const std::vector<float>& data,
750	const std::vector<bool>& mask,
751	const std::vector<int>& waveNumbers,
752	std::vector<float>& params,
753	int& nClipped,
754	float thresClip=3.0,
755	int nIterClip=1,
756	bool getResidual=true);
757	void selectWaveNumbers(const int whichrow,
758	const std::vector<bool>& chanMask,
759	const bool applyFFT,
760	const std::string& fftMethod,
761	const std::string& fftThresh,
762	const std::vector<int>& addNWaves,
763	const std::vector<int>& rejectNWaves,
764	std::vector<int>& nWaves);
765	void parseThresholdExpression(const std::string& fftThresh,
766	std::string& fftThAttr,
767	float& fftThSigma,
768	int& fftThTop);
769	void doSelectWaveNumbers(const int whichrow,
770	const std::vector<bool>& chanMask,
771	const std::string& fftMethod,
772	const float fftThSigma,
773	const int fftThTop,
774	const std::string& fftThAttr,
775	std::vector<int>& nWaves);
776	void addAuxWaveNumbers(const int whichrow,
777	const std::vector<int>& addNWaves,
778	const std::vector<int>& rejectNWaves,
779	std::vector<int>& nWaves);
780	void setWaveNumberListUptoNyquistFreq(const int whichrow,
781	std::vector<int>& nWaves);
782	bool hasSameNchanOverIFs();
783	std::string getMaskRangeList(const std::vector<bool>& mask,
784	int whichrow,
785	const casa::String& coordInfo,
786	bool hasSameNchan,
787	bool verbose=false);
788	std::vector<int> getMaskEdgeIndices(const std::vector<bool>& mask);
789	std::string formatBaselineParamsHeader(int whichrow, const std::string& masklist, bool verbose, bool csvformat) const;
790	std::string formatBaselineParamsFooter(float rms, int nClipped, bool verbose, bool csvformat) const;
791	std::vector<bool> getCompositeChanMask(int whichrow, const std::vector<bool>& inMask);
792	//std::vector<bool> getCompositeChanMask(int whichrow, const std::vector<bool>& inMask, const std::vector<int>& edge, const int minEdgeSize, STLineFinder& lineFinder);
793	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, Fitter& fitter);
794	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);
795	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);
796	void parseProgressInfo(const std::string& progressInfo, bool& showProgress, int& minNRow);
797	void showProgressOnTerminal(const int nProcessed, const int nTotal, const bool showProgress=true, const int nTotalThreshold=1000);
798
799	void applyChanFlag( casa::uInt whichrow, const std::vector<bool>& msk, casa::uChar flagval);
800
801	};
802
803	} // namespace
804
805	#endif

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

Download in other formats: