source: trunk/src/SDMathWrapper.cc @ 295

Last change on this file since 295 was 295, checked in by kil064, 19 years ago

track some small changes to SDMath interface (addition of
doTSys arg here and there)
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 8.3 KB
Line 
1//#---------------------------------------------------------------------------
2//# SDMathWrapper.cc: Wrapper classes to use CountedPtr
3//#---------------------------------------------------------------------------
4//# Copyright (C) 2004
5//# ATNF
6//#
7//# This program is free software; you can redistribute it and/or modify it
8//# under the terms of the GNU General Public License as published by the Free
9//# Software Foundation; either version 2 of the License, or (at your option)
10//# any later version.
11//#
12//# This program is distributed in the hope that it will be useful, but
13//# WITHOUT ANY WARRANTY; without even the implied warranty of
14//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
15//# Public License for more details.
16//#
17//# You should have received a copy of the GNU General Public License along
18//# with this program; if not, write to the Free Software Foundation, Inc.,
19//# 675 Massachusetts Ave, Cambridge, MA 02139, USA.
20//#
21//# Correspondence concerning this software should be addressed as follows:
22//#        Internet email: Malte.Marquarding@csiro.au
23//#        Postal address: Malte Marquarding,
24//#                        Australia Telescope National Facility,
25//#                        P.O. Box 76,
26//#                        Epping, NSW, 2121,
27//#                        AUSTRALIA
28//#
29//# $Id:
30//#---------------------------------------------------------------------------
31
32
33#include "SDMathWrapper.h"
34#include "SDMath.h"
35
36
37using namespace asap;
38using namespace casa;
39
40SDMemTableWrapper SDMathWrapper::quotient(const SDMemTableWrapper& on,
41                                          const SDMemTableWrapper& off,
42                                          Bool preserveContinuum)
43{
44    SDMath sdm;
45    Bool doTSys = True;
46    return SDMemTableWrapper(sdm.binaryOperate(on.getCP(), off.getCP(),
47                             String("QUOTIENT"), preserveContinuum, doTSys));
48}
49
50
51SDMemTableWrapper SDMathWrapper::binaryOperate(const SDMemTableWrapper& left,
52                                               const SDMemTableWrapper& right,
53                                               const std::string& op, bool doTSys)
54{
55    SDMath sdm;
56    return SDMemTableWrapper(sdm.binaryOperate(left.getCP(), right.getCP(),
57                                               String(op), False, Bool(doTSys)));
58}
59
60
61void SDMathWrapper::scaleInSitu(SDMemTableWrapper& in, float factor, bool doAll, bool doTSys)
62{
63  SDMemTable* pIn = in.getPtr();
64  const uInt what = 0;
65//
66  SDMath sdm;
67  SDMemTable* pOut = sdm.unaryOperate (*pIn, Float(factor),
68                                        Bool(doAll), what, Bool(doTSys));
69  *pIn = *pOut;
70   delete pOut;
71}
72
73SDMemTableWrapper SDMathWrapper::scale(const SDMemTableWrapper& in,
74                                       float factor, bool doAll, bool doTSys)
75{
76  const CountedPtr<SDMemTable>& pIn = in.getCP();
77  const uInt what = 0;
78  SDMath sdm;
79  return CountedPtr<SDMemTable>(sdm.unaryOperate(*pIn, Float(factor), Bool(doAll),
80                                                 what, Bool (doTSys)));
81}
82
83
84
85void SDMathWrapper::addInSitu(SDMemTableWrapper& in, float offset, bool doAll)
86{
87  SDMemTable* pIn = in.getPtr();
88  const uInt what = 1;
89//
90  SDMath sdm;
91  Bool doTSys = False;
92  SDMemTable* pOut = sdm.unaryOperate (*pIn, Float(offset),
93                                        Bool(doAll), what, doTSys);
94  *pIn = *pOut;
95   delete pOut;
96}
97
98SDMemTableWrapper SDMathWrapper::add(const SDMemTableWrapper& in,
99                                     float offset, bool doAll)
100{
101  const CountedPtr<SDMemTable>& pIn = in.getCP();
102  const uInt what = 1;
103  SDMath sdm;
104  Bool doTSys = False;
105  return CountedPtr<SDMemTable>(sdm.unaryOperate(*pIn, Float(offset),
106                                                  Bool(doAll), what, doTSys));
107}
108
109
110void SDMathWrapper::smoothInSitu(SDMemTableWrapper& in,
111                                 const std::string& kernel, float width,
112                                 bool doAll)
113{
114  SDMemTable* pIn = in.getPtr();
115  SDMath sdm;
116  SDMemTable* pOut = sdm.smooth(*pIn, String(kernel),
117                                Float(width), Bool(doAll));
118  *pIn = *pOut;
119   delete pOut;
120}
121
122
123SDMemTableWrapper SDMathWrapper::smooth (const SDMemTableWrapper& in,
124                                         const std::string& kernel,
125                                         float width, bool doAll)
126{
127  const CountedPtr<SDMemTable>& pIn = in.getCP();
128  SDMath sdm;
129  return CountedPtr<SDMemTable>(sdm.smooth(*pIn, String(kernel),
130                                           Float(width), Bool(doAll)));
131}
132
133
134
135void SDMathWrapper::binInSitu(SDMemTableWrapper& in, int width)
136{
137  SDMemTable* pIn = in.getPtr();
138  SDMath sdm;
139  SDMemTable* pOut = sdm.bin (*pIn, Int(width));
140  *pIn = *pOut;
141   delete pOut;
142}
143
144SDMemTableWrapper SDMathWrapper::bin (const SDMemTableWrapper& in,
145                                      int width)
146{
147  const CountedPtr<SDMemTable>& pIn = in.getCP();
148  SDMath sdm;
149  return CountedPtr<SDMemTable>(sdm.bin(*pIn, Int(width)));
150}
151
152
153void SDMathWrapper::averagePolInSitu(SDMemTableWrapper& in,
154                                     const std::vector<bool>& mask)
155{
156  SDMemTable* pIn = in.getPtr();
157  SDMath sdm;
158  Vector<Bool> tMask(mask);
159  SDMemTable* pOut = sdm.averagePol (*pIn, tMask);
160  *pIn = *pOut;
161   delete pOut;
162}
163
164SDMemTableWrapper SDMathWrapper::averagePol (const SDMemTableWrapper& in,
165                                             const std::vector<bool>& mask)
166
167{
168  const CountedPtr<SDMemTable>& pIn = in.getCP();
169  SDMath sdm;
170  Vector<Bool> tMask(mask);
171  return CountedPtr<SDMemTable>(sdm.averagePol(*pIn, tMask));
172}
173
174
175std::vector<float> SDMathWrapper::statistic(const SDMemTableWrapper& in,
176                                            const std::vector<bool>& mask,
177                                            const std::string& which, int row)
178{
179  SDMath sdm;
180  Vector<Bool> tMask(mask);
181  return sdm.statistic(in.getCP(), tMask, String(which), Int(row));
182}
183
184
185void SDMathWrapper::convertFluxInSitu(SDMemTableWrapper& in,
186                                      float area, float eta, bool doAll)
187{
188  SDMemTable* pIn = in.getPtr();
189  SDMath sdm;
190  SDMemTable* pOut = sdm.convertFlux (*pIn, Float(area), Float(eta), Bool(doAll));
191  *pIn = *pOut;
192  delete pOut;
193}
194
195
196SDMemTableWrapper SDMathWrapper::convertFlux(const SDMemTableWrapper& in,
197                                             float area, float eta, bool doAll)
198{
199  const CountedPtr<SDMemTable>& pIn = in.getCP();
200  SDMath sdm;
201  return CountedPtr<SDMemTable>(sdm.convertFlux(*pIn, Float(area), Float(eta), Bool(doAll)));
202}
203
204
205void SDMathWrapper::gainElevationInSitu(SDMemTableWrapper& in,
206                                        const std::vector<float>& coeffs,
207                                        const string& fileName,
208                                        const string& method, bool doAll)
209{
210  SDMemTable* pIn = in.getPtr();
211  Vector<Float> tCoeffs(coeffs);
212  SDMath sdm;
213  SDMemTable* pOut = sdm.gainElevation(*pIn, tCoeffs, String(fileName),
214                                       String(method), Bool(doAll));
215  *pIn = *pOut;
216  delete pOut;
217}
218
219
220SDMemTableWrapper SDMathWrapper::gainElevation(const SDMemTableWrapper& in,
221                                               const std::vector<float>& coeffs,
222                                               const string& fileName,
223                                               const string& method, bool doAll)
224{
225  const CountedPtr<SDMemTable>& pIn = in.getCP();
226  Vector<Float> tCoeffs(coeffs);
227  SDMath sdm;
228  return CountedPtr<SDMemTable>(sdm.gainElevation(*pIn, tCoeffs, String(fileName),
229                                                  String(method), Bool(doAll)));
230}
231
232void SDMathWrapper::velocityAlignmentInSitu (SDMemTableWrapper& in, const std::string& refTime)
233{
234  SDMemTable* pIn = in.getPtr();
235  SDMath sdm;
236  SDMemTable* pOut = sdm.velocityAlignment(*pIn, String(refTime));
237  *pIn = *pOut;
238  delete pOut;
239}
240
241
242SDMemTableWrapper SDMathWrapper::velocityAlignment (const SDMemTableWrapper& in,
243                                                    const std::string& refTime)
244{
245  const CountedPtr<SDMemTable>& pIn = in.getCP();
246  SDMath sdm;
247  return CountedPtr<SDMemTable>(sdm.velocityAlignment(*pIn, String(refTime)));
248}
249
250void SDMathWrapper::opacityInSitu(SDMemTableWrapper& in, float tau, bool doAll)
251{
252  SDMemTable* pIn = in.getPtr();
253  SDMath sdm;
254  SDMemTable* pOut = sdm.opacity(*pIn, Float(tau), Bool(doAll));
255  *pIn = *pOut;
256  delete pOut;
257}
258
259
260SDMemTableWrapper SDMathWrapper::opacity(const SDMemTableWrapper& in,
261                                         float tau, bool doAll)
262{
263  const CountedPtr<SDMemTable>& pIn = in.getCP();
264  SDMath sdm;
265  return CountedPtr<SDMemTable>(sdm.opacity(*pIn, Float(tau), Bool(doAll)));
266}
267
Note: See TracBrowser for help on using the repository browser.