source: trunk/src/SDMemTable.cc @ 83

Last change on this file since 83 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.