Changeset 322

Timestamp:

01/30/05 01:30:41 (20 years ago)

Author:

kil064

Message:

cache all the ScalarColumn and ArrayColumn objects to avoid reconstructnig
themn for every row get/put.

Location:

trunk/src

Files:

• SDMemTable.cc (modified) (31 diffs)
• SDMemTable.h (modified) (4 diffs)

trunk/src/SDMemTable.cc

@@ -50 +50 @@
 
 #include <tables/Tables/ExprNode.h>
-#include <tables/Tables/ScalarColumn.h>
-#include <tables/Tables/ArrayColumn.h>
 #include <tables/Tables/TableRecord.h>
 #include <measures/Measures/MFrequency.h>
@@ -73 +71 @@
 {
   setup();
+cerr << "Call SDMemTable::attach" << endl;
+  attach();
 }
 
@@ -100 +100 @@
     polSel_ = other.polSel_;
   }
+//
+  attach();
   //cerr << "hello from CC SDMemTable @ " << this << endl;
 }
@@ -135 +137 @@
      chanMask_ = other.chanMask_;
      table_ = other.table_.copyToMemoryTable(String("dummy"));
+     attach();
   }
   //cerr << "hello from ASS SDMemTable @ " << this << endl;
@@ -151 +154 @@
   TableDesc td("", "1", TableDesc::Scratch);
   td.comment() = "A SDMemTable";
+//
   td.addColumn(ScalarColumnDesc<Double>("TIME"));
   td.addColumn(ScalarColumnDesc<String>("SRCNAME"));
@@ -175 +179 @@
 }
 
+void SDMemTable::attach ()
+{
+  timeCol_.attach(table_, "TIME");
+  srcnCol_.attach(table_, "SRCNAME");
+  specCol_.attach(table_, "SPECTRA");
+  flagsCol_.attach(table_, "FLAGTRA");
+  tsCol_.attach(table_, "TSYS");
+  scanCol_.attach(table_, "SCANID");
+  integrCol_.attach(table_, "INTERVAL");
+  freqidCol_.attach(table_, "FREQID");
+  dirCol_.attach(table_, "DIRECTION");
+  fldnCol_.attach(table_, "FIELDNAME");
+  tcaltCol_.attach(table_, "TCALTIME");
+  tcalCol_.attach(table_, "TCAL");
+  azCol_.attach(table_, "AZIMUTH");
+  elCol_.attach(table_, "ELEVATION");
+  paraCol_.attach(table_, "PARANGLE");
+  rbeamCol_.attach(table_, "REFBEAM");
+  histCol_.attach(table_, "HISTORY");
+}
+
+
 std::string SDMemTable::getSourceName(Int whichRow) const
 {
-  ROScalarColumn<String> src(table_, "SRCNAME");
   String name;
-  src.get(whichRow, name);
+  srcnCol_.get(whichRow, name);
   return name;
 }
