source: trunk/src/SDMemTable.cc@ 84

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

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