source: branches/alma/src/STMathWrapper.h@ 1661

Last change on this file since 1661 was 1633, checked in by Takeshi Nakazato, 15 years ago

New Development: No

JIRA Issue: Yes CAS-1422

Ready to Release: Yes

Interface Changes: Yes

What Interface Changed: Defined calibrate() and almacal() in python/asapmath.py

Defined cwcal() in STMath class

Test Programs: List test programs

Put in Release Notes: Yes

Module(s): task_sdaverage

Description: Describe your changes here...

asapmath.py is changed to be able to calibrate data for APEX.
This modification is tentatively considered a calibration of ALMA
single-dish data. However, it must be updated in the future since
I don't know how raw ALMA data are provided and I have to change
code along with read ALMA data.

The calibrate() function takes calibration mode from its argument and
looks antenna name of the input scantable, and calls appropriate calibration
function depending on the calibration mode and antenna name.
If antenna name include 'APEX' or 'ALMA', newly defined calibration function
apexcal() is called. For other antenna name, one of the existing calibration
functions (calps, calnod, calfs, auto_quotient) is called.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 8.2 KB
Line 
1//
2// C++ Interface: STMathWrapper
3//
4// Description:
5//
6//
7// Author: Malte Marquarding <Malte.Marquarding@csiro.au>, (C) 2006
8//
9// Copyright: See COPYING file that comes with this distribution
10//
11//
12#ifndef ASAPSTMATHWRAPPER_H
13#define ASAPSTMATHWRAPPER_H
14
15#include <vector>
16#include <string>
17
18#include <casa/Utilities/CountedPtr.h>
19
20#include "STMath.h"
21#include "Scantable.h"
22#include "ScantableWrapper.h"
23
24namespace asap {
25
26/**
27Wrapper class to handle ScantableWrapper
28
29@author Malte Marquarding
30*/
31class STMathWrapper : public STMath {
32public:
33 STMathWrapper() {;}
34 explicit STMathWrapper(bool insitu) : STMath(insitu) {;}
35
36 virtual ~STMathWrapper() {;}
37
38 ScantableWrapper
39 average( const std::vector<ScantableWrapper>& in,
40 const std::vector<bool>& mask,
41 const std::string& weight,
42 const std::string& avmode )
43 {
44 std::vector<casa::CountedPtr<Scantable> > sts;
45 for (unsigned int i=0; i<in.size(); ++i) sts.push_back(in[i].getCP());
46 return ScantableWrapper(STMath::average(sts, mask, weight, avmode));
47 }
48
49 ScantableWrapper
50 averageChannel( const ScantableWrapper& in,
51 const std::string& mode = "MEDIAN",
52 const std::string& avmode = "NONE")
53 {
54 return ScantableWrapper(STMath::averageChannel(in.getCP(), mode, avmode));
55 }
56
57 ScantableWrapper
58 averagePolarisations( const ScantableWrapper& in,
59 const std::vector<bool>& mask,
60 const std::string& weight)
61 { return ScantableWrapper(STMath::averagePolarisations(in.getCP(),mask, weight));}
62
63 ScantableWrapper
64 averageBeams( const ScantableWrapper& in,
65 const std::vector<bool>& mask,
66 const std::string& weight)
67
68 { return ScantableWrapper(STMath::averageBeams(in.getCP(),mask, weight));}
69
70 ScantableWrapper
71 unaryOperate( const ScantableWrapper& in, float val,
72 const std::string& mode, bool tsys=false )
73 { return ScantableWrapper(STMath::unaryOperate(in.getCP(), val, mode, tsys)); }
74
75 ScantableWrapper binaryOperate( const ScantableWrapper& left,
76 const ScantableWrapper& right,
77 const std::string& mode)
78 { return ScantableWrapper( STMath::binaryOperate( left.getCP(), right.getCP(),
79 mode ) ); }
80
81
82 ScantableWrapper autoQuotient( const ScantableWrapper& in,
83 const std::string& mode = "NEAREST",
84 bool preserve = true )
85 { return ScantableWrapper(STMath::autoQuotient(in.getCP(), mode, preserve)); }
86
87 ScantableWrapper quotient( const ScantableWrapper& on,
88 const ScantableWrapper& off,
89 bool preserve = true )
90 { return ScantableWrapper( STMath::quotient( on.getCP(), off.getCP(),
91 preserve ) ); }
92
93 ScantableWrapper dototalpower( const ScantableWrapper& calon,
94 const ScantableWrapper& caloff, casa::Float tcal= 0 )
95 { return ScantableWrapper( STMath::dototalpower( calon.getCP(), caloff.getCP(), tcal ) ); }
96
97 ScantableWrapper dosigref( const ScantableWrapper& sig,
98 const ScantableWrapper& ref,
99 int smoothref = 0, casa::Float tsysv=0.0, casa::Float tau=0.0)
100 { return ScantableWrapper( STMath::dosigref( sig.getCP(), ref.getCP(), smoothref, tsysv, tau ) ); }
101
102 ScantableWrapper donod( const ScantableWrapper& s,
103 const std::vector<int>& scans,
104 int smoothref = 0,
105 casa::Float tsysv=0.0, casa::Float tau=0.0, casa::Float tcal=0.0 )
106 { return ScantableWrapper( STMath::donod( s.getCP(), scans, smoothref, tsysv, tau, tcal ) ); }
107
108 ScantableWrapper dofs( const ScantableWrapper& s,
109 const std::vector<int>& scans,
110 int smoothref = 0,
111 casa::Float tsysv=0.0, casa::Float tau=0.0, casa::Float tcal=0.0 )
112 { return ScantableWrapper( STMath::dofs( s.getCP(), scans, smoothref, tsysv, tau, tcal ) ); }
113
114 ScantableWrapper
115 freqSwitch( const ScantableWrapper& in )
116 { return ScantableWrapper(STMath::freqSwitch(in.getCP())); }
117
118 std::vector<float> statistic(const ScantableWrapper& in,
119 const std::vector<bool>& mask,
120 const std::string& which)
121 { return STMath::statistic(in.getCP(), mask, which); }
122
123 std::vector<int> minMaxChan(const ScantableWrapper& in,
124 const std::vector<bool>& mask,
125 const std::string& which)
126 { return STMath::minMaxChan(in.getCP(), mask, which); }
127
128 ScantableWrapper bin( const ScantableWrapper& in, int width=5)
129 { return ScantableWrapper(STMath::bin(in.getCP(), width)); }
130
131 ScantableWrapper
132 resample(const ScantableWrapper& in,
133 const std::string& method, float width)
134 { return ScantableWrapper(STMath::resample(in.getCP(), method, width)); }
135
136 ScantableWrapper
137 smooth(const ScantableWrapper& in, const std::string& kernel, float width)
138 { return ScantableWrapper(STMath::smooth(in.getCP(), kernel, width)); }
139
140 ScantableWrapper
141 gainElevation(const ScantableWrapper& in,
142 const std::vector<float>& coeff,
143 const std::string& filename,
144 const std::string& method)
145
146 { return
147 ScantableWrapper(STMath::gainElevation(in.getCP(), coeff, filename, method)); }
148
149 ScantableWrapper
150 convertFlux(const ScantableWrapper& in, float d,
151 float etaap, float jyperk)
152 { return ScantableWrapper(STMath::convertFlux(in.getCP(), d, etaap, jyperk)); }
153
154 ScantableWrapper opacity(const ScantableWrapper& in,
155 float tau)
156 { return ScantableWrapper(STMath::opacity(in.getCP(), tau)); }
157
158 ScantableWrapper
159 merge(const std::vector<ScantableWrapper >& in)
160
161 {
162 std::vector<casa::CountedPtr<Scantable> > sts;
163 for (unsigned int i=0; i<in.size(); ++i) sts.push_back(in[i].getCP());
164 return ScantableWrapper(STMath::merge(sts)); }
165
166 ScantableWrapper rotateXYPhase( const ScantableWrapper& in, float angle)
167 { return ScantableWrapper(STMath::rotateXYPhase(in.getCP(), angle)); }
168
169 ScantableWrapper rotateLinPolPhase( const ScantableWrapper& in, float angle)
170 { return ScantableWrapper(STMath::rotateLinPolPhase(in.getCP(), angle)); }
171
172 ScantableWrapper invertPhase( const ScantableWrapper& in )
173 { return ScantableWrapper(STMath::invertPhase(in.getCP())); }
174
175 ScantableWrapper swapPolarisations( const ScantableWrapper& in )
176 { return ScantableWrapper(STMath::swapPolarisations(in.getCP())); }
177
178 ScantableWrapper frequencyAlign( const ScantableWrapper& in,
179 const std::string& refTime,
180 const std::string& method )
181 { return ScantableWrapper(STMath::frequencyAlign(in.getCP())); }
182
183 ScantableWrapper convertPolarisation( const ScantableWrapper& in,
184 const std::string& newtype )
185 { return ScantableWrapper(STMath::convertPolarisation(in.getCP(),newtype)); }
186
187 ScantableWrapper mxExtract( const ScantableWrapper& in,
188 const std::string& scantype="on" )
189 { return ScantableWrapper(STMath::mxExtract(in.getCP(),scantype)); }
190
191 ScantableWrapper lagFlag( const ScantableWrapper& in,
192 double frequency, double width )
193 { return ScantableWrapper(STMath::lagFlag(in.getCP(), frequency, width)); }
194
195 // test for average spectra with different channel/resolution
196 ScantableWrapper
197 new_average( const std::vector<ScantableWrapper>& in,
198 const bool& compel,
199 const std::vector<bool>& mask,
200 const std::string& weight,
201 const std::string& avmode )
202 {
203 std::vector<casa::CountedPtr<Scantable> > sts;
204 for (unsigned int i=0; i<in.size(); ++i) sts.push_back(in[i].getCP());
205 return ScantableWrapper(STMath::new_average(sts, compel, mask, weight, avmode));
206 }
207
208 // cwcal
209 ScantableWrapper cwcal( const ScantableWrapper &in,
210 const std::string calmode,
211 const std::string antname )
212 {
213 casa::CountedPtr<Scantable> tab = in.getCP() ;
214 casa::String mode( calmode ) ;
215 casa::String name( antname ) ;
216 return ScantableWrapper( STMath::cwcal( tab, mode, name ) ) ;
217 }
218};
219
220}
221
222#endif
Note: See TracBrowser for help on using the repository browser.