@@ -187 +212 @@
   Double tm;
   if (whichRow > -1) {
-    ROScalarColumn<Double> src(table_, "TIME");
-    src.get(whichRow, tm);
+    timeCol_.get(whichRow, tm);
   } else {
     table_.keywordSet().get("UTC",tm);
@@ -204 +228 @@
 double SDMemTable::getInterval(Int whichRow) const
 {
-  ROScalarColumn<Double> src(table_, "INTERVAL");
   Double intval;
-  src.get(whichRow, intval);
+  integrCol_.get(whichRow, intval);
   return intval;
 }
@@ -246 +269 @@
 bool SDMemTable::setMask(std::vector<int> whichChans)
 {
-  ROArrayColumn<uChar> spec(table_, "FLAGTRA");
   std::vector<int>::iterator it;
-  uInt n = spec.shape(0)(3);
+  uInt n = flagsCol_.shape(0)(3);
   if (whichChans.empty()) {
     chanMask_ = std::vector<bool>(n,true);
@@ -264 +286 @@
 std::vector<bool> SDMemTable::getMask(Int whichRow) const {
   std::vector<bool> mask;
-  ROArrayColumn<uChar> spec(table_, "FLAGTRA");
   Array<uChar> arr;
-  spec.get(whichRow, arr);
+  flagsCol_.get(whichRow, arr);
   ArrayAccessor<uChar, Axis<asap::BeamAxis> > aa0(arr);
   aa0.reset(aa0.begin(uInt(beamSel_)));//go to beam
@@ -294 +315 @@
 {
   std::vector<float> spectrum;
-  ROArrayColumn<Float> spec(table_, "SPECTRA");
   Array<Float> arr;
-  spec.get(whichRow, arr);
+  specCol_.get(whichRow, arr);
   ArrayAccessor<Float, Axis<asap::BeamAxis> > aa0(arr);
   aa0.reset(aa0.begin(uInt(beamSel_)));//go to beam
@@ -412 +432 @@
 // Continue with km/s or Hz.  Get FreqID
 
-  ROArrayColumn<uInt> fid(table_, "FREQID");
   Vector<uInt> v;
-  fid.get(whichRow, v);
+  freqidCol_.get(whichRow, v);
   uInt specidx = v(IFSel_);
 
@@ -455 +474 @@
 std::string SDMemTable::getAbcissaString(Int whichRow) const
 {
-  ROArrayColumn<uInt> fid(table_, "FREQID");
   Table t = table_.keywordSet().asTable("FREQUENCIES");
 //
@@ -464 +482 @@
 //
   Vector<uInt> v;
-  fid.get(whichRow, v);
+  freqidCol_.get(whichRow, v);
   uInt specidx = v(IFSel_);
 
@@ -485 +503 @@
 void SDMemTable::setSpectrum(std::vector<float> spectrum, int whichRow)
 {
-  ArrayColumn<Float> spec(table_, "SPECTRA");
   Array<Float> arr;
-  spec.get(whichRow, arr);
+  specCol_.get(whichRow, arr);
   if (spectrum.size() != arr.shape()(3)) {
     throw(AipsError("Attempting to set spectrum with incorrect length."));
@@ -504 +521 @@
     it++;
   }
-  spec.put(whichRow, arr);
+  specCol_.put(whichRow, arr);
 }
 
 void SDMemTable::getSpectrum(Vector<Float>& spectrum, Int whichRow) const
 {
-  ROArrayColumn<Float> spec(table_, "SPECTRA");
   Array<Float> arr;
-  spec.get(whichRow, arr);
+  specCol_.get(whichRow, arr);
   spectrum.resize(arr.shape()(3));
   ArrayAccessor<Float, Axis<asap::BeamAxis> > aa0(arr);
@@ -528 +544 @@
 /*
 void SDMemTable::getMask(Vector<Bool>& mask, Int whichRow) const {
-  ROArrayColumn<uChar> spec(table_, "FLAGTRA");
   Array<uChar> arr;
-  spec.get(whichRow, arr);
+  flagsCol_.get(whichRow, arr);
   mask.resize(arr.shape()(3));
 
@@ -563 +578 @@
                                                 Bool useSelection) const 
 {
-  ROArrayColumn<Float> spec(table_, "SPECTRA");
   Array<Float> arr;
-  ROArrayColumn<uChar> flag(table_, "FLAGTRA");
   Array<uChar> farr;
-  spec.get(whichRow, arr);
-  flag.get(whichRow, farr);
+  specCol_.get(whichRow, arr);
+  flagsCol_.get(whichRow, farr);
   Array<Bool> barr(farr.shape());convertArray(barr, farr);
   MaskedArray<Float> marr;
@@ -609 +622 @@
 Float SDMemTable::getTsys(Int whichRow) const
 {
-  ROArrayColumn<Float> ts(table_, "TSYS");
   Array<Float> arr;
-  ts.get(whichRow, arr);
+  tsCol_.get(whichRow, arr);
   Float out;
   IPosition ip(arr.shape());
@@ -622 +634 @@
 {
   MDirection::Types mdr = getDirectionReference();
-  ROArrayColumn<Double> dir(table_, "DIRECTION");
   Array<Double> posit;
-  dir.get(whichRow,posit);
+  dirCol_.get(whichRow,posit);
   Vector<Double> wpos(2);
   wpos[0] = posit(IPosition(2,beamSel_,0));
@@ -637 +648 @@
   MEpoch::Types met = getTimeReference();
 //
-  ROScalarColumn<Double> tme(table_, "TIME");
   Double obstime;
-  tme.get(whichRow,obstime);
+  timeCol_.get(whichRow,obstime);
   MVEpoch tm2(Quantum<Double>(obstime, Unit(String("d"))));
   return MEpoch(tm2, met);
@@ -878 +888 @@
 bool SDMemTable::putSDContainer(const SDContainer& sdc)
 {
-  ScalarColumn<Double> mjd(table_, "TIME");
-  ScalarColumn<String> srcn(table_, "SRCNAME");
-  ScalarColumn<String> fldn(table_, "FIELDNAME");
-  ArrayColumn<Float> spec(table_, "SPECTRA");
-  ArrayColumn<uChar> flags(table_, "FLAGTRA");
-  ArrayColumn<Float> ts(table_, "TSYS");
-  ScalarColumn<Int> scan(table_, "SCANID");
-  ScalarColumn<Double> integr(table_, "INTERVAL");
-  ArrayColumn<uInt> freqid(table_, "FREQID");
-  ArrayColumn<Double> dir(table_, "DIRECTION");
-  ScalarColumn<Int> rbeam(table_, "REFBEAM");
-  ArrayColumn<Float> tcal(table_, "TCAL");
-  ScalarColumn<String> tcalt(table_, "TCALTIME");
-  ScalarColumn<Float> az(table_, "AZIMUTH");
-  ScalarColumn<Float> el(table_, "ELEVATION");
-  ScalarColumn<Float> para(table_, "PARANGLE");
-  ArrayColumn<String> hist(table_, "HISTORY");
-
   uInt rno = table_.nrow();
   table_.addRow();
 
-  mjd.put(rno, sdc.timestamp);
-  srcn.put(rno, sdc.sourcename);
-  fldn.put(rno, sdc.fieldname);
-  spec.put(rno, sdc.getSpectrum());
-  flags.put(rno, sdc.getFlags());
-  ts.put(rno, sdc.getTsys());
-  scan.put(rno, sdc.scanid);
-  integr.put(rno, sdc.interval);
-  freqid.put(rno, sdc.getFreqMap());
-  dir.put(rno, sdc.getDirection());
-  rbeam.put(rno, sdc.refbeam);
-  tcal.put(rno, sdc.tcal);
-  tcalt.put(rno, sdc.tcaltime);
-  az.put(rno, sdc.azimuth);
-  el.put(rno, sdc.elevation);
-  para.put(rno, sdc.parangle);
-  hist.put(rno, sdc.getHistory());
+//  mjd.put(rno, sdc.timestamp);
+  timeCol_.put(rno, sdc.timestamp);
+  srcnCol_.put(rno, sdc.sourcename);
+  fldnCol_.put(rno, sdc.fieldname);
+  specCol_.put(rno, sdc.getSpectrum());
+  flagsCol_.put(rno, sdc.getFlags());
+  tsCol_.put(rno, sdc.getTsys());
+  scanCol_.put(rno, sdc.scanid);
+  integrCol_.put(rno, sdc.interval);
+  freqidCol_.put(rno, sdc.getFreqMap());
+  dirCol_.put(rno, sdc.getDirection());
+  rbeamCol_.put(rno, sdc.refbeam);
+  tcalCol_.put(rno, sdc.tcal);
+  tcaltCol_.put(rno, sdc.tcaltime);
+  azCol_.put(rno, sdc.azimuth);
+  elCol_.put(rno, sdc.elevation);
+  paraCol_.put(rno, sdc.parangle);
+  histCol_.put(rno, sdc.getHistory());
 
   return true;
@@ -922 +915 @@
 SDContainer SDMemTable::getSDContainer(uInt whichRow) const
 {
-  ROScalarColumn<Double> mjd(table_, "TIME");
-  ROScalarColumn<String> srcn(table_, "SRCNAME");
-  ROScalarColumn<String> fldn(table_, "FIELDNAME");
-  ROArrayColumn<Float> spec(table_, "SPECTRA");
-  ROArrayColumn<uChar> flags(table_, "FLAGTRA");
-  ROArrayColumn<Float> ts(table_, "TSYS");
-  ROScalarColumn<Int> scan(table_, "SCANID");
-  ROScalarColumn<Double> integr(table_, "INTERVAL");
-  ROArrayColumn<uInt> freqid(table_, "FREQID");
-  ROArrayColumn<Double> dir(table_, "DIRECTION");
-  ROScalarColumn<Int> rbeam(table_, "REFBEAM");
-  ROArrayColumn<Float> tcal(table_, "TCAL");
-  ROScalarColumn<String> tcalt(table_, "TCALTIME");
-  ROScalarColumn<Float> az(table_, "AZIMUTH");
-  ROScalarColumn<Float> el(table_, "ELEVATION");
-  ROScalarColumn<Float> para(table_, "PARANGLE");
-  ROArrayColumn<String> hist(table_, "HISTORY");
-
   SDContainer sdc(nBeam(),nIF(),nPol(),nChan());
-  mjd.get(whichRow, sdc.timestamp);
-  srcn.get(whichRow, sdc.sourcename);
-  integr.get(whichRow, sdc.interval);
-  scan.get(whichRow, sdc.scanid);
-  fldn.get(whichRow, sdc.fieldname);
-  rbeam.get(whichRow, sdc.refbeam);
-  az.get(whichRow, sdc.azimuth);
-  el.get(whichRow, sdc.elevation);
-  para.get(whichRow, sdc.parangle);
+  timeCol_.get(whichRow, sdc.timestamp);
+  srcnCol_.get(whichRow, sdc.sourcename);
+  integrCol_.get(whichRow, sdc.interval);
+  scanCol_.get(whichRow, sdc.scanid);
+  fldnCol_.get(whichRow, sdc.fieldname);
+  rbeamCol_.get(whichRow, sdc.refbeam);
+  azCol_.get(whichRow, sdc.azimuth);
+  elCol_.get(whichRow, sdc.elevation);
+  paraCol_.get(whichRow, sdc.parangle);
   Vector<Float> tc;
-  tcal.get(whichRow, tc);
+  tcalCol_.get(whichRow, tc);
   sdc.tcal[0] = tc[0];sdc.tcal[1] = tc[1];
-  tcalt.get(whichRow, sdc.tcaltime);
+  tcaltCol_.get(whichRow, sdc.tcaltime);
   Array<Float> spectrum;
   Array<Float> tsys;
@@ -960 +935 @@
   Array<Double> direction;
   Vector<String> histo;
-  spec.get(whichRow, spectrum);
+  specCol_.get(whichRow, spectrum);
   sdc.putSpectrum(spectrum);
-  flags.get(whichRow, flagtrum);
+  flagsCol_.get(whichRow, flagtrum);
   sdc.putFlags(flagtrum);
-  ts.get(whichRow, tsys);
+  tsCol_.get(whichRow, tsys);
   sdc.putTsys(tsys);
-  freqid.get(whichRow, fmap);
+  freqidCol_.get(whichRow, fmap);
   sdc.putFreqMap(fmap);
-  dir.get(whichRow, direction);
+  dirCol_.get(whichRow, direction);
   sdc.putDirection(direction);
-  hist.get(whichRow, histo);
+  histCol_.get(whichRow, histo);
   sdc.putHistory(histo);
   return sdc;
@@ -1024 +999 @@
 Int SDMemTable::nScan() const {
   Int n = 0;
-  ROScalarColumn<Int> scans(table_, "SCANID");
   Int previous = -1;Int current=0;
-  for (uInt i=0; i< scans.nrow();i++) {
-    scans.getScalar(i,current);
+  for (uInt i=0; i< scanCol_.nrow();i++) {
+    scanCol_.getScalar(i,current);
     if (previous != current) {
       previous = current;
@@ -1096 +1070 @@
 
 std::string SDMemTable::summary() const  {
-  ROScalarColumn<Int> scans(table_, "SCANID");
-  ROScalarColumn<String> srcs(table_, "SRCNAME");
 
   // get number of integrations per scan
@@ -1104 +1076 @@
   int scount = 0;
   std::vector<int> cycles;
-  for (uInt i=0; i<scans.nrow();++i) {
-    while (idx == cIdx && i<scans.nrow()) {
-      scans.getScalar(++i,cIdx);
+  for (uInt i=0; i<scanCol_.nrow();++i) {
+    while (idx == cIdx && i<scanCol_.nrow()) {
+      scanCol_.getScalar(++i,cIdx);
       ++scount;
     }
@@ -1167 +1139 @@
   
   std::vector<int>::iterator it = cycles.begin();
-  for (uInt i=0; i< scans.nrow();i++) {
-    scans.getScalar(i,current);
+  for (uInt i=0; i< scanCol_.nrow();i++) {
+    scanCol_.getScalar(i,current);
     if (previous != current) {
-      srcs.getScalar(i,name);
+      srcnCol_.getScalar(i,name);
       previous = current;
       String t = formatSec(Double(getInterval(i)));
@@ -1231 +1203 @@
 bool SDMemTable::appendHistory(const std::string& hist, int whichRow)
 {
-  ArrayColumn<String> histo(table_, "HISTORY");
   Vector<String> history;
-  histo.get(whichRow, history);
+  histCol_.get(whichRow, history);
   history.resize(history.nelements()+1,True);
   history[history.nelements()-1] = hist;
-  histo.put(whichRow, history);
+  histCol_.put(whichRow, history);
 }
 
 std::vector<std::string> SDMemTable::history(int whichRow) const
 {
-  ROArrayColumn<String> hist(table_, "HISTORY");
   Vector<String> history;
-  hist.get(whichRow, history);
+  histCol_.get(whichRow, history);
   std::vector<std::string> stlout;
   // there is no Array<String>.tovector(std::vector<std::string>), so
@@ -1273 +1243 @@
 void SDMemTable::flag(int whichRow)
 {
-  ArrayColumn<uChar> spec(table_, "FLAGTRA");
   Array<uChar> arr;
-  spec.get(whichRow, arr);
+  flagsCol_.get(whichRow, arr);
 
   ArrayAccessor<uChar, Axis<asap::BeamAxis> > aa0(arr);
@@ -1288 +1257 @@
   }
 
-  spec.put(whichRow, arr);
+  flagsCol_.put(whichRow, arr);
 }
 

trunk/src/SDMemTable.h

@@ -37 +37 @@
 // AIPS++
  #include <casa/aips.h>
+#include <casa/Arrays/MaskedArray.h>
 #include <casa/BasicSL/String.h>
+#include <coordinates/Coordinates/SpectralCoordinate.h>
 #include <tables/Tables/Table.h>
-#include <casa/Arrays/MaskedArray.h>
+#include <tables/Tables/ArrayColumn.h>
+#include <tables/Tables/ScalarColumn.h>
+
 #include "SDDefs.h"
 
-#include <coordinates/Coordinates/SpectralCoordinate.h>
+
 
 namespace asap {
@@ -49 +53 @@
 class SDHeader;
 class SDFrequencyTable;
+
+
 
 
@@ -210 +216 @@
   casa::String formatDirection(const casa::MDirection& md) const;
   void setup();
+  void attach();
   // the current cursor into the array
   casa::Int IFSel_,beamSel_,polSel_;
@@ -215 +222 @@
   // the underlying memory table
   casa::Table table_;
+
+// Cached Columns to avoid reconstructing them for each row get/put
+  casa::ScalarColumn<casa::Double> timeCol_, integrCol_;
+  casa::ScalarColumn<casa::Float> azCol_, elCol_, paraCol_;
+  casa::ScalarColumn<casa::String> srcnCol_, fldnCol_, tcaltCol_;
+  casa::ScalarColumn<casa::Int> scanCol_, rbeamCol_;
+  casa::ArrayColumn<casa::Float> specCol_, tsCol_, tcalCol_;
+  casa::ArrayColumn<casa::Double> dirCol_;
+  casa::ArrayColumn<casa::uChar> flagsCol_;
+  casa::ArrayColumn<casa::uInt> freqidCol_;
+  casa::ArrayColumn<casa::String> histCol_;
 };