source: trunk/src/SDMemTable.cc@ 58

Last change on this file since 58 was 50, checked in by mmarquar, 20 years ago

Removed name_ related fields and functions.
Changed getTime to sprint out string of MVTime.
Added range checks for setIF/Pol/Beam functions.
Added const to get type functions, where it was missing.
Removed debugging cerr from getAbscissa
Added setCoordinate to set the Frequency Table from SpectralCoordinate.
Added nScans()
Added more info printing to summary
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 19.4 KB
RevLine 
[2]1//#---------------------------------------------------------------------------
2//# SDMemTable.cc: A MemoryTable container for single dish integrations
3//#---------------------------------------------------------------------------
4//# Copyright (C) 2004
5//# Malte Marquarding, 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
[16]32
[2]33#include <aips/iostream.h>
[50]34#include <aips/iomanip.h>
[2]35#include <aips/Arrays/Array.h>
36#include <aips/Arrays/ArrayMath.h>
37#include <aips/Arrays/MaskArrMath.h>
38#include <aips/Arrays/ArrayLogical.h>
39#include <aips/Arrays/ArrayAccessor.h>
40
41#include <aips/Tables/TableParse.h>
42#include <aips/Tables/TableDesc.h>
43#include <aips/Tables/SetupNewTab.h>
44#include <aips/Tables/ScaColDesc.h>
45#include <aips/Tables/ArrColDesc.h>
46
47#include <aips/Tables/ExprNode.h>
48#include <aips/Tables/ScalarColumn.h>
49#include <aips/Tables/ArrayColumn.h>
[18]50#include <aips/Tables/TableRecord.h>
[39]51#include <aips/Measures/MFrequency.h>
[50]52#include <aips/Quanta/MVTime.h>
[2]53
54#include "SDMemTable.h"
55#include "SDContainer.h"
56
57using namespace atnf_sd;
58
[18]59SDMemTable::SDMemTable() :
60 IFSel_(0),
61 beamSel_(0),
62 polSel_(0) {
63 setup();
64}
[2]65SDMemTable::SDMemTable(const std::string& name) :
66 IFSel_(0),
67 beamSel_(0),
68 polSel_(0) {
[50]69 Table tab(name);
[22]70 table_ = tab.copyToMemoryTable("dummy");
[2]71}
72
[16]73SDMemTable::SDMemTable(const SDMemTable& other, Bool clear) {
[2]74 this->IFSel_= other.IFSel_;
75 this->beamSel_= other.beamSel_;
76 this->polSel_= other.polSel_;
77 this->chanMask_ = other.chanMask_;
78 this->table_ = other.table_.copyToMemoryTable(String("dummy"));
79 // clear all rows()
[16]80 if (clear) {
81 this->table_.removeRow(this->table_.rowNumbers());
82 } else {
83 this->IFSel_ = other.IFSel_;
84 this->beamSel_ = other.beamSel_;
85 this->polSel_ = other.polSel_;
86 }
[2]87}
88
89SDMemTable::SDMemTable(const Table& tab, Int scanID) :
90 IFSel_(0),
91 beamSel_(0),
92 polSel_(0) {
93 String exprs = String("select * from $1 where SCANID == ")
94 +String::toString(scanID);
[50]95 //cerr << exprs << endl;
[2]96 Table t = tableCommand(exprs,tab);
[22]97 table_ = t.copyToMemoryTable("dummy");
[2]98}
99
100SDMemTable::~SDMemTable(){
[50]101 //cerr << "goodbye from SDMemTable @ " << this << endl;
[2]102}
103
104SDMemTable SDMemTable::getScan(Int scanID) {
105 return SDMemTable(table_, scanID);
106}
107
108void SDMemTable::setup() {
109 TableDesc td("", "1", TableDesc::Scratch);
110 td.comment() = "A SDMemTable";
111 td.addColumn(ScalarColumnDesc<Double>("TIME"));
112 td.addColumn(ScalarColumnDesc<String>("SRCNAME"));
113 td.addColumn(ArrayColumnDesc<Float>("SPECTRA"));
114 td.addColumn(ArrayColumnDesc<uChar>("FLAGTRA"));
115 td.addColumn(ArrayColumnDesc<Float>("TSYS"));
116 td.addColumn(ScalarColumnDesc<Int>("SCANID"));
[16]117 td.addColumn(ScalarColumnDesc<Double>("INTERVAL"));
[39]118 td.addColumn(ArrayColumnDesc<uInt>("FREQID"));
[2]119 // Now create a new table from the description.
[18]120
[22]121 SetupNewTable aNewTab("dummy", td, Table::New);
[2]122 table_ = Table(aNewTab, Table::Memory, 0);
123}
124
125std::string SDMemTable::getSourceName(Int whichRow) const {
126 ROScalarColumn<String> src(table_, "SRCNAME");
127 String name;
128 src.get(whichRow, name);
129 return name;
130}
131
[50]132std::string SDMemTable::getTime(Int whichRow) const {
[2]133 ROScalarColumn<Double> src(table_, "TIME");
134 Double tm;
135 src.get(whichRow, tm);
[50]136 MVTime mvt(tm);
137 mvt.setFormat(MVTime::YMD);
138 ostringstream oss;
139 oss << mvt;
140 String str(oss);
141 return str;
[2]142}
[50]143double SDMemTable::getInterval(Int whichRow) const {
144 ROScalarColumn<Double> src(table_, "INTERVAL");
145 Double intval;
146 src.get(whichRow, intval);
147 return intval;
148}
[2]149
150bool SDMemTable::setIF(Int whichIF) {
[50]151 if ( whichIF >= 0 && whichIF < nIF()) {
[2]152 IFSel_ = whichIF;
153 return true;
[50]154 }
155 return false;
[2]156}
[50]157
[2]158bool SDMemTable::setBeam(Int whichBeam) {
[50]159 if ( whichBeam >= 0 && whichBeam < nBeam()) {
[2]160 beamSel_ = whichBeam;
161 return true;
[50]162 }
163 return false;
164}
[2]165
166bool SDMemTable::setPol(Int whichPol) {
[50]167 if ( whichPol >= 0 && whichPol < nPol()) {
[2]168 polSel_ = whichPol;
169 return true;
[50]170 }
171 return false;
[2]172}
173
[16]174bool SDMemTable::setMask(const std::vector<int>& whichChans) {
175 ROArrayColumn<uChar> spec(table_, "FLAGTRA");
176
177 std::vector<int>::iterator it;
178 uInt n = spec.shape(0)(3);
179 chanMask_.resize(n,true);
[39]180 for (it = whichChans.begin(); it != whichChans.end(); ++it) {
[16]181 if (*it < n)
182 chanMask_[*it] = false;
183 }
[2]184 return true;
185}
186
[16]187std::vector<bool> SDMemTable::getMask(Int whichRow) const {
188 std::vector<bool> mask;
189 ROArrayColumn<uChar> spec(table_, "FLAGTRA");
190 Array<uChar> arr;
191 spec.get(whichRow, arr);
192 ArrayAccessor<uChar, Axis<0> > aa0(arr);
193 aa0.reset(aa0.begin(uInt(beamSel_)));//go to beam
194 ArrayAccessor<uChar, Axis<1> > aa1(aa0);
195 aa1.reset(aa1.begin(uInt(IFSel_)));// go to IF
196 ArrayAccessor<uChar, Axis<2> > aa2(aa1);
197 aa2.reset(aa2.begin(uInt(polSel_)));// go to pol
198
199 Bool useUserMask = ( chanMask_.size() == arr.shape()(3) );
200
201 std::vector<bool> tmp;
202 tmp = chanMask_; // WHY the fxxx do I have to make a copy here
203 std::vector<bool>::iterator miter;
204 miter = tmp.begin();
205
206 for (ArrayAccessor<uChar, Axis<3> > i(aa2); i != i.end(); ++i) {
207 bool out =!static_cast<bool>(*i);
208 if (useUserMask) {
209 out = out && (*miter);
210 miter++;
211 }
212 mask.push_back(out);
213 }
214 return mask;
[2]215}
[50]216std::vector<float> SDMemTable::getSpectrum(Int whichRow) const {
[2]217
218 std::vector<float> spectrum;
219 ROArrayColumn<Float> spec(table_, "SPECTRA");
220 Array<Float> arr;
221 spec.get(whichRow, arr);
222 ArrayAccessor<Float, Axis<0> > aa0(arr);
223 aa0.reset(aa0.begin(uInt(beamSel_)));//go to beam
224 ArrayAccessor<Float, Axis<1> > aa1(aa0);
225 aa1.reset(aa1.begin(uInt(IFSel_)));// go to IF
[16]226 ArrayAccessor<Float, Axis<2> > aa2(aa1);
227 aa2.reset(aa2.begin(uInt(polSel_)));// go to pol
228 for (ArrayAccessor<Float, Axis<3> > i(aa2); i != i.end(); ++i) {
229 spectrum.push_back(*i);
[2]230 }
231 return spectrum;
232}
[39]233
234std::vector<double> SDMemTable::getAbscissa(Int whichRow,
235 const std::string& whichUnit,
236 double restfreq) {
237 std::vector<double> absc(nChan());
238 Vector<Double> absc1(nChan());
239 indgen(absc1);
240 ROArrayColumn<uInt> fid(table_, "FREQID");
241 Vector<uInt> v;
242 fid.get(whichRow, v);
243 uInt specidx = v(IFSel_);
244 Unit u;
245 if (whichUnit == "") {
246 // get unit from table
247 } else {
248 u = String(whichUnit);
249 }
250 SpectralCoordinate spc = getCoordinate(specidx);
251 if ( u == Unit("km/s") ) {
252 if (Double(restfreq) > Double(0.000001)) {
253 cerr << "converting to velocities"<< endl;
254 spc.setRestFrequency(Double(restfreq));
255 spc.setVelocity(u.getName());
256 Vector<Double> wrld;
257 spc.pixelToVelocity(wrld,absc1);
258 std::vector<double>::iterator it;
259 uInt i = 0;
260 for (it = absc.begin(); it != absc.end(); ++it) {
261 (*it) = wrld[i];
262 i++;
263 }
264 }
265 } else if (u == Unit("Hz")) {
266 Vector<String> wau(1); wau = u.getName();
267 spc.setWorldAxisUnits(wau);
268 cerr << " converting in frequency" << endl;
269 std::vector<double>::iterator it;
270 Double tmp;
271 uInt i = 0;
[50]272 for (it = absc.begin(); it != absc.end(); ++it) {
[39]273 spc.toWorld(tmp,absc1[i]);
274 (*it) = tmp;
275 i++;
276 }
277 }
278 return absc;
279}
280
[21]281void SDMemTable::getSpectrum(Vector<Float>& spectrum, Int whichRow=0) {
282 ROArrayColumn<Float> spec(table_, "SPECTRA");
283 Array<Float> arr;
284 spec.get(whichRow, arr);
285 spectrum.resize(arr.shape()(3));
286 ArrayAccessor<Float, Axis<0> > aa0(arr);
287 aa0.reset(aa0.begin(uInt(beamSel_)));//go to beam
288 ArrayAccessor<Float, Axis<1> > aa1(aa0);
289 aa1.reset(aa1.begin(uInt(IFSel_)));// go to IF
290 ArrayAccessor<Float, Axis<2> > aa2(aa1);
291 aa2.reset(aa2.begin(uInt(polSel_)));// go to pol
[2]292
[21]293 ArrayAccessor<Float, Axis<0> > va(spectrum);
294 for (ArrayAccessor<Float, Axis<3> > i(aa2); i != i.end(); ++i) {
295 (*va) = (*i);
296 va++;
297 }
298}
299
300void SDMemTable::getMask(Vector<Bool>& mask, Int whichRow=0) const {
301 ROArrayColumn<uChar> spec(table_, "FLAGTRA");
302 Array<uChar> arr;
303 spec.get(whichRow, arr);
304 mask.resize(arr.shape()(3));
305
306 ArrayAccessor<uChar, Axis<0> > aa0(arr);
307 aa0.reset(aa0.begin(uInt(beamSel_)));//go to beam
308 ArrayAccessor<uChar, Axis<1> > aa1(aa0);
309 aa1.reset(aa1.begin(uInt(IFSel_)));// go to IF
310 ArrayAccessor<uChar, Axis<2> > aa2(aa1);
311 aa2.reset(aa2.begin(uInt(polSel_)));// go to pol
312
313 Bool useUserMask = ( chanMask_.size() == arr.shape()(3) );
314
315 ArrayAccessor<Bool, Axis<0> > va(mask);
316 std::vector<bool> tmp;
317 tmp = chanMask_; // WHY the fxxx do I have to make a copy here. The
318 // iterator should work on chanMask_??
319 std::vector<bool>::iterator miter;
320 miter = tmp.begin();
321
322 for (ArrayAccessor<uChar, Axis<3> > i(aa2); i != i.end(); ++i) {
323 bool out =!static_cast<bool>(*i);
324 if (useUserMask) {
325 out = out && (*miter);
326 miter++;
327 }
328 (*va) = out;
329 va++;
330 }
331}
332
[16]333MaskedArray<Float> SDMemTable::rowAsMaskedArray(uInt whichRow,
334 Bool useSelection) {
[2]335 ROArrayColumn<Float> spec(table_, "SPECTRA");
336 Array<Float> arr;
337 ROArrayColumn<uChar> flag(table_, "FLAGTRA");
338 Array<uChar> farr;
339 spec.get(whichRow, arr);
340 flag.get(whichRow, farr);
341 Array<Bool> barr(farr.shape());convertArray(barr, farr);
342 MaskedArray<Float> marr;
[16]343 if (useSelection) {
344 ArrayAccessor<Float, Axis<0> > aa0(arr);
345 aa0.reset(aa0.begin(uInt(beamSel_)));//go to beam
346 ArrayAccessor<Float, Axis<1> > aa1(aa0);
347 aa1.reset(aa1.begin(uInt(IFSel_)));// go to IF
348 ArrayAccessor<Float, Axis<2> > aa2(aa1);
349 aa2.reset(aa2.begin(uInt(polSel_)));// go to pol
350
351 ArrayAccessor<Bool, Axis<0> > baa0(barr);
352 baa0.reset(baa0.begin(uInt(beamSel_)));//go to beam
353 ArrayAccessor<Bool, Axis<1> > baa1(baa0);
354 baa1.reset(baa1.begin(uInt(IFSel_)));// go to IF
355 ArrayAccessor<Bool, Axis<2> > baa2(baa1);
356 baa2.reset(baa2.begin(uInt(polSel_)));// go to pol
357
358 Vector<Float> a(arr.shape()(3));
359 Vector<Bool> b(barr.shape()(3));
360 ArrayAccessor<Float, Axis<0> > a0(a);
361 ArrayAccessor<Bool, Axis<0> > b0(b);
362
363 ArrayAccessor<Bool, Axis<3> > j(baa2);
364 for (ArrayAccessor<Float, Axis<3> > i(aa2); i != i.end(); ++i) {
365 (*a0) = (*i);
366 (*b0) = !(*j);
367 j++;
368 a0++;
369 b0++;
370 }
371 marr.setData(a,b);
372 } else {
373 marr.setData(arr,!barr);
374 }
[2]375 return marr;
376}
377
378Float SDMemTable::getTsys(Int whichRow) const {
379 ROArrayColumn<Float> ts(table_, "TSYS");
380 Array<Float> arr;
381 ts.get(whichRow, arr);
382 Float out;
383 IPosition ip(arr.shape());
[16]384 ip(0) = beamSel_;ip(1) = IFSel_;ip(2) = polSel_;ip(3)=0;
[2]385 out = arr(ip);
386 return out;
387}
388
[39]389SpectralCoordinate SDMemTable::getCoordinate(uInt whichIdx) const {
390
391 Table t = table_.keywordSet().asTable("FREQUENCIES");
392 if (whichIdx > t.nrow() ) {
393 cerr << "SDMemTable::getCoordinate - whichIdx out of range" << endl;
394 return;
395 }
396 Double rp,rv,inc;
397 String rf;
398 ROScalarColumn<Double> rpc(t, "REFPIX");
399 ROScalarColumn<Double> rvc(t, "REFVAL");
400 ROScalarColumn<Double> incc(t, "INCREMENT");
401 t.keywordSet().get("REFFRAME",rf);
402
403 MFrequency::Types mft;
404 if (!MFrequency::getType(mft, rf)) {
405 cerr << "Frequency type unknown assuming TOPO" << endl;
406 mft = MFrequency::TOPO;
407 }
408 rpc.get(whichIdx, rp);
409 rvc.get(whichIdx, rv);
410 incc.get(whichIdx, inc);
[50]411 //cerr << "creating speccord from " << whichIdx << ": "
412 // << rp <<", " << rv << ", " << inc << ", " << mft <<endl;
[39]413 SpectralCoordinate spec(mft,rv,inc,rp);
414 return spec;
415}
416
[50]417Bool SDMemTable::setCoordinate(const SpectralCoordinate& speccord,
418 uInt whichIdx) {
419 Table t = table_.rwKeywordSet().asTable("FREQUENCIES");
420 if (whichIdx > t.nrow() ) {
421 cerr << "SDMemTable::setCoordinate - whichIdx out of range" << endl;
422 return;
423 }
424 ScalarColumn<Double> rpc(t, "REFPIX");
425 ScalarColumn<Double> rvc(t, "REFVAL");
426 ScalarColumn<Double> incc(t, "INCREMENT");
427
428 rpc.put(whichIdx, speccord.referencePixel()[0]);
429 rvc.put(whichIdx, speccord.referenceValue()[0]);
430 incc.put(whichIdx, speccord.increment()[0]);
431
432 return True;
433}
434
435
[39]436bool SDMemTable::putSDFreqTable(const SDFrequencyTable& sdft) {
437 TableDesc td("", "1", TableDesc::Scratch);
438 td.addColumn(ScalarColumnDesc<Double>("REFPIX"));
439 td.addColumn(ScalarColumnDesc<Double>("REFVAL"));
440 td.addColumn(ScalarColumnDesc<Double>("INCREMENT"));
441 SetupNewTable aNewTab("freqs", td, Table::New);
442 Table aTable (aNewTab, Table::Memory, sdft.length());
443 ScalarColumn<Double> sc0(aTable, "REFPIX");
444 ScalarColumn<Double> sc1(aTable, "REFVAL");
445 ScalarColumn<Double> sc2(aTable, "INCREMENT");
446 for (uInt i=0; i < sdft.length(); ++i) {
447 sc0.put(i,sdft.referencePixel(i));
448 sc1.put(i,sdft.referenceValue(i));
449 sc2.put(i,sdft.increment(i));
450 }
451 aTable.rwKeywordSet().define("REFFRAME", sdft.refFrame());
452 aTable.rwKeywordSet().define("EQUINOX", sdft.equinox());
453 aTable.rwKeywordSet().define("Unit", String("kms-1"));
454 table_.rwKeywordSet().defineTable ("FREQUENCIES", aTable);
455 return True;
456}
457
458SDFrequencyTable SDMemTable::getSDFreqTable() const {
459 SDFrequencyTable sdft;
460
461 return sdft;
462}
463
[2]464bool SDMemTable::putSDContainer(const SDContainer& sdc) {
465 ScalarColumn<Double> mjd(table_, "TIME");
466 ScalarColumn<String> srcn(table_, "SRCNAME");
467 ArrayColumn<Float> spec(table_, "SPECTRA");
468 ArrayColumn<uChar> flags(table_, "FLAGTRA");
469 ArrayColumn<Float> ts(table_, "TSYS");
470 ScalarColumn<Int> scan(table_, "SCANID");
[16]471 ScalarColumn<Double> integr(table_, "INTERVAL");
[39]472 ArrayColumn<uInt> freqid(table_, "FREQID");
[2]473
474 uInt rno = table_.nrow();
475 table_.addRow();
476
477 mjd.put(rno, sdc.timestamp);
478 srcn.put(rno, sdc.sourcename);
479 spec.put(rno, sdc.getSpectrum());
480 flags.put(rno, sdc.getFlags());
481 ts.put(rno, sdc.getTsys());
482 scan.put(rno, sdc.scanid);
[16]483 integr.put(rno, sdc.interval);
[39]484 freqid.put(rno, sdc.getFreqMap());
[16]485
[2]486 return true;
487}
[18]488
[21]489SDContainer SDMemTable::getSDContainer(uInt whichRow) const {
490 ROScalarColumn<Double> mjd(table_, "TIME");
491 ROScalarColumn<String> srcn(table_, "SRCNAME");
492 ROArrayColumn<Float> spec(table_, "SPECTRA");
493 ROArrayColumn<uChar> flags(table_, "FLAGTRA");
494 ROArrayColumn<Float> ts(table_, "TSYS");
495 ROScalarColumn<Int> scan(table_, "SCANID");
496 ROScalarColumn<Double> integr(table_, "INTERVAL");
[39]497 ROArrayColumn<uInt> freqid(table_, "FREQID");
[21]498
499 SDContainer sdc(nBeam(),nIF(),nPol(),nChan());
500 mjd.get(whichRow, sdc.timestamp);
501 srcn.get(whichRow, sdc.sourcename);
502 integr.get(whichRow, sdc.interval);
503 scan.get(whichRow, sdc.scanid);
504 Array<Float> spectrum;
505 Array<Float> tsys;
506 Array<uChar> flagtrum;
[39]507 Vector<uInt> fmap;
[21]508 spec.get(whichRow, spectrum);
509 sdc.putSpectrum(spectrum);
510 flags.get(whichRow, flagtrum);
511 sdc.putFlags(flagtrum);
512 ts.get(whichRow, tsys);
513 sdc.putTsys(tsys);
[39]514 freqid.get(whichRow, fmap);
515 sdc.putFreqMap(fmap);
[21]516 return sdc;
517}
[18]518bool SDMemTable::putSDHeader(const SDHeader& sdh) {
519 table_.lock();
520 table_.rwKeywordSet().define("nIF", sdh.nif);
521 table_.rwKeywordSet().define("nBeam", sdh.nbeam);
522 table_.rwKeywordSet().define("nPol", sdh.npol);
523 table_.rwKeywordSet().define("nChan", sdh.nchan);
524 table_.rwKeywordSet().define("Observer", sdh.observer);
525 table_.rwKeywordSet().define("Project", sdh.project);
526 table_.rwKeywordSet().define("Obstype", sdh.obstype);
527 table_.rwKeywordSet().define("AntennaName", sdh.antennaname);
528 table_.rwKeywordSet().define("AntennaPosition", sdh.antennaposition);
529 table_.rwKeywordSet().define("Equinox", sdh.equinox);
530 table_.rwKeywordSet().define("FreqRefFrame", sdh.freqref);
531 table_.rwKeywordSet().define("FreqRefVal", sdh.reffreq);
532 table_.rwKeywordSet().define("Bandwidth", sdh.bandwidth);
533 table_.rwKeywordSet().define("UTC", sdh.utc);
534 table_.unlock();
535 return true;
[50]536}
[21]537
538SDHeader SDMemTable::getSDHeader() const {
539 SDHeader sdh;
540 table_.keywordSet().get("nBeam",sdh.nbeam);
541 table_.keywordSet().get("nIF",sdh.nif);
542 table_.keywordSet().get("nPol",sdh.npol);
543 table_.keywordSet().get("nChan",sdh.nchan);
544 table_.keywordSet().get("Observer", sdh.observer);
545 table_.keywordSet().get("Project", sdh.project);
546 table_.keywordSet().get("Obstype", sdh.obstype);
547 table_.keywordSet().get("AntennaName", sdh.antennaname);
548 table_.keywordSet().get("AntennaPosition", sdh.antennaposition);
549 table_.keywordSet().get("Equinox", sdh.equinox);
550 table_.keywordSet().get("FreqRefFrame", sdh.freqref);
551 table_.keywordSet().get("FreqRefVal", sdh.reffreq);
552 table_.keywordSet().get("Bandwidth", sdh.bandwidth);
553 table_.keywordSet().get("UTC", sdh.utc);
554 return sdh;
[18]555}
[2]556void SDMemTable::makePersistent(const std::string& filename) {
557 table_.deepCopy(filename,Table::New);
558}
559
[50]560Int SDMemTable::nScans() const {
561 Int n = 0;
562 ROScalarColumn<Int> scans(table_, "SCANID");
563 Int previous = -1;Int current=0;
564 for (uInt i=0; i< scans.nrow();i++) {
565 scans.getScalar(i,current);
566 if (previous != current) {
567 previous = current;
568 n++;
569 }
570 }
571 return n;
572}
573
[2]574void SDMemTable::summary() const {
575 ROScalarColumn<Int> scans(table_, "SCANID");
576 ROScalarColumn<String> srcs(table_, "SRCNAME");
[18]577 cout << "*************** Header ***************" << endl;
578 cout << "nBeam = " << nBeam() << "\t"
579 << "nIF = " << nIF() << endl
580 << "nPol = " << nPol() << "\t"
581 << "nChan = " << nChan() << "\t" << endl;
582 cout << "*************** Header ***************" << endl;
[2]583 uInt count = 0;
584 String name;
585 Int previous = -1;Int current=0;
[50]586 cout << "Scan\tSource\t\tTime\t\tIntegration" << endl;
[2]587 for (uInt i=0; i< scans.nrow();i++) {
588 scans.getScalar(i,current);
589 if (previous != current) {
590 srcs.getScalar(i,name);
[50]591 previous = current;
592 Double t = getInterval();
593 String unit("sec");
594 if (t/60.0 > 1.0) {
595 t/=60.0;unit = "min";
596 }
[16]597 cout << count << "\t"
[50]598 << name << "\t"
599 << getTime() << "\t"
600 << setprecision(2) << setiosflags(std::ios_base::fixed)
601 << t << " " << unit << endl
[16]602 << endl;
[50]603 count++;
[2]604 }
605 }
[18]606 cout << "Table contains " << table_.nrow() << " integration(s)." << endl;
607 cout << "in " << count << " scan(s)." << endl;
[2]608}
[18]609
610Int SDMemTable::nBeam() const {
611 Int n;
612 table_.keywordSet().get("nBeam",n);
613 return n;
614}
615Int SDMemTable::nIF() const {
616 Int n;
617 table_.keywordSet().get("nIF",n);
618 return n;
619}
620Int SDMemTable::nPol() const {
621 Int n;
622 table_.keywordSet().get("nPol",n);
623 return n;
624}
625Int SDMemTable::nChan() const {
626 Int n;
627 table_.keywordSet().get("nChan",n);
628 return n;
629}
[16]630/*
[18]631void SDMemTable::maskChannels(const std::vector<Int>& whichChans ) {
[16]632
633 std::vector<int>::iterator it;
634 ArrayAccessor<uChar, Axis<2> > j(flags_);
635 for (it = whichChans.begin(); it != whichChans.end(); it++) {
636 j.reset(j.begin(uInt(*it)));
637 for (ArrayAccessor<uChar, Axis<0> > i(j); i != i.end(); ++i) {
638 for (ArrayAccessor<uChar, Axis<1> > ii(i); ii != ii.end(); ++ii) {
639 for (ArrayAccessor<uChar, Axis<3> > iii(ii);
640 iii != iii.end(); ++iii) {
641 (*iii) =
642 }
643 }
644 }
645 }
646
647}
648*/
Note: See TracBrowser for help on using the repository browser.