source: trunk/src/SDMemTable.cc@ 78

Last change on this file since 78 was 78, checked in by mar637, 20 years ago

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