source: trunk/src/Scantable.cpp@ 835

Last change on this file since 835 was 805, checked in by mar637, 19 years ago

Code replacemnts after the rename

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 21.1 KB
Line 
1//
2// C++ Implementation: Scantable
3//
4// Description:
5//
6//
7// Author: Malte Marquarding <asap@atnf.csiro.au>, (C) 2005
8//
9// Copyright: See COPYING file that comes with this distribution
10//
11//
12#include <map>
13
14#include <casa/aips.h>
15#include <casa/iostream.h>
16#include <casa/iomanip.h>
17#include <casa/OS/Path.h>
18#include <casa/OS/File.h>
19#include <casa/Arrays/Array.h>
20#include <casa/Arrays/ArrayMath.h>
21#include <casa/Arrays/MaskArrMath.h>
22#include <casa/Arrays/ArrayLogical.h>
23#include <casa/Arrays/ArrayAccessor.h>
24#include <casa/Arrays/VectorSTLIterator.h>
25#include <casa/Arrays/Vector.h>
26#include <casa/BasicMath/Math.h>
27#include <casa/BasicSL/Constants.h>
28#include <casa/Quanta/MVAngle.h>
29#include <casa/Containers/RecordField.h>
30
31#include <tables/Tables/TableParse.h>
32#include <tables/Tables/TableDesc.h>
33#include <tables/Tables/TableCopy.h>
34#include <tables/Tables/SetupNewTab.h>
35#include <tables/Tables/ScaColDesc.h>
36#include <tables/Tables/ArrColDesc.h>
37#include <tables/Tables/TableRow.h>
38#include <tables/Tables/TableVector.h>
39#include <tables/Tables/TableIter.h>
40
41#include <tables/Tables/ExprNode.h>
42#include <tables/Tables/TableRecord.h>
43#include <measures/Measures/MFrequency.h>
44#include <measures/Measures/MEpoch.h>
45#include <measures/Measures/MeasTable.h>
46#include <measures/Measures/MeasRef.h>
47#include <measures/TableMeasures/TableMeasRefDesc.h>
48#include <measures/TableMeasures/TableMeasValueDesc.h>
49#include <measures/TableMeasures/TableMeasDesc.h>
50#include <measures/TableMeasures/ScalarMeasColumn.h>
51#include <coordinates/Coordinates/CoordinateUtil.h>
52#include <casa/Quanta/MVTime.h>
53#include <casa/Quanta/MVAngle.h>
54
55#include "Scantable.h"
56#include "SDAttr.h"
57
58using namespace casa;
59
60namespace asap {
61
62Scantable::Scantable(Table::TableType ttype) :
63 type_(ttype),
64 freqTable_(ttype),
65 focusTable_(ttype),
66 weatherTable_(ttype),
67 tcalTable_(ttype),
68 moleculeTable_(ttype)
69{
70 setupMainTable();
71 table_.rwKeywordSet().defineTable("FREQUENCIES", freqTable_.table());
72 table_.rwKeywordSet().defineTable("WEATHER", weatherTable_.table());
73 table_.rwKeywordSet().defineTable("FOCUS", focusTable_.table());
74 table_.rwKeywordSet().defineTable("TCAL", tcalTable_.table());
75 table_.rwKeywordSet().defineTable("MOLECULES", moleculeTable_.table());
76 setupHistoryTable();
77 setupFitTable();
78
79 originalTable_ = table_;
80 attach();
81}
82
83Scantable::Scantable(const std::string& name, Table::TableType ttype) :
84 type_(ttype),
85 freqTable_(ttype)
86{
87 Table tab(name);
88 Int version;
89 tab.keywordSet().get("VERSION", version);
90 if (version != version_) {
91 throw(AipsError("Unsupported version of ASAP file."));
92 }
93 if ( type_ == Table::Memory )
94 table_ = tab.copyToMemoryTable("dummy");
95 else
96 table_ = tab;
97
98 originalTable_ = table_;
99 attach();
100}
101
102
103Scantable::Scantable( const Scantable& other, bool clear )
104{
105 // with or without data
106 if (clear) {
107 table_ = TableCopy::makeEmptyMemoryTable(String("dummy"), other.table_,
108 True);
109 } else {
110 table_ = other.table_.copyToMemoryTable(String("dummy"));
111 }
112
113 originalTable_ = table_;
114 attach();
115}
116
117Scantable::~Scantable()
118{
119 cout << "~Scantable() " << this << endl;
120}
121
122void Scantable::setupMainTable()
123{
124 TableDesc td("", "1", TableDesc::Scratch);
125 td.comment() = "An ASAP Scantable";
126 td.rwKeywordSet().define("VERSION", Int(version_));
127
128 // n Cycles
129 td.addColumn(ScalarColumnDesc<uInt>("SCANNO"));
130 // new index every nBeam x nIF x nPol
131 td.addColumn(ScalarColumnDesc<uInt>("CYCLENO"));
132
133 td.addColumn(ScalarColumnDesc<uInt>("BEAMNO"));
134 td.addColumn(ScalarColumnDesc<uInt>("IFNO"));
135 td.rwKeywordSet().define("POLTYPE", String("linear"));
136 td.addColumn(ScalarColumnDesc<uInt>("POLNO"));
137
138 td.addColumn(ScalarColumnDesc<uInt>("FREQ_ID"));
139 td.addColumn(ScalarColumnDesc<uInt>("MOLECULE_ID"));
140 // linear, circular, stokes [I Q U V], stokes1 [I Plinear Pangle V]
141 td.addColumn(ScalarColumnDesc<Int>("REFBEAMNO"));
142
143 td.addColumn(ScalarColumnDesc<Double>("TIME"));
144 TableMeasRefDesc measRef(MEpoch::UTC); // UTC as default
145 TableMeasValueDesc measVal(td, "TIME");
146 TableMeasDesc<MEpoch> mepochCol(measVal, measRef);
147 mepochCol.write(td);
148
149 td.addColumn(ScalarColumnDesc<Double>("INTERVAL"));
150
151 td.addColumn(ScalarColumnDesc<String>("SRCNAME"));
152 // Type of source (on=0, off=1, other=-1)
153 td.addColumn(ScalarColumnDesc<Int>("SRCTYPE", Int(-1)));
154 td.addColumn(ScalarColumnDesc<String>("FIELDNAME"));
155
156 //The actual Data Vectors
157 td.addColumn(ArrayColumnDesc<Float>("SPECTRA"));
158 td.addColumn(ArrayColumnDesc<uChar>("FLAGTRA"));
159 td.addColumn(ArrayColumnDesc<Float>("TSYS"));
160
161 td.addColumn(ArrayColumnDesc<Double>("DIRECTION",
162 IPosition(1,2),
163 ColumnDesc::Direct));
164 TableMeasRefDesc mdirRef(MDirection::J2000); // default
165 TableMeasValueDesc tmvdMDir(td, "DIRECTION");
166 // the TableMeasDesc gives the column a type
167 TableMeasDesc<MDirection> mdirCol(tmvdMDir, mdirRef);
168 // writing create the measure column
169 mdirCol.write(td);
170 td.addColumn(ScalarColumnDesc<Double>("AZIMUTH"));
171 td.addColumn(ScalarColumnDesc<Double>("ELEVATION"));
172 td.addColumn(ScalarColumnDesc<Float>("PARANGLE"));
173
174 td.addColumn(ScalarColumnDesc<uInt>("TCAL_ID"));
175 td.addColumn(ScalarColumnDesc<uInt>("FIT_ID"));
176
177 td.addColumn(ScalarColumnDesc<uInt>("FOCUS_ID"));
178 td.addColumn(ScalarColumnDesc<uInt>("WEATHER_ID"));
179
180 td.rwKeywordSet().define("OBSMODE", String(""));
181
182 // Now create Table SetUp from the description.
183 SetupNewTable aNewTab("dummy", td, Table::New);
184 table_ = Table(aNewTab, Table::Memory, 0);
185
186 originalTable_ = table_;
187
188}
189
190void asap::Scantable::setupHistoryTable( )
191{
192 TableDesc tdh("", "1", TableDesc::Scratch);
193 tdh.addColumn(ScalarColumnDesc<String>("ITEM"));
194 SetupNewTable histtab("history", tdh, Table::New);
195 Table histTable(histtab, Table::Memory);
196 table_.rwKeywordSet().defineTable("HISTORY", histTable);
197}
198
199void Scantable::setupFitTable()
200{
201 TableDesc td("", "1", TableDesc::Scratch);
202 td.addColumn(ScalarColumnDesc<uInt>("FIT_ID"));
203 td.addColumn(ArrayColumnDesc<String>("FUNCTIONS"));
204 td.addColumn(ArrayColumnDesc<Int>("COMPONENTS"));
205 td.addColumn(ArrayColumnDesc<Double>("PARAMETERS"));
206 td.addColumn(ArrayColumnDesc<Bool>("PARMASK"));
207 td.addColumn(ArrayColumnDesc<String>("FRAMEINFO"));
208 SetupNewTable aNewTab("fits", td, Table::New);
209 Table aTable(aNewTab, Table::Memory);
210 table_.rwKeywordSet().defineTable("FITS", aTable);
211}
212
213void Scantable::attach()
214{
215 historyTable_ = table_.keywordSet().asTable("HISTORY");
216 fitTable_ = table_.keywordSet().asTable("FITS");
217
218 timeCol_.attach(table_, "TIME");
219 srcnCol_.attach(table_, "SRCNAME");
220 specCol_.attach(table_, "SPECTRA");
221 flagsCol_.attach(table_, "FLAGTRA");
222 tsCol_.attach(table_, "TSYS");
223 cycleCol_.attach(table_,"CYCLENO");
224 scanCol_.attach(table_, "SCANNO");
225 beamCol_.attach(table_, "BEAMNO");
226 integrCol_.attach(table_, "INTERVAL");
227 azCol_.attach(table_, "AZIMUTH");
228 elCol_.attach(table_, "ELEVATION");
229 dirCol_.attach(table_, "DIRECTION");
230 paraCol_.attach(table_, "PARANGLE");
231 fldnCol_.attach(table_, "FIELDNAME");
232 rbeamCol_.attach(table_, "REFBEAMNO");
233
234 mfitidCol_.attach(table_,"FIT_ID");
235 fitidCol_.attach(fitTable_,"FIT_ID");
236
237 mfreqidCol_.attach(table_, "FREQ_ID");
238
239 mtcalidCol_.attach(table_, "TCAL_ID");
240
241 mfocusidCol_.attach(table_, "FOCUS_ID");
242
243 mmolidCol_.attach(table_, "MOLECULE_ID");
244}
245
246void Scantable::putSDHeader(const SDHeader& sdh)
247{
248 table_.rwKeywordSet().define("nIF", sdh.nif);
249 table_.rwKeywordSet().define("nBeam", sdh.nbeam);
250 table_.rwKeywordSet().define("nPol", sdh.npol);
251 table_.rwKeywordSet().define("nChan", sdh.nchan);
252 table_.rwKeywordSet().define("Observer", sdh.observer);
253 table_.rwKeywordSet().define("Project", sdh.project);
254 table_.rwKeywordSet().define("Obstype", sdh.obstype);
255 table_.rwKeywordSet().define("AntennaName", sdh.antennaname);
256 table_.rwKeywordSet().define("AntennaPosition", sdh.antennaposition);
257 table_.rwKeywordSet().define("Equinox", sdh.equinox);
258 table_.rwKeywordSet().define("FreqRefFrame", sdh.freqref);
259 table_.rwKeywordSet().define("FreqRefVal", sdh.reffreq);
260 table_.rwKeywordSet().define("Bandwidth", sdh.bandwidth);
261 table_.rwKeywordSet().define("UTC", sdh.utc);
262 table_.rwKeywordSet().define("FluxUnit", sdh.fluxunit);
263 table_.rwKeywordSet().define("Epoch", sdh.epoch);
264}
265
266SDHeader Scantable::getSDHeader() const
267{
268 SDHeader sdh;
269 table_.keywordSet().get("nBeam",sdh.nbeam);
270 table_.keywordSet().get("nIF",sdh.nif);
271 table_.keywordSet().get("nPol",sdh.npol);
272 table_.keywordSet().get("nChan",sdh.nchan);
273 table_.keywordSet().get("Observer", sdh.observer);
274 table_.keywordSet().get("Project", sdh.project);
275 table_.keywordSet().get("Obstype", sdh.obstype);
276 table_.keywordSet().get("AntennaName", sdh.antennaname);
277 table_.keywordSet().get("AntennaPosition", sdh.antennaposition);
278 table_.keywordSet().get("Equinox", sdh.equinox);
279 table_.keywordSet().get("FreqRefFrame", sdh.freqref);
280 table_.keywordSet().get("FreqRefVal", sdh.reffreq);
281 table_.keywordSet().get("Bandwidth", sdh.bandwidth);
282 table_.keywordSet().get("UTC", sdh.utc);
283 table_.keywordSet().get("FluxUnit", sdh.fluxunit);
284 table_.keywordSet().get("Epoch", sdh.epoch);
285 return sdh;
286}
287
288int Scantable::rowToScanIndex( int therow )
289{
290 int therealrow = -1;
291
292 return therealrow;
293}
294
295int Scantable::nScan() const {
296 int n = 0;
297 int previous = -1; int current = 0;
298 for (uInt i=0; i< scanCol_.nrow();i++) {
299 scanCol_.getScalar(i,current);
300 if (previous != current) {
301 previous = current;
302 n++;
303 }
304 }
305 return n;
306}
307
308std::string Scantable::formatSec(Double x) const
309{
310 Double xcop = x;
311 MVTime mvt(xcop/24./3600.); // make days
312
313 if (x < 59.95)
314 return String(" ") + mvt.string(MVTime::TIME_CLEAN_NO_HM, 7)+"s";
315 else if (x < 3599.95)
316 return String(" ") + mvt.string(MVTime::TIME_CLEAN_NO_H,7)+" ";
317 else {
318 ostringstream oss;
319 oss << setw(2) << std::right << setprecision(1) << mvt.hour();
320 oss << ":" << mvt.string(MVTime::TIME_CLEAN_NO_H,7) << " ";
321 return String(oss);
322 }
323};
324
325std::string Scantable::formatDirection(const MDirection& md) const
326{
327 Vector<Double> t = md.getAngle(Unit(String("rad"))).getValue();
328 Int prec = 7;
329
330 MVAngle mvLon(t[0]);
331 String sLon = mvLon.string(MVAngle::TIME,prec);
332 MVAngle mvLat(t[1]);
333 String sLat = mvLat.string(MVAngle::ANGLE+MVAngle::DIG2,prec);
334 return sLon + String(" ") + sLat;
335}
336
337
338std::string Scantable::getFluxUnit() const
339{
340 String tmp;
341 table_.keywordSet().get("FluxUnit", tmp);
342 return tmp;
343}
344
345void Scantable::setFluxUnit(const std::string& unit)
346{
347 String tmp(unit);
348 Unit tU(tmp);
349 if (tU==Unit("K") || tU==Unit("Jy")) {
350 table_.rwKeywordSet().define(String("FluxUnit"), tmp);
351 } else {
352 throw AipsError("Illegal unit - must be compatible with Jy or K");
353 }
354}
355
356void Scantable::setInstrument(const std::string& name)
357{
358 bool throwIt = true;
359 Instrument ins = SDAttr::convertInstrument(name, throwIt);
360 String nameU(name);
361 nameU.upcase();
362 table_.rwKeywordSet().define(String("AntennaName"), nameU);
363}
364
365MPosition Scantable::getAntennaPosition () const
366{
367 Vector<Double> antpos;
368 table_.keywordSet().get("AntennaPosition", antpos);
369 MVPosition mvpos(antpos(0),antpos(1),antpos(2));
370 return MPosition(mvpos);
371}
372
373void Scantable::makePersistent(const std::string& filename)
374{
375 String inname(filename);
376 Path path(inname);
377 inname = path.expandedName();
378 table_.deepCopy(inname, Table::New);
379}
380
381int asap::Scantable::nbeam( int scanno ) const
382{
383 if ( scanno < 0 ) {
384 Int n;
385 table_.keywordSet().get("nBeam",n);
386 return int(n);
387 } else {
388 // take the first POLNO,IFNO,CYCLENO as nbeam shouldn't vary with these
389 Table tab = table_(table_.col("SCANNO") == scanno
390 && table_.col("POLNO") == 0
391 && table_.col("IFNO") == 0
392 && table_.col("CYCLENO") == 0 );
393 ROTableVector<uInt> v(tab, "BEAMNO");
394 return int(v.nelements());
395 }
396 return 0;
397}
398
399int asap::Scantable::nif( int scanno ) const
400{
401 if ( scanno < 0 ) {
402 Int n;
403 table_.keywordSet().get("nIF",n);
404 return int(n);
405 } else {
406 // take the first POLNO,BEAMNO,CYCLENO as nbeam shouldn't vary with these
407 Table tab = table_(table_.col("SCANNO") == scanno
408 && table_.col("POLNO") == 0
409 && table_.col("BEAMNO") == 0
410 && table_.col("CYCLENO") == 0 );
411 ROTableVector<uInt> v(tab, "IFNO");
412 return int(v.nelements());
413 }
414 return 0;
415}
416
417int asap::Scantable::npol( int scanno ) const
418{
419 if ( scanno < 0 ) {
420 Int n;
421 table_.keywordSet().get("nPol",n);
422 return n;
423 } else {
424 // take the first POLNO,IFNO,CYCLENO as nbeam shouldn't vary with these
425 Table tab = table_(table_.col("SCANNO") == scanno
426 && table_.col("IFNO") == 0
427 && table_.col("BEAMNO") == 0
428 && table_.col("CYCLENO") == 0 );
429 ROTableVector<uInt> v(tab, "POLNO");
430 return int(v.nelements());
431 }
432 return 0;
433}
434
435int asap::Scantable::nrow( int scanno ) const
436{
437 if ( scanno < 0 ) {
438 return int(table_.nrow());
439 } else {
440 // take the first POLNO,IFNO,CYCLENO as nbeam shouldn't vary with these
441 Table tab = table_(table_.col("SCANNO") == scanno
442 && table_.col("BEAMNO") == 0
443 && table_.col("IFNO") == 0
444 && table_.col("POLNO") == 0 );
445 return int(tab.nrow());
446 }
447 return 0;
448}
449
450
451int asap::Scantable::nchan( int scanno, int ifno ) const
452{
453 if ( scanno < 0 && ifno < 0 ) {
454 Int n;
455 table_.keywordSet().get("nChan",n);
456 return int(n);
457 } else {
458 // take the first POLNO,IFNO,CYCLENO as nbeam shouldn't vary with these
459 Table tab = table_(table_.col("SCANNO") == scanno
460 && table_.col("IFNO") == ifno
461 && table_.col("BEAMNO") == 0
462 && table_.col("POLNO") == 0
463 && table_.col("CYCLENO") == 0 );
464 ROArrayColumn<Float> v(tab, "SPECTRA");
465 cout << v.shape(0) << endl;
466 return 0;
467 }
468 return 0;
469}
470
471Table Scantable::getHistoryTable() const
472{
473 return table_.keywordSet().asTable("HISTORY");
474}
475
476void Scantable::appendToHistoryTable(const Table& otherHist)
477{
478 Table t = table_.rwKeywordSet().asTable("HISTORY");
479
480 addHistory(asap::SEPERATOR);
481 TableCopy::copyRows(t, otherHist, t.nrow(), 0, otherHist.nrow());
482 addHistory(asap::SEPERATOR);
483}
484
485void Scantable::addHistory(const std::string& hist)
486{
487 Table t = table_.rwKeywordSet().asTable("HISTORY");
488 uInt nrow = t.nrow();
489 t.addRow();
490 ScalarColumn<String> itemCol(t, "ITEM");
491 itemCol.put(nrow, hist);
492}
493
494std::vector<std::string> Scantable::getHistory() const
495{
496 Vector<String> history;
497 const Table& t = table_.keywordSet().asTable("HISTORY");
498 uInt nrow = t.nrow();
499 ROScalarColumn<String> itemCol(t, "ITEM");
500 std::vector<std::string> stlout;
501 String hist;
502 for (uInt i=0; i<nrow; ++i) {
503 itemCol.get(i, hist);
504 stlout.push_back(hist);
505 }
506 return stlout;
507}
508
509std::string Scantable::formatTime(const MEpoch& me, bool showdate) const
510{
511 MVTime mvt(me.getValue());
512 if (showdate)
513 mvt.setFormat(MVTime::YMD);
514 else
515 mvt.setFormat(MVTime::TIME);
516 ostringstream oss;
517 oss << mvt;
518 return String(oss);
519}
520
521void Scantable::calculateAZEL()
522{
523 MPosition mp = getAntennaPosition();
524 MEpoch::ROScalarColumn timeCol(table_, "TIME");
525 ostringstream oss;
526 oss << "Computed azimuth/elevation using " << endl
527 << mp << endl;
528 for (uInt i=0; i<nrow(); ++i) {
529 MEpoch me = timeCol(i);
530 MDirection md = dirCol_(i);
531 dirCol_.get(i,md);
532 oss << " Time: " << formatTime(me,False) << " Direction: " << formatDirection(md)
533 << endl << " => ";
534 MeasFrame frame(mp, me);
535 Vector<Double> azel =
536 MDirection::Convert(md, MDirection::Ref(MDirection::AZEL,
537 frame)
538 )().getAngle("rad").getValue();
539 azCol_.put(i,azel[0]);
540 elCol_.put(i,azel[1]);
541 oss << "azel: " << azel[0]/C::pi*180.0 << " "
542 << azel[1]/C::pi*180.0 << " (deg)" << endl;
543 }
544 pushLog(String(oss));
545}
546
547double Scantable::getInterval(int whichrow) const
548{
549 if (whichrow < 0) return 0.0;
550 Double intval;
551 integrCol_.get(Int(whichrow), intval);
552 return intval;
553}
554
555std::vector<bool> Scantable::getMask(int whichrow) const
556{
557 Vector<uChar> flags;
558 flagsCol_.get(uInt(whichrow), flags);
559 Vector<Bool> bflag(flags.shape());
560 convertArray(bflag, flags);
561 bflag = !bflag;
562 std::vector<bool> mask;
563 bflag.tovector(mask);
564 return mask;
565}
566
567std::vector<float> Scantable::getSpectrum(int whichrow) const
568{
569 Vector<Float> arr;
570 specCol_.get(whichrow, arr);
571 std::vector<float> out;
572 arr.tovector(out);
573 return out;
574}
575
576String Scantable::generateName()
577{
578 return (File::newUniqueName("./","temp")).baseName();
579}
580
581const casa::Table& Scantable::table( ) const
582{
583 return table_;
584}
585
586casa::Table& Scantable::table( )
587{
588 return table_;
589}
590
591std::string Scantable::getPolarizationLabel(bool linear, bool stokes,
592 bool linpol, int polidx) const
593{
594 uInt idx = 0;
595 if (polidx >=0) idx = polidx;
596 return "";
597 //return SDPolUtil::polarizationLabel(idx, linear, stokes, linpol);
598}
599
600void Scantable::unsetSelection()
601{
602 table_ = originalTable_;
603 selector_.reset();
604}
605
606void Scantable::setSelection( const STSelector& selection )
607{
608 Table tab = const_cast<STSelector&>(selection).apply(originalTable_);
609 if ( tab.nrow() == 0 ) {
610 throw(AipsError("Selection contains no data. Not applying it."));
611 }
612 table_ = tab;
613 selector_ = selection;
614}
615
616std::string asap::Scantable::summary( bool verbose )
617{
618 // Format header info
619 ostringstream oss;
620 oss << endl;
621 oss << asap::SEPERATOR << endl;
622 oss << " Scan Table Summary" << endl;
623 oss << asap::SEPERATOR << endl;
624 oss.flags(std::ios_base::left);
625 oss << setw(15) << "Beams:" << setw(4) << nbeam() << endl
626 << setw(15) << "IFs:" << setw(4) << nif() << endl
627 << setw(15) << "Polarisations:" << setw(4) << npol() << endl
628 << setw(15) << "Channels:" << setw(4) << nchan() << endl;
629 oss << endl;
630 String tmp;
631 //table_.keywordSet().get("Observer", tmp);
632 oss << setw(15) << "Observer:" << table_.keywordSet().asString("Observer") << endl;
633 oss << setw(15) << "Obs Date:" << getTime(-1,true) << endl;
634 table_.keywordSet().get("Project", tmp);
635 oss << setw(15) << "Project:" << tmp << endl;
636 table_.keywordSet().get("Obstype", tmp);
637 oss << setw(15) << "Obs. Type:" << tmp << endl;
638 table_.keywordSet().get("AntennaName", tmp);
639 oss << setw(15) << "Antenna Name:" << tmp << endl;
640 table_.keywordSet().get("FluxUnit", tmp);
641 oss << setw(15) << "Flux Unit:" << tmp << endl;
642 Vector<Float> vec;
643 oss << setw(15) << "Rest Freqs:";
644 if (vec.nelements() > 0) {
645 oss << setprecision(10) << vec << " [Hz]" << endl;
646 } else {
647 oss << "none" << endl;
648 }
649 oss << setw(15) << "Abcissa:" << "channel" << endl;
650 oss << selector_.print() << endl;
651 oss << endl;
652 // main table
653 String dirtype = "Position ("
654 + MDirection::showType(dirCol_.getMeasRef().getType())
655 + ")";
656 oss << setw(5) << "Scan"
657 << setw(15) << "Source"
658// << setw(24) << dirtype
659 << setw(10) << "Time"
660 << setw(18) << "Integration" << endl
661 << setw(5) << "" << setw(10) << "Beam" << dirtype << endl
662 << setw(15) << "" << setw(5) << "IF"
663 << setw(8) << "Frame" << setw(16)
664 << "RefVal" << setw(10) << "RefPix" << setw(12) << "Increment" <<endl;
665 oss << asap::SEPERATOR << endl;
666 TableIterator iter(table_, "SCANNO");
667 while (!iter.pastEnd()) {
668 Table subt = iter.table();
669 ROTableRow row(subt);
670 MEpoch::ROScalarColumn timeCol(subt,"TIME");
671 const TableRecord& rec = row.get(0);
672 oss << setw(4) << std::right << rec.asuInt("SCANNO")
673 << std::left << setw(1) << ""
674 << setw(15) << rec.asString("SRCNAME")
675 << setw(10) << formatTime(timeCol(0), false);
676 // count the cycles in the scan
677 TableIterator cyciter(subt, "CYCLENO");
678 int nint = 0;
679 while (!cyciter.pastEnd()) {
680 ++nint;
681 ++cyciter;
682 }
683 oss << setw(3) << std::right << nint << setw(3) << " x " << std::left
684 << setw(6) << formatSec(rec.asFloat("INTERVAL")) << endl;
685
686 TableIterator biter(subt, "BEAMNO");
687 while (!biter.pastEnd()) {
688 Table bsubt = biter.table();
689 ROTableRow brow(bsubt);
690 MDirection::ROScalarColumn bdirCol(bsubt,"DIRECTION");
691 const TableRecord& brec = brow.get(0);
692 oss << setw(6) << "" << setw(10) << brec.asuInt("BEAMNO");
693 oss << setw(24) << formatDirection(bdirCol(0)) << endl;
694 TableIterator iiter(bsubt, "IFNO");
695 while (!iiter.pastEnd()) {
696 Table isubt = iiter.table();
697 ROTableRow irow(isubt);
698 const TableRecord& irec = irow.get(0);
699 oss << std::right <<setw(8) << "" << std::left << irec.asuInt("IFNO");
700 oss << frequencies().print(irec.asuInt("FREQ_ID"));
701
702 ++iiter;
703 }
704 ++biter;
705 }
706 ++iter;
707 }
708 /// @todo implement verbose mode
709 return String(oss);
710}
711
712std::string Scantable::getTime(int whichrow, bool showdate) const
713{
714 MEpoch::ROScalarColumn timeCol(table_, "TIME");
715 MEpoch me;
716 if (whichrow > -1) {
717 me = timeCol(uInt(whichrow));
718 } else {
719 Double tm;
720 table_.keywordSet().get("UTC",tm);
721 me = MEpoch(MVEpoch(tm));
722 }
723 return formatTime(me, showdate);
724}
725
726}//namespace asap
Note: See TracBrowser for help on using the repository browser.