source: trunk/src/SDMemTable.cc@ 95

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

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