source: trunk/src/STMath.cpp@ 1473

Last change on this file since 1473 was 1439, checked in by Malte Marquarding, 16 years ago

added Header diff function. Don't use obstype for conformance test
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 64.9 KB
Line 
1//
2// C++ Implementation: 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
13#include <casa/iomanip.h>
14#include <casa/Exceptions/Error.h>
15#include <casa/Containers/Block.h>
16#include <casa/BasicSL/String.h>
17#include <casa/Arrays/MaskArrLogi.h>
18#include <casa/Arrays/MaskArrMath.h>
19#include <casa/Arrays/ArrayLogical.h>
20#include <casa/Arrays/ArrayMath.h>
21#include <casa/Arrays/Slice.h>
22#include <casa/Arrays/Slicer.h>
23#include <casa/Containers/RecordField.h>
24#include <tables/Tables/TableRow.h>
25#include <tables/Tables/TableVector.h>
26#include <tables/Tables/TabVecMath.h>
27#include <tables/Tables/ExprNode.h>
28#include <tables/Tables/TableRecord.h>
29#include <tables/Tables/TableParse.h>
30#include <tables/Tables/ReadAsciiTable.h>
31#include <tables/Tables/TableIter.h>
32#include <tables/Tables/TableCopy.h>
33#include <scimath/Mathematics/FFTServer.h>
34
35#include <lattices/Lattices/LatticeUtilities.h>
36
37#include <coordinates/Coordinates/SpectralCoordinate.h>
38#include <coordinates/Coordinates/CoordinateSystem.h>
39#include <coordinates/Coordinates/CoordinateUtil.h>
40#include <coordinates/Coordinates/FrequencyAligner.h>
41
42#include <scimath/Mathematics/VectorKernel.h>
43#include <scimath/Mathematics/Convolver.h>
44#include <scimath/Functionals/Polynomial.h>
45
46#include "MathUtils.h"
47#include "RowAccumulator.h"
48#include "STAttr.h"
49#include "STMath.h"
50#include "STSelector.h"
51
52using namespace casa;
53
54using namespace asap;
55
56STMath::STMath(bool insitu) :
57 insitu_(insitu)
58{
59}
60
61
62STMath::~STMath()
63{
64}
65
66CountedPtr<Scantable>
67STMath::average( const std::vector<CountedPtr<Scantable> >& in,
68 const std::vector<bool>& mask,
69 const std::string& weight,
70 const std::string& avmode)
71{
72 if ( avmode == "SCAN" && in.size() != 1 )
73 throw(AipsError("Can't perform 'SCAN' averaging on multiple tables.\n"
74 "Use merge first."));
75 WeightType wtype = stringToWeight(weight);
76
77 // output
78 // clone as this is non insitu
79 bool insitu = insitu_;
80 setInsitu(false);
81 CountedPtr< Scantable > out = getScantable(in[0], true);
82 setInsitu(insitu);
83 std::vector<CountedPtr<Scantable> >::const_iterator stit = in.begin();
84 ++stit;
85 while ( stit != in.end() ) {
86 out->appendToHistoryTable((*stit)->history());
87 ++stit;
88 }
89
90 Table& tout = out->table();
91
92 /// @todo check if all scantables are conformant
93
94 ArrayColumn<Float> specColOut(tout,"SPECTRA");
95 ArrayColumn<uChar> flagColOut(tout,"FLAGTRA");
96 ArrayColumn<Float> tsysColOut(tout,"TSYS");
97 ScalarColumn<Double> mjdColOut(tout,"TIME");
98 ScalarColumn<Double> intColOut(tout,"INTERVAL");
99 ScalarColumn<uInt> cycColOut(tout,"CYCLENO");
100 ScalarColumn<uInt> scanColOut(tout,"SCANNO");
101
102 // set up the output table rows. These are based on the structure of the
103 // FIRST scantable in the vector
104 const Table& baset = in[0]->table();
105
106 Block<String> cols(3);
107 cols[0] = String("BEAMNO");
108 cols[1] = String("IFNO");
109 cols[2] = String("POLNO");
110 if ( avmode == "SOURCE" ) {
111 cols.resize(4);
112 cols[3] = String("SRCNAME");
113 }
114 if ( avmode == "SCAN" && in.size() == 1) {
115 cols.resize(4);
116 cols[3] = String("SCANNO");
117 }
118 uInt outrowCount = 0;
119 TableIterator iter(baset, cols);
120 while (!iter.pastEnd()) {
121 Table subt = iter.table();
122 // copy the first row of this selection into the new table
123 tout.addRow();
124 TableCopy::copyRows(tout, subt, outrowCount, 0, 1);
125 // re-index to 0
126 if ( avmode != "SCAN" && avmode != "SOURCE" ) {
127 scanColOut.put(outrowCount, uInt(0));
128 }
129 ++outrowCount;
130 ++iter;
131 }
132 RowAccumulator acc(wtype);
133 Vector<Bool> cmask(mask);
134 acc.setUserMask(cmask);
135 ROTableRow row(tout);
136 ROArrayColumn<Float> specCol, tsysCol;
137 ROArrayColumn<uChar> flagCol;
138 ROScalarColumn<Double> mjdCol, intCol;
139 ROScalarColumn<Int> scanIDCol;
140
141 Vector<uInt> rowstodelete;
142
143 for (uInt i=0; i < tout.nrow(); ++i) {
144 for ( int j=0; j < int(in.size()); ++j ) {
145 const Table& tin = in[j]->table();
146 const TableRecord& rec = row.get(i);
147 ROScalarColumn<Double> tmp(tin, "TIME");
148 Double td;tmp.get(0,td);
149 Table basesubt = tin(tin.col("BEAMNO") == Int(rec.asuInt("BEAMNO"))
150 && tin.col("IFNO") == Int(rec.asuInt("IFNO"))
151 && tin.col("POLNO") == Int(rec.asuInt("POLNO")) );
152 Table subt;
153 if ( avmode == "SOURCE") {
154 subt = basesubt( basesubt.col("SRCNAME") == rec.asString("SRCNAME") );
155 } else if (avmode == "SCAN") {
156 subt = basesubt( basesubt.col("SCANNO") == Int(rec.asuInt("SCANNO")) );
157 } else {
158 subt = basesubt;
159 }
160 specCol.attach(subt,"SPECTRA");
161 flagCol.attach(subt,"FLAGTRA");
162 tsysCol.attach(subt,"TSYS");
163 intCol.attach(subt,"INTERVAL");
164 mjdCol.attach(subt,"TIME");
165 Vector<Float> spec,tsys;
166 Vector<uChar> flag;
167 Double inter,time;
168 for (uInt k = 0; k < subt.nrow(); ++k ) {
169 flagCol.get(k, flag);
170 Vector<Bool> bflag(flag.shape());
171 convertArray(bflag, flag);
172 /*
173 if ( allEQ(bflag, True) ) {
174 continue;//don't accumulate
175 }
176 */
177 specCol.get(k, spec);
178 tsysCol.get(k, tsys);
179 intCol.get(k, inter);
180 mjdCol.get(k, time);
181 // spectrum has to be added last to enable weighting by the other values
182 acc.add(spec, !bflag, tsys, inter, time);
183 }
184 }
185 const Vector<Bool>& msk = acc.getMask();
186 if ( allEQ(msk, False) ) {
187 uint n = rowstodelete.nelements();
188 rowstodelete.resize(n+1, True);
189 rowstodelete[n] = i;
190 continue;
191 }
192 //write out
193 Vector<uChar> flg(msk.shape());
194 convertArray(flg, !msk);
195 flagColOut.put(i, flg);
196 specColOut.put(i, acc.getSpectrum());
197 tsysColOut.put(i, acc.getTsys());
198 intColOut.put(i, acc.getInterval());
199 mjdColOut.put(i, acc.getTime());
200 // we should only have one cycle now -> reset it to be 0
201 // frequency switched data has different CYCLENO for different IFNO
202 // which requires resetting this value
203 cycColOut.put(i, uInt(0));
204 acc.reset();
205 }
206 if (rowstodelete.nelements() > 0) {
207 tout.removeRow(rowstodelete);
208 if (tout.nrow() == 0) {
209 throw(AipsError("Can't average fully flagged data."));
210 }
211 }
212 return out;
213}
214
215CountedPtr< Scantable >
216 STMath::averageChannel( const CountedPtr < Scantable > & in,
217 const std::string & mode,
218 const std::string& avmode )
219{
220 // clone as this is non insitu
221 bool insitu = insitu_;
222 setInsitu(false);
223 CountedPtr< Scantable > out = getScantable(in, true);
224 setInsitu(insitu);
225 Table& tout = out->table();
226 ArrayColumn<Float> specColOut(tout,"SPECTRA");
227 ArrayColumn<uChar> flagColOut(tout,"FLAGTRA");
228 ArrayColumn<Float> tsysColOut(tout,"TSYS");
229 ScalarColumn<uInt> scanColOut(tout,"SCANNO");
230 ScalarColumn<Double> intColOut(tout, "INTERVAL");
231 Table tmp = in->table().sort("BEAMNO");
232 Block<String> cols(3);
233 cols[0] = String("BEAMNO");
234 cols[1] = String("IFNO");
235 cols[2] = String("POLNO");
236 if ( avmode == "SCAN") {
237 cols.resize(4);
238 cols[3] = String("SCANNO");
239 }
240 uInt outrowCount = 0;
241 uChar userflag = 1 << 7;
242 TableIterator iter(tmp, cols);
243 while (!iter.pastEnd()) {
244 Table subt = iter.table();
245 ROArrayColumn<Float> specCol, tsysCol;
246 ROArrayColumn<uChar> flagCol;
247 ROScalarColumn<Double> intCol(subt, "INTERVAL");
248 specCol.attach(subt,"SPECTRA");
249 flagCol.attach(subt,"FLAGTRA");
250 tsysCol.attach(subt,"TSYS");
251 tout.addRow();
252 TableCopy::copyRows(tout, subt, outrowCount, 0, 1);
253 if ( avmode != "SCAN") {
254 scanColOut.put(outrowCount, uInt(0));
255 }
256 Vector<Float> tmp;
257 specCol.get(0, tmp);
258 uInt nchan = tmp.nelements();
259 // have to do channel by channel here as MaskedArrMath
260 // doesn't have partialMedians
261 Vector<uChar> flags = flagCol.getColumn(Slicer(Slice(0)));
262 Vector<Float> outspec(nchan);
263 Vector<uChar> outflag(nchan,0);
264 Vector<Float> outtsys(1);/// @fixme when tsys is channel based
265 for (uInt i=0; i<nchan; ++i) {
266 Vector<Float> specs = specCol.getColumn(Slicer(Slice(i)));
267 MaskedArray<Float> ma = maskedArray(specs,flags);
268 outspec[i] = median(ma);
269 if ( allEQ(ma.getMask(), False) )
270 outflag[i] = userflag;// flag data
271 }
272 outtsys[0] = median(tsysCol.getColumn());
273 specColOut.put(outrowCount, outspec);
274 flagColOut.put(outrowCount, outflag);
275 tsysColOut.put(outrowCount, outtsys);
276 Double intsum = sum(intCol.getColumn());
277 intColOut.put(outrowCount, intsum);
278 ++outrowCount;
279 ++iter;
280 }
281 return out;
282}
283
284CountedPtr< Scantable > STMath::getScantable(const CountedPtr< Scantable >& in,
285 bool droprows)
286{
287 if (insitu_) return in;
288 else {
289 // clone
290 Scantable* tabp = new Scantable(*in, Bool(droprows));
291 return CountedPtr<Scantable>(tabp);
292 }
293}
294
295CountedPtr< Scantable > STMath::unaryOperate( const CountedPtr< Scantable >& in,
296 float val,
297 const std::string& mode,
298 bool tsys )
299{
300 CountedPtr< Scantable > out = getScantable(in, false);
301 Table& tab = out->table();
302 ArrayColumn<Float> specCol(tab,"SPECTRA");
303 ArrayColumn<Float> tsysCol(tab,"TSYS");
304 for (uInt i=0; i<tab.nrow(); ++i) {
305 Vector<Float> spec;
306 Vector<Float> ts;
307 specCol.get(i, spec);
308 tsysCol.get(i, ts);
309 if (mode == "MUL" || mode == "DIV") {
310 if (mode == "DIV") val = 1.0/val;
311 spec *= val;
312 specCol.put(i, spec);
313 if ( tsys ) {
314 ts *= val;
315 tsysCol.put(i, ts);
316 }
317 } else if ( mode == "ADD" || mode == "SUB") {
318 if (mode == "SUB") val *= -1.0;
319 spec += val;
320 specCol.put(i, spec);
321 if ( tsys ) {
322 ts += val;
323 tsysCol.put(i, ts);
324 }
325 }
326 }
327 return out;
328}
329
330CountedPtr<Scantable> STMath::binaryOperate(const CountedPtr<Scantable>& left,
331 const CountedPtr<Scantable>& right,
332 const std::string& mode)
333{
334 bool insitu = insitu_;
335 if ( ! left->conformant(*right) ) {
336 throw(AipsError("'left' and 'right' scantables are not conformant."));
337 }
338 setInsitu(false);
339 CountedPtr< Scantable > out = getScantable(left, false);
340 setInsitu(insitu);
341 Table& tout = out->table();
342 Block<String> coln(5);
343 coln[0] = "SCANNO"; coln[1] = "CYCLENO"; coln[2] = "BEAMNO";
344 coln[3] = "IFNO"; coln[4] = "POLNO";
345 Table tmpl = tout.sort(coln);
346 Table tmpr = right->table().sort(coln);
347 ArrayColumn<Float> lspecCol(tmpl,"SPECTRA");
348 ROArrayColumn<Float> rspecCol(tmpr,"SPECTRA");
349 ArrayColumn<uChar> lflagCol(tmpl,"FLAGTRA");
350 ROArrayColumn<uChar> rflagCol(tmpr,"FLAGTRA");
351
352 for (uInt i=0; i<tout.nrow(); ++i) {
353 Vector<Float> lspecvec, rspecvec;
354 Vector<uChar> lflagvec, rflagvec;
355 lspecvec = lspecCol(i); rspecvec = rspecCol(i);
356 lflagvec = lflagCol(i); rflagvec = rflagCol(i);
357 MaskedArray<Float> mleft = maskedArray(lspecvec, lflagvec);
358 MaskedArray<Float> mright = maskedArray(rspecvec, rflagvec);
359 if (mode == "ADD") {
360 mleft += mright;
361 } else if ( mode == "SUB") {
362 mleft -= mright;
363 } else if ( mode == "MUL") {
364 mleft *= mright;
365 } else if ( mode == "DIV") {
366 mleft /= mright;
367 } else {
368 throw(AipsError("Illegal binary operator"));
369 }
370 lspecCol.put(i, mleft.getArray());
371 }
372 return out;
373}
374
375
376
377MaskedArray<Float> STMath::maskedArray( const Vector<Float>& s,
378 const Vector<uChar>& f)
379{
380 Vector<Bool> mask;
381 mask.resize(f.shape());
382 convertArray(mask, f);
383 return MaskedArray<Float>(s,!mask);
384}
385
386Vector<uChar> STMath::flagsFromMA(const MaskedArray<Float>& ma)
387{
388 const Vector<Bool>& m = ma.getMask();
389 Vector<uChar> flags(m.shape());
390 convertArray(flags, !m);
391 return flags;
392}
393
394CountedPtr< Scantable > STMath::autoQuotient( const CountedPtr< Scantable >& in,
395 const std::string & mode,
396 bool preserve )
397{
398 /// @todo make other modes available
399 /// modes should be "nearest", "pair"
400 // make this operation non insitu
401 const Table& tin = in->table();
402 Table ons = tin(tin.col("SRCTYPE") == Int(0));
403 Table offs = tin(tin.col("SRCTYPE") == Int(1));
404 if ( offs.nrow() == 0 )
405 throw(AipsError("No 'off' scans present."));
406 // put all "on" scans into output table
407
408 bool insitu = insitu_;
409 setInsitu(false);
410 CountedPtr< Scantable > out = getScantable(in, true);
411 setInsitu(insitu);
412 Table& tout = out->table();
413
414 TableCopy::copyRows(tout, ons);
415 TableRow row(tout);
416 ROScalarColumn<Double> offtimeCol(offs, "TIME");
417 ArrayColumn<Float> outspecCol(tout, "SPECTRA");
418 ROArrayColumn<Float> outtsysCol(tout, "TSYS");
419 ArrayColumn<uChar> outflagCol(tout, "FLAGTRA");
420 for (uInt i=0; i < tout.nrow(); ++i) {
421 const TableRecord& rec = row.get(i);
422 Double ontime = rec.asDouble("TIME");
423 Table presel = offs(offs.col("BEAMNO") == Int(rec.asuInt("BEAMNO"))
424 && offs.col("IFNO") == Int(rec.asuInt("IFNO"))
425 && offs.col("POLNO") == Int(rec.asuInt("POLNO")) );
426 ROScalarColumn<Double> offtimeCol(presel, "TIME");
427
428 Double mindeltat = min(abs(offtimeCol.getColumn() - ontime));
429 // Timestamp may vary within a cycle ???!!!
430 // increase this by 0.01 sec in case of rounding errors...
431 // There might be a better way to do this.
432 // fix to this fix. TIME is MJD, so 1.0d not 1.0s
433 mindeltat += 0.01/24./60./60.;
434 Table sel = presel( abs(presel.col("TIME")-ontime) <= mindeltat);
435
436 if ( sel.nrow() < 1 ) {
437 throw(AipsError("No closest in time found... This could be a rounding "
438 "issue. Try quotient instead."));
439 }
440 TableRow offrow(sel);
441 const TableRecord& offrec = offrow.get(0);//should only be one row
442 RORecordFieldPtr< Array<Float> > specoff(offrec, "SPECTRA");
443 RORecordFieldPtr< Array<Float> > tsysoff(offrec, "TSYS");
444 RORecordFieldPtr< Array<uChar> > flagoff(offrec, "FLAGTRA");
445 /// @fixme this assumes tsys is a scalar not vector
446 Float tsysoffscalar = (*tsysoff)(IPosition(1,0));
447 Vector<Float> specon, tsyson;
448 outtsysCol.get(i, tsyson);
449 outspecCol.get(i, specon);
450 Vector<uChar> flagon;
451 outflagCol.get(i, flagon);
452 MaskedArray<Float> mon = maskedArray(specon, flagon);
453 MaskedArray<Float> moff = maskedArray(*specoff, *flagoff);
454 MaskedArray<Float> quot = (tsysoffscalar * mon / moff);
455 if (preserve) {
456 quot -= tsysoffscalar;
457 } else {
458 quot -= tsyson[0];
459 }
460 outspecCol.put(i, quot.getArray());
461 outflagCol.put(i, flagsFromMA(quot));
462 }
463 // renumber scanno
464 TableIterator it(tout, "SCANNO");
465 uInt i = 0;
466 while ( !it.pastEnd() ) {
467 Table t = it.table();
468 TableVector<uInt> vec(t, "SCANNO");
469 vec = i;
470 ++i;
471 ++it;
472 }
473 return out;
474}
475
476
477CountedPtr< Scantable > STMath::quotient( const CountedPtr< Scantable > & on,
478 const CountedPtr< Scantable > & off,
479 bool preserve )
480{
481 bool insitu = insitu_;
482 if ( ! on->conformant(*off) ) {
483 throw(AipsError("'on' and 'off' scantables are not conformant."));
484 }
485 setInsitu(false);
486 CountedPtr< Scantable > out = getScantable(on, false);
487 setInsitu(insitu);
488 Table& tout = out->table();
489 const Table& toff = off->table();
490 TableIterator sit(tout, "SCANNO");
491 TableIterator s2it(toff, "SCANNO");
492 while ( !sit.pastEnd() ) {
493 Table ton = sit.table();
494 TableRow row(ton);
495 Table t = s2it.table();
496 ArrayColumn<Float> outspecCol(ton, "SPECTRA");
497 ROArrayColumn<Float> outtsysCol(ton, "TSYS");
498 ArrayColumn<uChar> outflagCol(ton, "FLAGTRA");
499 for (uInt i=0; i < ton.nrow(); ++i) {
500 const TableRecord& rec = row.get(i);
501 Table offsel = t( t.col("BEAMNO") == Int(rec.asuInt("BEAMNO"))
502 && t.col("IFNO") == Int(rec.asuInt("IFNO"))
503 && t.col("POLNO") == Int(rec.asuInt("POLNO")) );
504 if ( offsel.nrow() == 0 )
505 throw AipsError("STMath::quotient: no matching off");
506 TableRow offrow(offsel);
507 const TableRecord& offrec = offrow.get(0);//should be ncycles - take first
508 RORecordFieldPtr< Array<Float> > specoff(offrec, "SPECTRA");
509 RORecordFieldPtr< Array<Float> > tsysoff(offrec, "TSYS");
510 RORecordFieldPtr< Array<uChar> > flagoff(offrec, "FLAGTRA");
511 Float tsysoffscalar = (*tsysoff)(IPosition(1,0));
512 Vector<Float> specon, tsyson;
513 outtsysCol.get(i, tsyson);
514 outspecCol.get(i, specon);
515 Vector<uChar> flagon;
516 outflagCol.get(i, flagon);
517 MaskedArray<Float> mon = maskedArray(specon, flagon);
518 MaskedArray<Float> moff = maskedArray(*specoff, *flagoff);
519 MaskedArray<Float> quot = (tsysoffscalar * mon / moff);
520 if (preserve) {
521 quot -= tsysoffscalar;
522 } else {
523 quot -= tsyson[0];
524 }
525 outspecCol.put(i, quot.getArray());
526 outflagCol.put(i, flagsFromMA(quot));
527 }
528 ++sit;
529 ++s2it;
530 // take the first off for each on scan which doesn't have a
531 // matching off scan
532 // non <= noff: matching pairs, non > noff matching pairs then first off
533 if ( s2it.pastEnd() ) s2it.reset();
534 }
535 return out;
536}
537
538// dototalpower (migration of GBTIDL procedure dototalpower.pro)
539// calibrate the CAL on-off pair. It calculate Tsys and average CAL on-off subintegrations
540// do it for each cycles in a specific scan.
541CountedPtr< Scantable > STMath::dototalpower( const CountedPtr< Scantable >& calon,
542 const CountedPtr< Scantable >& caloff, Float tcal )
543{
544if ( ! calon->conformant(*caloff) ) {
545 throw(AipsError("'CAL on' and 'CAL off' scantables are not conformant."));
546 }
547 setInsitu(false);
548 CountedPtr< Scantable > out = getScantable(caloff, false);
549 Table& tout = out->table();
550 const Table& tcon = calon->table();
551 Vector<Float> tcalout;
552 Vector<Float> tcalout2; //debug
553
554 if ( tout.nrow() != tcon.nrow() ) {
555 throw(AipsError("Mismatch in number of rows to form cal on - off pair."));
556 }
557 // iteration by scanno or cycle no.
558 TableIterator sit(tout, "SCANNO");
559 TableIterator s2it(tcon, "SCANNO");
560 while ( !sit.pastEnd() ) {
561 Table toff = sit.table();
562 TableRow row(toff);
563 Table t = s2it.table();
564 ScalarColumn<Double> outintCol(toff, "INTERVAL");
565 ArrayColumn<Float> outspecCol(toff, "SPECTRA");
566 ArrayColumn<Float> outtsysCol(toff, "TSYS");
567 ArrayColumn<uChar> outflagCol(toff, "FLAGTRA");
568 ROScalarColumn<uInt> outtcalIdCol(toff, "TCAL_ID");
569 ROScalarColumn<uInt> outpolCol(toff, "POLNO");
570 ROScalarColumn<Double> onintCol(t, "INTERVAL");
571 ROArrayColumn<Float> onspecCol(t, "SPECTRA");
572 ROArrayColumn<Float> ontsysCol(t, "TSYS");
573 ROArrayColumn<uChar> onflagCol(t, "FLAGTRA");
574 //ROScalarColumn<uInt> ontcalIdCol(t, "TCAL_ID");
575
576 for (uInt i=0; i < toff.nrow(); ++i) {
577 //skip these checks -> assumes the data order are the same between the cal on off pairs
578 //
579 Vector<Float> specCalon, specCaloff;
580 // to store scalar (mean) tsys
581 Vector<Float> tsysout(1);
582 uInt tcalId, polno;
583 Double offint, onint;
584 outpolCol.get(i, polno);
585 outspecCol.get(i, specCaloff);
586 onspecCol.get(i, specCalon);
587 Vector<uChar> flagCaloff, flagCalon;
588 outflagCol.get(i, flagCaloff);
589 onflagCol.get(i, flagCalon);
590 outtcalIdCol.get(i, tcalId);
591 outintCol.get(i, offint);
592 onintCol.get(i, onint);
593 // caluculate mean Tsys
594 uInt nchan = specCaloff.nelements();
595 // percentage of edge cut off
596 uInt pc = 10;
597 uInt bchan = nchan/pc;
598 uInt echan = nchan-bchan;
599
600 Slicer chansl(IPosition(1,bchan-1), IPosition(1,echan-1), IPosition(1,1),Slicer::endIsLast);
601 Vector<Float> testsubsp = specCaloff(chansl);
602 MaskedArray<Float> spoff = maskedArray( specCaloff(chansl),flagCaloff(chansl) );
603 MaskedArray<Float> spon = maskedArray( specCalon(chansl),flagCalon(chansl) );
604 MaskedArray<Float> spdiff = spon-spoff;
605 uInt noff = spoff.nelementsValid();
606 //uInt non = spon.nelementsValid();
607 uInt ndiff = spdiff.nelementsValid();
608 Float meantsys;
609
610/**
611 Double subspec, subdiff;
612 uInt usednchan;
613 subspec = 0;
614 subdiff = 0;
615 usednchan = 0;
616 for(uInt k=(bchan-1); k<echan; k++) {
617 subspec += specCaloff[k];
618 subdiff += static_cast<Double>(specCalon[k]-specCaloff[k]);
619 ++usednchan;
620 }
621**/
622 // get tcal if input tcal <= 0
623 String tcalt;
624 Float tcalUsed;
625 tcalUsed = tcal;
626 if ( tcal <= 0.0 ) {
627 caloff->tcal().getEntry(tcalt, tcalout, tcalId);
628 if (polno<=3) {
629 tcalUsed = tcalout[polno];
630 }
631 else {
632 tcalUsed = tcalout[0];
633 }
634 }
635
636 Float meanoff;
637 Float meandiff;
638 if (noff && ndiff) {
639 //Debug
640 //if(noff!=ndiff) cerr<<"noff and ndiff is not equal"<<endl;
641 meanoff = sum(spoff)/noff;
642 meandiff = sum(spdiff)/ndiff;
643 meantsys= (meanoff/meandiff )*tcalUsed + tcalUsed/2;
644 }
645 else {
646 meantsys=1;
647 }
648
649 tsysout[0] = Float(meantsys);
650 MaskedArray<Float> mcaloff = maskedArray(specCaloff, flagCaloff);
651 MaskedArray<Float> mcalon = maskedArray(specCalon, flagCalon);
652 MaskedArray<Float> sig = Float(0.5) * (mcaloff + mcalon);
653 //uInt ncaloff = mcaloff.nelementsValid();
654 //uInt ncalon = mcalon.nelementsValid();
655
656 outintCol.put(i, offint+onint);
657 outspecCol.put(i, sig.getArray());
658 outflagCol.put(i, flagsFromMA(sig));
659 outtsysCol.put(i, tsysout);
660 }
661 ++sit;
662 ++s2it;
663 }
664 return out;
665}
666
667//dosigref - migrated from GBT IDL's dosigref.pro, do calibration of position switch
668// observatiions.
669// input: sig and ref scantables, and an optional boxcar smoothing width(default width=0,
670// no smoothing).
671// output: resultant scantable [= (sig-ref/ref)*tsys]
672CountedPtr< Scantable > STMath::dosigref( const CountedPtr < Scantable >& sig,
673 const CountedPtr < Scantable >& ref,
674 int smoothref,
675 casa::Float tsysv,
676 casa::Float tau )
677{
678if ( ! ref->conformant(*sig) ) {
679 throw(AipsError("'sig' and 'ref' scantables are not conformant."));
680 }
681 setInsitu(false);
682 CountedPtr< Scantable > out = getScantable(sig, false);
683 CountedPtr< Scantable > smref;
684 if ( smoothref > 1 ) {
685 float fsmoothref = static_cast<float>(smoothref);
686 std::string inkernel = "boxcar";
687 smref = smooth(ref, inkernel, fsmoothref );
688 ostringstream oss;
689 oss<<"Applied smoothing of "<<fsmoothref<<" on the reference."<<endl;
690 pushLog(String(oss));
691 }
692 else {
693 smref = ref;
694 }
695 Table& tout = out->table();
696 const Table& tref = smref->table();
697 if ( tout.nrow() != tref.nrow() ) {
698 throw(AipsError("Mismatch in number of rows to form on-source and reference pair."));
699 }
700 // iteration by scanno? or cycle no.
701 TableIterator sit(tout, "SCANNO");
702 TableIterator s2it(tref, "SCANNO");
703 while ( !sit.pastEnd() ) {
704 Table ton = sit.table();
705 Table t = s2it.table();
706 ScalarColumn<Double> outintCol(ton, "INTERVAL");
707 ArrayColumn<Float> outspecCol(ton, "SPECTRA");
708 ArrayColumn<Float> outtsysCol(ton, "TSYS");
709 ArrayColumn<uChar> outflagCol(ton, "FLAGTRA");
710 ArrayColumn<Float> refspecCol(t, "SPECTRA");
711 ROScalarColumn<Double> refintCol(t, "INTERVAL");
712 ROArrayColumn<Float> reftsysCol(t, "TSYS");
713 ArrayColumn<uChar> refflagCol(t, "FLAGTRA");
714 ROScalarColumn<Float> refelevCol(t, "ELEVATION");
715 for (uInt i=0; i < ton.nrow(); ++i) {
716
717 Double onint, refint;
718 Vector<Float> specon, specref;
719 // to store scalar (mean) tsys
720 Vector<Float> tsysref;
721 outintCol.get(i, onint);
722 refintCol.get(i, refint);
723 outspecCol.get(i, specon);
724 refspecCol.get(i, specref);
725 Vector<uChar> flagref, flagon;
726 outflagCol.get(i, flagon);
727 refflagCol.get(i, flagref);
728 reftsysCol.get(i, tsysref);
729
730 Float tsysrefscalar;
731 if ( tsysv > 0.0 ) {
732 ostringstream oss;
733 Float elev;
734 refelevCol.get(i, elev);
735 oss << "user specified Tsys = " << tsysv;
736 // do recalc elevation if EL = 0
737 if ( elev == 0 ) {
738 throw(AipsError("EL=0, elevation data is missing."));
739 } else {
740 if ( tau <= 0.0 ) {
741 throw(AipsError("Valid tau is not supplied."));
742 } else {
743 tsysrefscalar = tsysv * exp(tau/elev);
744 }
745 }
746 oss << ", corrected (for El) tsys= "<<tsysrefscalar;
747 pushLog(String(oss));
748 }
749 else {
750 tsysrefscalar = tsysref[0];
751 }
752 //get quotient spectrum
753 MaskedArray<Float> mref = maskedArray(specref, flagref);
754 MaskedArray<Float> mon = maskedArray(specon, flagon);
755 MaskedArray<Float> specres = tsysrefscalar*((mon - mref)/mref);
756 Double resint = onint*refint*smoothref/(onint+refint*smoothref);
757
758 //Debug
759 //cerr<<"Tsys used="<<tsysrefscalar<<endl;
760 // fill the result, replay signal tsys by reference tsys
761 outintCol.put(i, resint);
762 outspecCol.put(i, specres.getArray());
763 outflagCol.put(i, flagsFromMA(specres));
764 outtsysCol.put(i, tsysref);
765 }
766 ++sit;
767 ++s2it;
768 }
769 return out;
770}
771
772CountedPtr< Scantable > STMath::donod(const casa::CountedPtr<Scantable>& s,
773 const std::vector<int>& scans,
774 int smoothref,
775 casa::Float tsysv,
776 casa::Float tau,
777 casa::Float tcal )
778
779{
780 setInsitu(false);
781 STSelector sel;
782 std::vector<int> scan1, scan2, beams;
783 std::vector< vector<int> > scanpair;
784 std::vector<string> calstate;
785 String msg;
786
787 CountedPtr< Scantable > s1b1on, s1b1off, s1b2on, s1b2off;
788 CountedPtr< Scantable > s2b1on, s2b1off, s2b2on, s2b2off;
789
790 std::vector< CountedPtr< Scantable > > sctables;
791 sctables.push_back(s1b1on);
792 sctables.push_back(s1b1off);
793 sctables.push_back(s1b2on);
794 sctables.push_back(s1b2off);
795 sctables.push_back(s2b1on);
796 sctables.push_back(s2b1off);
797 sctables.push_back(s2b2on);
798 sctables.push_back(s2b2off);
799
800 //check scanlist
801 int n=s->checkScanInfo(scans);
802 if (n==1) {
803 throw(AipsError("Incorrect scan pairs. "));
804 }
805
806 // Assume scans contain only a pair of consecutive scan numbers.
807 // It is assumed that first beam, b1, is on target.
808 // There is no check if the first beam is on or not.
809 if ( scans.size()==1 ) {
810 scan1.push_back(scans[0]);
811 scan2.push_back(scans[0]+1);
812 } else if ( scans.size()==2 ) {
813 scan1.push_back(scans[0]);
814 scan2.push_back(scans[1]);
815 } else {
816 if ( scans.size()%2 == 0 ) {
817 for (uInt i=0; i<scans.size(); i++) {
818 if (i%2 == 0) {
819 scan1.push_back(scans[i]);
820 }
821 else {
822 scan2.push_back(scans[i]);
823 }
824 }
825 } else {
826 throw(AipsError("Odd numbers of scans, cannot form pairs."));
827 }
828 }
829 scanpair.push_back(scan1);
830 scanpair.push_back(scan2);
831 calstate.push_back("*calon");
832 calstate.push_back("*[^calon]");
833 CountedPtr< Scantable > ws = getScantable(s, false);
834 uInt l=0;
835 while ( l < sctables.size() ) {
836 for (uInt i=0; i < 2; i++) {
837 for (uInt j=0; j < 2; j++) {
838 for (uInt k=0; k < 2; k++) {
839 sel.reset();
840 sel.setScans(scanpair[i]);
841 sel.setName(calstate[k]);
842 beams.clear();
843 beams.push_back(j);
844 sel.setBeams(beams);
845 ws->setSelection(sel);
846 sctables[l]= getScantable(ws, false);
847 l++;
848 }
849 }
850 }
851 }
852
853 // replace here by splitData or getData functionality
854 CountedPtr< Scantable > sig1;
855 CountedPtr< Scantable > ref1;
856 CountedPtr< Scantable > sig2;
857 CountedPtr< Scantable > ref2;
858 CountedPtr< Scantable > calb1;
859 CountedPtr< Scantable > calb2;
860
861 msg=String("Processing dototalpower for subset of the data");
862 ostringstream oss1;
863 oss1 << msg << endl;
864 pushLog(String(oss1));
865 // Debug for IRC CS data
866 //float tcal1=7.0;
867 //float tcal2=4.0;
868 sig1 = dototalpower(sctables[0], sctables[1], tcal=tcal);
869 ref1 = dototalpower(sctables[2], sctables[3], tcal=tcal);
870 ref2 = dototalpower(sctables[4], sctables[5], tcal=tcal);
871 sig2 = dototalpower(sctables[6], sctables[7], tcal=tcal);
872
873 // correction of user-specified tsys for elevation here
874
875 // dosigref calibration
876 msg=String("Processing dosigref for subset of the data");
877 ostringstream oss2;
878 oss2 << msg << endl;
879 pushLog(String(oss2));
880 calb1=dosigref(sig1,ref2,smoothref,tsysv,tau);
881 calb2=dosigref(sig2,ref1,smoothref,tsysv,tau);
882
883 // iteration by scanno or cycle no.
884 Table& tcalb1 = calb1->table();
885 Table& tcalb2 = calb2->table();
886 TableIterator sit(tcalb1, "SCANNO");
887 TableIterator s2it(tcalb2, "SCANNO");
888 while ( !sit.pastEnd() ) {
889 Table t1 = sit.table();
890 Table t2= s2it.table();
891 ArrayColumn<Float> outspecCol(t1, "SPECTRA");
892 ArrayColumn<Float> outtsysCol(t1, "TSYS");
893 ArrayColumn<uChar> outflagCol(t1, "FLAGTRA");
894 ScalarColumn<Double> outintCol(t1, "INTERVAL");
895 ArrayColumn<Float> t2specCol(t2, "SPECTRA");
896 ROArrayColumn<Float> t2tsysCol(t2, "TSYS");
897 ArrayColumn<uChar> t2flagCol(t2, "FLAGTRA");
898 ROScalarColumn<Double> t2intCol(t2, "INTERVAL");
899 for (uInt i=0; i < t1.nrow(); ++i) {
900 Vector<Float> spec1, spec2;
901 // to store scalar (mean) tsys
902 Vector<Float> tsys1, tsys2;
903 Vector<uChar> flag1, flag2;
904 Double tint1, tint2;
905 outspecCol.get(i, spec1);
906 t2specCol.get(i, spec2);
907 outflagCol.get(i, flag1);
908 t2flagCol.get(i, flag2);
909 outtsysCol.get(i, tsys1);
910 t2tsysCol.get(i, tsys2);
911 outintCol.get(i, tint1);
912 t2intCol.get(i, tint2);
913 // average
914 // assume scalar tsys for weights
915 Float wt1, wt2, tsyssq1, tsyssq2;
916 tsyssq1 = tsys1[0]*tsys1[0];
917 tsyssq2 = tsys2[0]*tsys2[0];
918 wt1 = Float(tint1)/tsyssq1;
919 wt2 = Float(tint2)/tsyssq2;
920 Float invsumwt=1/(wt1+wt2);
921 MaskedArray<Float> mspec1 = maskedArray(spec1, flag1);
922 MaskedArray<Float> mspec2 = maskedArray(spec2, flag2);
923 MaskedArray<Float> avspec = invsumwt * (wt1*mspec1 + wt2*mspec2);
924 //Array<Float> avtsys = Float(0.5) * (tsys1 + tsys2);
925 // cerr<< "Tsys1="<<tsys1<<" Tsys2="<<tsys2<<endl;
926 tsys1[0] = sqrt(tsyssq1 + tsyssq2);
927 Array<Float> avtsys = tsys1;
928
929 outspecCol.put(i, avspec.getArray());
930 outflagCol.put(i, flagsFromMA(avspec));
931 outtsysCol.put(i, avtsys);
932 }
933 ++sit;
934 ++s2it;
935 }
936 return calb1;
937}
938
939//GBTIDL version of frequency switched data calibration
940CountedPtr< Scantable > STMath::dofs( const CountedPtr< Scantable >& s,
941 const std::vector<int>& scans,
942 int smoothref,
943 casa::Float tsysv,
944 casa::Float tau,
945 casa::Float tcal )
946{
947
948
949 STSelector sel;
950 CountedPtr< Scantable > ws = getScantable(s, false);
951 CountedPtr< Scantable > sig, sigwcal, ref, refwcal;
952 CountedPtr< Scantable > calsig, calref, out;
953
954 //split the data
955 sel.setName("*_fs");
956 ws->setSelection(sel);
957 sig = getScantable(ws,false);
958 sel.reset();
959 sel.setName("*_fs_calon");
960 ws->setSelection(sel);
961 sigwcal = getScantable(ws,false);
962 sel.reset();
963 sel.setName("*_fsr");
964 ws->setSelection(sel);
965 ref = getScantable(ws,false);
966 sel.reset();
967 sel.setName("*_fsr_calon");
968 ws->setSelection(sel);
969 refwcal = getScantable(ws,false);
970
971 calsig = dototalpower(sigwcal, sig, tcal=tcal);
972 calref = dototalpower(refwcal, ref, tcal=tcal);
973
974 out=dosigref(calsig,calref,smoothref,tsysv,tau);
975
976 return out;
977}
978
979
980CountedPtr< Scantable > STMath::freqSwitch( const CountedPtr< Scantable >& in )
981{
982 // make copy or reference
983 CountedPtr< Scantable > out = getScantable(in, false);
984 Table& tout = out->table();
985 Block<String> cols(4);
986 cols[0] = String("SCANNO");
987 cols[1] = String("CYCLENO");
988 cols[2] = String("BEAMNO");
989 cols[3] = String("POLNO");
990 TableIterator iter(tout, cols);
991 while (!iter.pastEnd()) {
992 Table subt = iter.table();
993 // this should leave us with two rows for the two IFs....if not ignore
994 if (subt.nrow() != 2 ) {
995 continue;
996 }
997 ArrayColumn<Float> specCol(subt, "SPECTRA");
998 ArrayColumn<Float> tsysCol(subt, "TSYS");
999 ArrayColumn<uChar> flagCol(subt, "FLAGTRA");
1000 Vector<Float> onspec,offspec, ontsys, offtsys;
1001 Vector<uChar> onflag, offflag;
1002 tsysCol.get(0, ontsys); tsysCol.get(1, offtsys);
1003 specCol.get(0, onspec); specCol.get(1, offspec);
1004 flagCol.get(0, onflag); flagCol.get(1, offflag);
1005 MaskedArray<Float> on = maskedArray(onspec, onflag);
1006 MaskedArray<Float> off = maskedArray(offspec, offflag);
1007 MaskedArray<Float> oncopy = on.copy();
1008
1009 on /= off; on -= 1.0f;
1010 on *= ontsys[0];
1011 off /= oncopy; off -= 1.0f;
1012 off *= offtsys[0];
1013 specCol.put(0, on.getArray());
1014 const Vector<Bool>& m0 = on.getMask();
1015 Vector<uChar> flags0(m0.shape());
1016 convertArray(flags0, !m0);
1017 flagCol.put(0, flags0);
1018
1019 specCol.put(1, off.getArray());
1020 const Vector<Bool>& m1 = off.getMask();
1021 Vector<uChar> flags1(m1.shape());
1022 convertArray(flags1, !m1);
1023 flagCol.put(1, flags1);
1024 ++iter;
1025 }
1026
1027 return out;
1028}
1029
1030std::vector< float > STMath::statistic( const CountedPtr< Scantable > & in,
1031 const std::vector< bool > & mask,
1032 const std::string& which )
1033{
1034
1035 Vector<Bool> m(mask);
1036 const Table& tab = in->table();
1037 ROArrayColumn<Float> specCol(tab, "SPECTRA");
1038 ROArrayColumn<uChar> flagCol(tab, "FLAGTRA");
1039 std::vector<float> out;
1040 for (uInt i=0; i < tab.nrow(); ++i ) {
1041 Vector<Float> spec; specCol.get(i, spec);
1042 Vector<uChar> flag; flagCol.get(i, flag);
1043 MaskedArray<Float> ma = maskedArray(spec, flag);
1044 float outstat = 0.0;
1045 if ( spec.nelements() == m.nelements() ) {
1046 outstat = mathutil::statistics(which, ma(m));
1047 } else {
1048 outstat = mathutil::statistics(which, ma);
1049 }
1050 out.push_back(outstat);
1051 }
1052 return out;
1053}
1054
1055CountedPtr< Scantable > STMath::bin( const CountedPtr< Scantable > & in,
1056 int width )
1057{
1058 if ( !in->getSelection().empty() ) throw(AipsError("Can't bin subset of the data."));
1059 CountedPtr< Scantable > out = getScantable(in, false);
1060 Table& tout = out->table();
1061 out->frequencies().rescale(width, "BIN");
1062 ArrayColumn<Float> specCol(tout, "SPECTRA");
1063 ArrayColumn<uChar> flagCol(tout, "FLAGTRA");
1064 for (uInt i=0; i < tout.nrow(); ++i ) {
1065 MaskedArray<Float> main = maskedArray(specCol(i), flagCol(i));
1066 MaskedArray<Float> maout;
1067 LatticeUtilities::bin(maout, main, 0, Int(width));
1068 /// @todo implement channel based tsys binning
1069 specCol.put(i, maout.getArray());
1070 flagCol.put(i, flagsFromMA(maout));
1071 // take only the first binned spectrum's length for the deprecated
1072 // global header item nChan
1073 if (i==0) tout.rwKeywordSet().define(String("nChan"),
1074 Int(maout.getArray().nelements()));
1075 }
1076 return out;
1077}
1078
1079CountedPtr< Scantable > STMath::resample( const CountedPtr< Scantable >& in,
1080 const std::string& method,
1081 float width )
1082//
1083// Should add the possibility of width being specified in km/s. This means
1084// that for each freqID (SpectralCoordinate) we will need to convert to an
1085// average channel width (say at the reference pixel). Then we would need
1086// to be careful to make sure each spectrum (of different freqID)
1087// is the same length.
1088//
1089{
1090 //InterpolateArray1D<Double,Float>::InterpolationMethod interp;
1091 Int interpMethod(stringToIMethod(method));
1092
1093 CountedPtr< Scantable > out = getScantable(in, false);
1094 Table& tout = out->table();
1095
1096// Resample SpectralCoordinates (one per freqID)
1097 out->frequencies().rescale(width, "RESAMPLE");
1098 TableIterator iter(tout, "IFNO");
1099 TableRow row(tout);
1100 while ( !iter.pastEnd() ) {
1101 Table tab = iter.table();
1102 ArrayColumn<Float> specCol(tab, "SPECTRA");
1103 //ArrayColumn<Float> tsysCol(tout, "TSYS");
1104 ArrayColumn<uChar> flagCol(tab, "FLAGTRA");
1105 Vector<Float> spec;
1106 Vector<uChar> flag;
1107 specCol.get(0,spec); // the number of channels should be constant per IF
1108 uInt nChanIn = spec.nelements();
1109 Vector<Float> xIn(nChanIn); indgen(xIn);
1110 Int fac = Int(nChanIn/width);
1111 Vector<Float> xOut(fac+10); // 10 to be safe - resize later
1112 uInt k = 0;
1113 Float x = 0.0;
1114 while (x < Float(nChanIn) ) {
1115 xOut(k) = x;
1116 k++;
1117 x += width;
1118 }
1119 uInt nChanOut = k;
1120 xOut.resize(nChanOut, True);
1121 // process all rows for this IFNO
1122 Vector<Float> specOut;
1123 Vector<Bool> maskOut;
1124 Vector<uChar> flagOut;
1125 for (uInt i=0; i < tab.nrow(); ++i) {
1126 specCol.get(i, spec);
1127 flagCol.get(i, flag);
1128 Vector<Bool> mask(flag.nelements());
1129 convertArray(mask, flag);
1130
1131 IPosition shapeIn(spec.shape());
1132 //sh.nchan = nChanOut;
1133 InterpolateArray1D<Float,Float>::interpolate(specOut, maskOut, xOut,
1134 xIn, spec, mask,
1135 interpMethod, True, True);
1136 /// @todo do the same for channel based Tsys
1137 flagOut.resize(maskOut.nelements());
1138 convertArray(flagOut, maskOut);
1139 specCol.put(i, specOut);
1140 flagCol.put(i, flagOut);
1141 }
1142 ++iter;
1143 }
1144
1145 return out;
1146}
1147
1148STMath::imethod STMath::stringToIMethod(const std::string& in)
1149{
1150 static STMath::imap lookup;
1151
1152 // initialize the lookup table if necessary
1153 if ( lookup.empty() ) {
1154 lookup["nearest"] = InterpolateArray1D<Double,Float>::nearestNeighbour;
1155 lookup["linear"] = InterpolateArray1D<Double,Float>::linear;
1156 lookup["cubic"] = InterpolateArray1D<Double,Float>::cubic;
1157 lookup["spline"] = InterpolateArray1D<Double,Float>::spline;
1158 }
1159
1160 STMath::imap::const_iterator iter = lookup.find(in);
1161
1162 if ( lookup.end() == iter ) {
1163 std::string message = in;
1164 message += " is not a valid interpolation mode";
1165 throw(AipsError(message));
1166 }
1167 return iter->second;
1168}
1169
1170WeightType STMath::stringToWeight(const std::string& in)
1171{
1172 static std::map<std::string, WeightType> lookup;
1173
1174 // initialize the lookup table if necessary
1175 if ( lookup.empty() ) {
1176 lookup["NONE"] = asap::NONE;
1177 lookup["TINT"] = asap::TINT;
1178 lookup["TINTSYS"] = asap::TINTSYS;
1179 lookup["TSYS"] = asap::TSYS;
1180 lookup["VAR"] = asap::VAR;
1181 }
1182
1183 std::map<std::string, WeightType>::const_iterator iter = lookup.find(in);
1184
1185 if ( lookup.end() == iter ) {
1186 std::string message = in;
1187 message += " is not a valid weighting mode";
1188 throw(AipsError(message));
1189 }
1190 return iter->second;
1191}
1192
1193CountedPtr< Scantable > STMath::gainElevation( const CountedPtr< Scantable >& in,
1194 const vector< float > & coeff,
1195 const std::string & filename,
1196 const std::string& method)
1197{
1198 // Get elevation data from Scantable and convert to degrees
1199 CountedPtr< Scantable > out = getScantable(in, false);
1200 Table& tab = out->table();
1201 ROScalarColumn<Float> elev(tab, "ELEVATION");
1202 Vector<Float> x = elev.getColumn();
1203 x *= Float(180 / C::pi); // Degrees
1204
1205 Vector<Float> coeffs(coeff);
1206 const uInt nc = coeffs.nelements();
1207 if ( filename.length() > 0 && nc > 0 ) {
1208 throw(AipsError("You must choose either polynomial coefficients or an ascii file, not both"));
1209 }
1210
1211 // Correct
1212 if ( nc > 0 || filename.length() == 0 ) {
1213 // Find instrument
1214 Bool throwit = True;
1215 Instrument inst =
1216 STAttr::convertInstrument(tab.keywordSet().asString("AntennaName"),
1217 throwit);
1218
1219 // Set polynomial
1220 Polynomial<Float>* ppoly = 0;
1221 Vector<Float> coeff;
1222 String msg;
1223 if ( nc > 0 ) {
1224 ppoly = new Polynomial<Float>(nc);
1225 coeff = coeffs;
1226 msg = String("user");
1227 } else {
1228 STAttr sdAttr;
1229 coeff = sdAttr.gainElevationPoly(inst);
1230 ppoly = new Polynomial<Float>(3);
1231 msg = String("built in");
1232 }
1233
1234 if ( coeff.nelements() > 0 ) {
1235 ppoly->setCoefficients(coeff);
1236 } else {
1237 delete ppoly;
1238 throw(AipsError("There is no known gain-elevation polynomial known for this instrument"));
1239 }
1240 ostringstream oss;
1241 oss << "Making polynomial correction with " << msg << " coefficients:" << endl;
1242 oss << " " << coeff;
1243 pushLog(String(oss));
1244 const uInt nrow = tab.nrow();
1245 Vector<Float> factor(nrow);
1246 for ( uInt i=0; i < nrow; ++i ) {
1247 factor[i] = 1.0 / (*ppoly)(x[i]);
1248 }
1249 delete ppoly;
1250 scaleByVector(tab, factor, true);
1251
1252 } else {
1253 // Read and correct
1254 pushLog("Making correction from ascii Table");
1255 scaleFromAsciiTable(tab, filename, method, x, true);
1256 }
1257 return out;
1258}
1259
1260void STMath::scaleFromAsciiTable(Table& in, const std::string& filename,
1261 const std::string& method,
1262 const Vector<Float>& xout, bool dotsys)
1263{
1264
1265// Read gain-elevation ascii file data into a Table.
1266
1267 String formatString;
1268 Table tbl = readAsciiTable(formatString, Table::Memory, filename, "", "", False);
1269 scaleFromTable(in, tbl, method, xout, dotsys);
1270}
1271
1272void STMath::scaleFromTable(Table& in,
1273 const Table& table,
1274 const std::string& method,
1275 const Vector<Float>& xout, bool dotsys)
1276{
1277
1278 ROScalarColumn<Float> geElCol(table, "ELEVATION");
1279 ROScalarColumn<Float> geFacCol(table, "FACTOR");
1280 Vector<Float> xin = geElCol.getColumn();
1281 Vector<Float> yin = geFacCol.getColumn();
1282 Vector<Bool> maskin(xin.nelements(),True);
1283
1284 // Interpolate (and extrapolate) with desired method
1285
1286 InterpolateArray1D<Double,Float>::InterpolationMethod interp = stringToIMethod(method);
1287
1288 Vector<Float> yout;
1289 Vector<Bool> maskout;
1290 InterpolateArray1D<Float,Float>::interpolate(yout, maskout, xout,
1291 xin, yin, maskin, interp,
1292 True, True);
1293
1294 scaleByVector(in, Float(1.0)/yout, dotsys);
1295}
1296
1297void STMath::scaleByVector( Table& in,
1298 const Vector< Float >& factor,
1299 bool dotsys )
1300{
1301 uInt nrow = in.nrow();
1302 if ( factor.nelements() != nrow ) {
1303 throw(AipsError("factors.nelements() != table.nelements()"));
1304 }
1305 ArrayColumn<Float> specCol(in, "SPECTRA");
1306 ArrayColumn<uChar> flagCol(in, "FLAGTRA");
1307 ArrayColumn<Float> tsysCol(in, "TSYS");
1308 for (uInt i=0; i < nrow; ++i) {
1309 MaskedArray<Float> ma = maskedArray(specCol(i), flagCol(i));
1310 ma *= factor[i];
1311 specCol.put(i, ma.getArray());
1312 flagCol.put(i, flagsFromMA(ma));
1313 if ( dotsys ) {
1314 Vector<Float> tsys = tsysCol(i);
1315 tsys *= factor[i];
1316 tsysCol.put(i,tsys);
1317 }
1318 }
1319}
1320
1321CountedPtr< Scantable > STMath::convertFlux( const CountedPtr< Scantable >& in,
1322 float d, float etaap,
1323 float jyperk )
1324{
1325 CountedPtr< Scantable > out = getScantable(in, false);
1326 Table& tab = in->table();
1327 Unit fluxUnit(tab.keywordSet().asString("FluxUnit"));
1328 Unit K(String("K"));
1329 Unit JY(String("Jy"));
1330
1331 bool tokelvin = true;
1332 Double cfac = 1.0;
1333
1334 if ( fluxUnit == JY ) {
1335 pushLog("Converting to K");
1336 Quantum<Double> t(1.0,fluxUnit);
1337 Quantum<Double> t2 = t.get(JY);
1338 cfac = (t2 / t).getValue(); // value to Jy
1339
1340 tokelvin = true;
1341 out->setFluxUnit("K");
1342 } else if ( fluxUnit == K ) {
1343 pushLog("Converting to Jy");
1344 Quantum<Double> t(1.0,fluxUnit);
1345 Quantum<Double> t2 = t.get(K);
1346 cfac = (t2 / t).getValue(); // value to K
1347
1348 tokelvin = false;
1349 out->setFluxUnit("Jy");
1350 } else {
1351 throw(AipsError("Unrecognized brightness units in Table - must be consistent with Jy or K"));
1352 }
1353 // Make sure input values are converted to either Jy or K first...
1354 Float factor = cfac;
1355
1356 // Select method
1357 if (jyperk > 0.0) {
1358 factor *= jyperk;
1359 if ( tokelvin ) factor = 1.0 / jyperk;
1360 ostringstream oss;
1361 oss << "Jy/K = " << jyperk;
1362 pushLog(String(oss));
1363 Vector<Float> factors(tab.nrow(), factor);
1364 scaleByVector(tab,factors, false);
1365 } else if ( etaap > 0.0) {
1366 if (d < 0) {
1367 Instrument inst =
1368 STAttr::convertInstrument(tab.keywordSet().asString("AntennaName"),
1369 True);
1370 STAttr sda;
1371 d = sda.diameter(inst);
1372 }
1373 jyperk = STAttr::findJyPerK(etaap, d);
1374 ostringstream oss;
1375 oss << "Jy/K = " << jyperk;
1376 pushLog(String(oss));
1377 factor *= jyperk;
1378 if ( tokelvin ) {
1379 factor = 1.0 / factor;
1380 }
1381 Vector<Float> factors(tab.nrow(), factor);
1382 scaleByVector(tab, factors, False);
1383 } else {
1384
1385 // OK now we must deal with automatic look up of values.
1386 // We must also deal with the fact that the factors need
1387 // to be computed per IF and may be different and may
1388 // change per integration.
1389
1390 pushLog("Looking up conversion factors");
1391 convertBrightnessUnits(out, tokelvin, cfac);
1392 }
1393
1394 return out;
1395}
1396
1397void STMath::convertBrightnessUnits( CountedPtr<Scantable>& in,
1398 bool tokelvin, float cfac )
1399{
1400 Table& table = in->table();
1401 Instrument inst =
1402 STAttr::convertInstrument(table.keywordSet().asString("AntennaName"), True);
1403 TableIterator iter(table, "FREQ_ID");
1404 STFrequencies stfreqs = in->frequencies();
1405 STAttr sdAtt;
1406 while (!iter.pastEnd()) {
1407 Table tab = iter.table();
1408 ArrayColumn<Float> specCol(tab, "SPECTRA");
1409 ArrayColumn<uChar> flagCol(tab, "FLAGTRA");
1410 ROScalarColumn<uInt> freqidCol(tab, "FREQ_ID");
1411 MEpoch::ROScalarColumn timeCol(tab, "TIME");
1412
1413 uInt freqid; freqidCol.get(0, freqid);
1414 Vector<Float> tmpspec; specCol.get(0, tmpspec);
1415 // STAttr.JyPerK has a Vector interface... change sometime.
1416 Vector<Float> freqs(1,stfreqs.getRefFreq(freqid, tmpspec.nelements()));
1417 for ( uInt i=0; i<tab.nrow(); ++i) {
1418 Float jyperk = (sdAtt.JyPerK(inst, timeCol(i), freqs))[0];
1419 Float factor = cfac * jyperk;
1420 if ( tokelvin ) factor = Float(1.0) / factor;
1421 MaskedArray<Float> ma = maskedArray(specCol(i), flagCol(i));
1422 ma *= factor;
1423 specCol.put(i, ma.getArray());
1424 flagCol.put(i, flagsFromMA(ma));
1425 }
1426 ++iter;
1427 }
1428}
1429
1430CountedPtr< Scantable > STMath::opacity( const CountedPtr< Scantable > & in,
1431 float tau )
1432{
1433 CountedPtr< Scantable > out = getScantable(in, false);
1434
1435 Table tab = out->table();
1436 ROScalarColumn<Float> elev(tab, "ELEVATION");
1437 ArrayColumn<Float> specCol(tab, "SPECTRA");
1438 ArrayColumn<uChar> flagCol(tab, "FLAGTRA");
1439 for ( uInt i=0; i<tab.nrow(); ++i) {
1440 Float zdist = Float(C::pi_2) - elev(i);
1441 Float factor = exp(tau/cos(zdist));
1442 MaskedArray<Float> ma = maskedArray(specCol(i), flagCol(i));
1443 ma *= factor;
1444 specCol.put(i, ma.getArray());
1445 flagCol.put(i, flagsFromMA(ma));
1446 }
1447 return out;
1448}
1449
1450CountedPtr< Scantable > STMath::smoothOther( const CountedPtr< Scantable >& in,
1451 const std::string& kernel,
1452 float width )
1453{
1454 CountedPtr< Scantable > out = getScantable(in, false);
1455 Table& table = out->table();
1456 ArrayColumn<Float> specCol(table, "SPECTRA");
1457 ArrayColumn<uChar> flagCol(table, "FLAGTRA");
1458 Vector<Float> spec;
1459 Vector<uChar> flag;
1460 for ( uInt i=0; i<table.nrow(); ++i) {
1461 specCol.get(i, spec);
1462 flagCol.get(i, flag);
1463 Vector<Bool> mask(flag.nelements());
1464 convertArray(mask, flag);
1465 Vector<Float> specout;
1466 Vector<Bool> maskout;
1467 if ( kernel == "hanning" ) {
1468 mathutil::hanning(specout, maskout, spec , !mask);
1469 convertArray(flag, !maskout);
1470 } else if ( kernel == "rmedian" ) {
1471 mathutil::runningMedian(specout, maskout, spec , mask, width);
1472 convertArray(flag, maskout);
1473 }
1474 flagCol.put(i, flag);
1475 specCol.put(i, specout);
1476 }
1477 return out;
1478}
1479
1480CountedPtr< Scantable > STMath::smooth( const CountedPtr< Scantable >& in,
1481 const std::string& kernel, float width )
1482{
1483 if (kernel == "rmedian" || kernel == "hanning") {
1484 return smoothOther(in, kernel, width);
1485 }
1486 CountedPtr< Scantable > out = getScantable(in, false);
1487 Table& table = out->table();
1488 VectorKernel::KernelTypes type = VectorKernel::toKernelType(kernel);
1489 // same IFNO should have same no of channels
1490 // this saves overhead
1491 TableIterator iter(table, "IFNO");
1492 while (!iter.pastEnd()) {
1493 Table tab = iter.table();
1494 ArrayColumn<Float> specCol(tab, "SPECTRA");
1495 ArrayColumn<uChar> flagCol(tab, "FLAGTRA");
1496 Vector<Float> tmpspec; specCol.get(0, tmpspec);
1497 uInt nchan = tmpspec.nelements();
1498 Vector<Float> kvec = VectorKernel::make(type, width, nchan, True, False);
1499 Convolver<Float> conv(kvec, IPosition(1,nchan));
1500 Vector<Float> spec;
1501 Vector<uChar> flag;
1502 for ( uInt i=0; i<tab.nrow(); ++i) {
1503 specCol.get(i, spec);
1504 flagCol.get(i, flag);
1505 Vector<Bool> mask(flag.nelements());
1506 convertArray(mask, flag);
1507 Vector<Float> specout;
1508 mathutil::replaceMaskByZero(specout, mask);
1509 conv.linearConv(specout, spec);
1510 specCol.put(i, specout);
1511 }
1512 ++iter;
1513 }
1514 return out;
1515}
1516
1517CountedPtr< Scantable >
1518 STMath::merge( const std::vector< CountedPtr < Scantable > >& in )
1519{
1520 if ( in.size() < 2 ) {
1521 throw(AipsError("Need at least two scantables to perform a merge."));
1522 }
1523 std::vector<CountedPtr < Scantable > >::const_iterator it = in.begin();
1524 bool insitu = insitu_;
1525 setInsitu(false);
1526 CountedPtr< Scantable > out = getScantable(*it, false);
1527 setInsitu(insitu);
1528 Table& tout = out->table();
1529 ScalarColumn<uInt> freqidcol(tout,"FREQ_ID"), molidcol(tout, "MOLECULE_ID");
1530 ScalarColumn<uInt> scannocol(tout,"SCANNO"), focusidcol(tout,"FOCUS_ID");
1531 // Renumber SCANNO to be 0-based
1532 Vector<uInt> scannos = scannocol.getColumn();
1533 uInt offset = min(scannos);
1534 scannos -= offset;
1535 scannocol.putColumn(scannos);
1536 uInt newscanno = max(scannos)+1;
1537 ++it;
1538 while ( it != in.end() ){
1539 if ( ! (*it)->conformant(*out) ) {
1540 // non conformant.
1541 pushLog(String("Warning: Can't merge scantables as header info differs."));
1542 }
1543 out->appendToHistoryTable((*it)->history());
1544 const Table& tab = (*it)->table();
1545 TableIterator scanit(tab, "SCANNO");
1546 while (!scanit.pastEnd()) {
1547 TableIterator freqit(scanit.table(), "FREQ_ID");
1548 while ( !freqit.pastEnd() ) {
1549 Table thetab = freqit.table();
1550 uInt nrow = tout.nrow();
1551 //tout.addRow(thetab.nrow());
1552 TableCopy::copyRows(tout, thetab, nrow, 0, thetab.nrow());
1553 ROTableRow row(thetab);
1554 for ( uInt i=0; i<thetab.nrow(); ++i) {
1555 uInt k = nrow+i;
1556 scannocol.put(k, newscanno);
1557 const TableRecord& rec = row.get(i);
1558 Double rv,rp,inc;
1559 (*it)->frequencies().getEntry(rp, rv, inc, rec.asuInt("FREQ_ID"));
1560 uInt id;
1561 id = out->frequencies().addEntry(rp, rv, inc);
1562 freqidcol.put(k,id);
1563 String name,fname;Double rf;
1564 (*it)->molecules().getEntry(rf, name, fname, rec.asuInt("MOLECULE_ID"));
1565 id = out->molecules().addEntry(rf, name, fname);
1566 molidcol.put(k, id);
1567 Float frot,fax,ftan,fhand,fmount,fuser, fxy, fxyp;
1568 (*it)->focus().getEntry(fax, ftan, frot, fhand,
1569 fmount,fuser, fxy, fxyp,
1570 rec.asuInt("FOCUS_ID"));
1571 id = out->focus().addEntry(fax, ftan, frot, fhand,
1572 fmount,fuser, fxy, fxyp);
1573 focusidcol.put(k, id);
1574 }
1575 ++freqit;
1576 }
1577 ++newscanno;
1578 ++scanit;
1579 }
1580 ++it;
1581 }
1582 return out;
1583}
1584
1585CountedPtr< Scantable >
1586 STMath::invertPhase( const CountedPtr < Scantable >& in )
1587{
1588 return applyToPol(in, &STPol::invertPhase, Float(0.0));
1589}
1590
1591CountedPtr< Scantable >
1592 STMath::rotateXYPhase( const CountedPtr < Scantable >& in, float phase )
1593{
1594 return applyToPol(in, &STPol::rotatePhase, Float(phase));
1595}
1596
1597CountedPtr< Scantable >
1598 STMath::rotateLinPolPhase( const CountedPtr < Scantable >& in, float phase )
1599{
1600 return applyToPol(in, &STPol::rotateLinPolPhase, Float(phase));
1601}
1602
1603CountedPtr< Scantable > STMath::applyToPol( const CountedPtr<Scantable>& in,
1604 STPol::polOperation fptr,
1605 Float phase )
1606{
1607 CountedPtr< Scantable > out = getScantable(in, false);
1608 Table& tout = out->table();
1609 Block<String> cols(4);
1610 cols[0] = String("SCANNO");
1611 cols[1] = String("BEAMNO");
1612 cols[2] = String("IFNO");
1613 cols[3] = String("CYCLENO");
1614 TableIterator iter(tout, cols);
1615 CountedPtr<STPol> stpol = STPol::getPolClass(out->factories_,
1616 out->getPolType() );
1617 while (!iter.pastEnd()) {
1618 Table t = iter.table();
1619 ArrayColumn<Float> speccol(t, "SPECTRA");
1620 ScalarColumn<uInt> focidcol(t, "FOCUS_ID");
1621 ScalarColumn<Float> parancol(t, "PARANGLE");
1622 Matrix<Float> pols(speccol.getColumn());
1623 try {
1624 stpol->setSpectra(pols);
1625 Float fang,fhand,parang;
1626 fang = in->focusTable_.getTotalFeedAngle(focidcol(0));
1627 fhand = in->focusTable_.getFeedHand(focidcol(0));
1628 parang = parancol(0);
1629 /// @todo re-enable this
1630 // disable total feed angle to support paralactifying Caswell style
1631 stpol->setPhaseCorrections(parang, -parang, fhand);
1632 // use a member function pointer in STPol. This only works on
1633 // the STPol pointer itself, not the Counted Pointer so
1634 // derefernce it.
1635 (&(*(stpol))->*fptr)(phase);
1636 speccol.putColumn(stpol->getSpectra());
1637 } catch (AipsError& e) {
1638 //delete stpol;stpol=0;
1639 throw(e);
1640 }
1641 ++iter;
1642 }
1643 //delete stpol;stpol=0;
1644 return out;
1645}
1646
1647CountedPtr< Scantable >
1648 STMath::swapPolarisations( const CountedPtr< Scantable > & in )
1649{
1650 CountedPtr< Scantable > out = getScantable(in, false);
1651 Table& tout = out->table();
1652 Table t0 = tout(tout.col("POLNO") == 0);
1653 Table t1 = tout(tout.col("POLNO") == 1);
1654 if ( t0.nrow() != t1.nrow() )
1655 throw(AipsError("Inconsistent number of polarisations"));
1656 ArrayColumn<Float> speccol0(t0, "SPECTRA");
1657 ArrayColumn<uChar> flagcol0(t0, "FLAGTRA");
1658 ArrayColumn<Float> speccol1(t1, "SPECTRA");
1659 ArrayColumn<uChar> flagcol1(t1, "FLAGTRA");
1660 Matrix<Float> s0 = speccol0.getColumn();
1661 Matrix<uChar> f0 = flagcol0.getColumn();
1662 speccol0.putColumn(speccol1.getColumn());
1663 flagcol0.putColumn(flagcol1.getColumn());
1664 speccol1.putColumn(s0);
1665 flagcol1.putColumn(f0);
1666 return out;
1667}
1668
1669CountedPtr< Scantable >
1670 STMath::averagePolarisations( const CountedPtr< Scantable > & in,
1671 const std::vector<bool>& mask,
1672 const std::string& weight )
1673{
1674 if (in->npol() < 2 )
1675 throw(AipsError("averagePolarisations can only be applied to two or more"
1676 "polarisations"));
1677 bool insitu = insitu_;
1678 setInsitu(false);
1679 CountedPtr< Scantable > pols = getScantable(in, true);
1680 setInsitu(insitu);
1681 Table& tout = pols->table();
1682 std::string taql = "SELECT FROM $1 WHERE POLNO IN [0,1]";
1683 Table tab = tableCommand(taql, in->table());
1684 if (tab.nrow() == 0 )
1685 throw(AipsError("Could not find any rows with POLNO==0 and POLNO==1"));
1686 TableCopy::copyRows(tout, tab);
1687 TableVector<uInt> vec(tout, "POLNO");
1688 vec = 0;
1689 pols->table_.rwKeywordSet().define("nPol", Int(1));
1690 //pols->table_.rwKeywordSet().define("POLTYPE", String("stokes"));
1691 pols->table_.rwKeywordSet().define("POLTYPE", in->getPolType());
1692 std::vector<CountedPtr<Scantable> > vpols;
1693 vpols.push_back(pols);
1694 CountedPtr< Scantable > out = average(vpols, mask, weight, "SCAN");
1695 return out;
1696}
1697
1698CountedPtr< Scantable >
1699 STMath::averageBeams( const CountedPtr< Scantable > & in,
1700 const std::vector<bool>& mask,
1701 const std::string& weight )
1702{
1703 bool insitu = insitu_;
1704 setInsitu(false);
1705 CountedPtr< Scantable > beams = getScantable(in, false);
1706 setInsitu(insitu);
1707 Table& tout = beams->table();
1708 // give all rows the same BEAMNO
1709 TableVector<uInt> vec(tout, "BEAMNO");
1710 vec = 0;
1711 beams->table_.rwKeywordSet().define("nBeam", Int(1));
1712 std::vector<CountedPtr<Scantable> > vbeams;
1713 vbeams.push_back(beams);
1714 CountedPtr< Scantable > out = average(vbeams, mask, weight, "SCAN");
1715 return out;
1716}
1717
1718
1719CountedPtr< Scantable >
1720 asap::STMath::frequencyAlign( const CountedPtr< Scantable > & in,
1721 const std::string & refTime,
1722 const std::string & method)
1723{
1724 // clone as this is not working insitu
1725 bool insitu = insitu_;
1726 setInsitu(false);
1727 CountedPtr< Scantable > out = getScantable(in, false);
1728 setInsitu(insitu);
1729 Table& tout = out->table();
1730 // Get reference Epoch to time of first row or given String
1731 Unit DAY(String("d"));
1732 MEpoch::Ref epochRef(in->getTimeReference());
1733 MEpoch refEpoch;
1734 if (refTime.length()>0) {
1735 Quantum<Double> qt;
1736 if (MVTime::read(qt,refTime)) {
1737 MVEpoch mv(qt);
1738 refEpoch = MEpoch(mv, epochRef);
1739 } else {
1740 throw(AipsError("Invalid format for Epoch string"));
1741 }
1742 } else {
1743 refEpoch = in->timeCol_(0);
1744 }
1745 MPosition refPos = in->getAntennaPosition();
1746
1747 InterpolateArray1D<Double,Float>::InterpolationMethod interp = stringToIMethod(method);
1748 // test if user frame is different to base frame
1749 if ( in->frequencies().getFrameString(true)
1750 == in->frequencies().getFrameString(false) ) {
1751 throw(AipsError("Can't convert as no output frame has been set"
1752 " (use set_freqframe) or it is aligned already."));
1753 }
1754 MFrequency::Types system = in->frequencies().getFrame();
1755 MVTime mvt(refEpoch.getValue());
1756 String epochout = mvt.string(MVTime::YMD) + String(" (") + refEpoch.getRefString() + String(")");
1757 ostringstream oss;
1758 oss << "Aligned at reference Epoch " << epochout
1759 << " in frame " << MFrequency::showType(system);
1760 pushLog(String(oss));
1761 // set up the iterator
1762 Block<String> cols(4);
1763 // select by constant direction
1764 cols[0] = String("SRCNAME");
1765 cols[1] = String("BEAMNO");
1766 // select by IF ( no of channels varies over this )
1767 cols[2] = String("IFNO");
1768 // select by restfrequency
1769 cols[3] = String("MOLECULE_ID");
1770 TableIterator iter(tout, cols);
1771 while ( !iter.pastEnd() ) {
1772 Table t = iter.table();
1773 MDirection::ROScalarColumn dirCol(t, "DIRECTION");
1774 TableIterator fiter(t, "FREQ_ID");
1775 // determine nchan from the first row. This should work as
1776 // we are iterating over BEAMNO and IFNO // we should have constant direction
1777
1778 ROArrayColumn<Float> sCol(t, "SPECTRA");
1779 MDirection direction = dirCol(0);
1780 uInt nchan = sCol(0).nelements();
1781 while ( !fiter.pastEnd() ) {
1782 Table ftab = fiter.table();
1783 ScalarColumn<uInt> freqidCol(ftab, "FREQ_ID");
1784 // get the SpectralCoordinate for the freqid, which we are iterating over
1785 SpectralCoordinate sC = in->frequencies().getSpectralCoordinate(freqidCol(0));
1786 FrequencyAligner<Float> fa( sC, nchan, refEpoch,
1787 direction, refPos, system );
1788 // realign the SpectralCoordinate and put into the output Scantable
1789 Vector<String> units(1);
1790 units = String("Hz");
1791 Bool linear=True;
1792 SpectralCoordinate sc2 = fa.alignedSpectralCoordinate(linear);
1793 sc2.setWorldAxisUnits(units);
1794 uInt id = out->frequencies().addEntry(sc2.referencePixel()[0],
1795 sc2.referenceValue()[0],
1796 sc2.increment()[0]);
1797 TableVector<uInt> tvec(ftab, "FREQ_ID");
1798 tvec = id;
1799 // create the "global" abcissa for alignment with same FREQ_ID
1800 Vector<Double> abc(nchan);
1801 Double w;
1802 for (uInt i=0; i<nchan; i++) {
1803 sC.toWorld(w,Double(i));
1804 abc[i] = w;
1805 }
1806 // cache abcissa for same time stamps, so iterate over those
1807 TableIterator timeiter(ftab, "TIME");
1808 while ( !timeiter.pastEnd() ) {
1809 Table tab = timeiter.table();
1810 ArrayColumn<Float> specCol(tab, "SPECTRA");
1811 ArrayColumn<uChar> flagCol(tab, "FLAGTRA");
1812 MEpoch::ROScalarColumn timeCol(tab, "TIME");
1813 // use align abcissa cache after the first row
1814 bool first = true;
1815 // these rows should be just be POLNO
1816 for (int i=0; i<int(tab.nrow()); ++i) {
1817 // input values
1818 Vector<uChar> flag = flagCol(i);
1819 Vector<Bool> mask(flag.shape());
1820 Vector<Float> specOut, spec;
1821 spec = specCol(i);
1822 Vector<Bool> maskOut;Vector<uChar> flagOut;
1823 convertArray(mask, flag);
1824 // alignment
1825 Bool ok = fa.align(specOut, maskOut, abc, spec,
1826 mask, timeCol(i), !first,
1827 interp, False);
1828 // back into scantable
1829 flagOut.resize(maskOut.nelements());
1830 convertArray(flagOut, maskOut);
1831 flagCol.put(i, flagOut);
1832 specCol.put(i, specOut);
1833 // start abcissa caching
1834 first = false;
1835 }
1836 // next timestamp
1837 ++timeiter;
1838 }
1839 // next FREQ_ID
1840 ++fiter;
1841 }
1842 // next aligner
1843 ++iter;
1844 }
1845 // set this afterwards to ensure we are doing insitu correctly.
1846 out->frequencies().setFrame(system, true);
1847 return out;
1848}
1849
1850CountedPtr<Scantable>
1851 asap::STMath::convertPolarisation( const CountedPtr<Scantable>& in,
1852 const std::string & newtype )
1853{
1854 if (in->npol() != 2 && in->npol() != 4)
1855 throw(AipsError("Can only convert two or four polarisations."));
1856 if ( in->getPolType() == newtype )
1857 throw(AipsError("No need to convert."));
1858 if ( ! in->selector_.empty() )
1859 throw(AipsError("Can only convert whole scantable. Unset the selection."));
1860 bool insitu = insitu_;
1861 setInsitu(false);
1862 CountedPtr< Scantable > out = getScantable(in, true);
1863 setInsitu(insitu);
1864 Table& tout = out->table();
1865 tout.rwKeywordSet().define("POLTYPE", String(newtype));
1866
1867 Block<String> cols(4);
1868 cols[0] = "SCANNO";
1869 cols[1] = "CYCLENO";
1870 cols[2] = "BEAMNO";
1871 cols[3] = "IFNO";
1872 TableIterator it(in->originalTable_, cols);
1873 String basetype = in->getPolType();
1874 STPol* stpol = STPol::getPolClass(in->factories_, basetype);
1875 try {
1876 while ( !it.pastEnd() ) {
1877 Table tab = it.table();
1878 uInt row = tab.rowNumbers()[0];
1879 stpol->setSpectra(in->getPolMatrix(row));
1880 Float fang,fhand,parang;
1881 fang = in->focusTable_.getTotalFeedAngle(in->mfocusidCol_(row));
1882 fhand = in->focusTable_.getFeedHand(in->mfocusidCol_(row));
1883 parang = in->paraCol_(row);
1884 /// @todo re-enable this
1885 // disable total feed angle to support paralactifying Caswell style
1886 stpol->setPhaseCorrections(parang, -parang, fhand);
1887 Int npolout = 0;
1888 for (uInt i=0; i<tab.nrow(); ++i) {
1889 Vector<Float> outvec = stpol->getSpectrum(i, newtype);
1890 if ( outvec.nelements() > 0 ) {
1891 tout.addRow();
1892 TableCopy::copyRows(tout, tab, tout.nrow()-1, 0, 1);
1893 ArrayColumn<Float> sCol(tout,"SPECTRA");
1894 ScalarColumn<uInt> pCol(tout,"POLNO");
1895 sCol.put(tout.nrow()-1 ,outvec);
1896 pCol.put(tout.nrow()-1 ,uInt(npolout));
1897 npolout++;
1898 }
1899 }
1900 tout.rwKeywordSet().define("nPol", npolout);
1901 ++it;
1902 }
1903 } catch (AipsError& e) {
1904 delete stpol;
1905 throw(e);
1906 }
1907 delete stpol;
1908 return out;
1909}
1910
1911CountedPtr< Scantable >
1912 asap::STMath::mxExtract( const CountedPtr< Scantable > & in,
1913 const std::string & scantype )
1914{
1915 bool insitu = insitu_;
1916 setInsitu(false);
1917 CountedPtr< Scantable > out = getScantable(in, true);
1918 setInsitu(insitu);
1919 Table& tout = out->table();
1920 std::string taql = "SELECT FROM $1 WHERE BEAMNO != REFBEAMNO";
1921 if (scantype == "on") {
1922 taql = "SELECT FROM $1 WHERE BEAMNO == REFBEAMNO";
1923 }
1924 Table tab = tableCommand(taql, in->table());
1925 TableCopy::copyRows(tout, tab);
1926 if (scantype == "on") {
1927 // re-index SCANNO to 0
1928 TableVector<uInt> vec(tout, "SCANNO");
1929 vec = 0;
1930 }
1931 return out;
1932}
1933
1934CountedPtr< Scantable >
1935 asap::STMath::lagFlag( const CountedPtr< Scantable > & in,
1936 double frequency, double width )
1937{
1938 CountedPtr< Scantable > out = getScantable(in, false);
1939 Table& tout = out->table();
1940 TableIterator iter(tout, "FREQ_ID");
1941 FFTServer<Float,Complex> ffts;
1942 while ( !iter.pastEnd() ) {
1943 Table tab = iter.table();
1944 Double rp,rv,inc;
1945 ROTableRow row(tab);
1946 const TableRecord& rec = row.get(0);
1947 uInt freqid = rec.asuInt("FREQ_ID");
1948 out->frequencies().getEntry(rp, rv, inc, freqid);
1949 ArrayColumn<Float> specCol(tab, "SPECTRA");
1950 ArrayColumn<uChar> flagCol(tab, "FLAGTRA");
1951 for (int i=0; i<int(tab.nrow()); ++i) {
1952 Vector<Float> spec = specCol(i);
1953 Vector<uChar> flag = flagCol(i);
1954 Int lag0 = Int(spec.nelements()*abs(inc)/(frequency+width)+0.5);
1955 Int lag1 = Int(spec.nelements()*abs(inc)/(frequency-width)+0.5);
1956 for (int k=0; k < flag.nelements(); ++k ) {
1957 if (flag[k] > 0) {
1958 spec[k] = 0.0;
1959 }
1960 }
1961 Vector<Complex> lags;
1962 ffts.fft0(lags, spec);
1963 Int start = max(0, lag0);
1964 Int end = min(Int(lags.nelements()-1), lag1);
1965 if (start == end) {
1966 lags[start] = Complex(0.0);
1967 } else {
1968 for (int j=start; j <=end ;++j) {
1969 lags[j] = Complex(0.0);
1970 }
1971 }
1972 ffts.fft0(spec, lags);
1973 specCol.put(i, spec);
1974 }
1975 ++iter;
1976 }
1977 return out;
1978}
Note: See TracBrowser for help on using the repository browser.