Changes in / [20:30]

Location:

/trunk/src

Files:

• SDContainer.cc (modified) (1 diff)
• SDContainer.h (modified) (1 diff)
• SDMemTable.cc (modified) (9 diffs)
• SDMemTable.h (modified) (5 diffs)
• SDMemTableWrapper.h (modified) (2 diffs)
• SDReader.cc (modified) (3 diffs)
• SDWriter.cc (added)
• SDWriter.h (added)
• python_SD.cc (modified) (2 diffs)
• python_SD.h (modified) (2 diffs)
• python_SDMemTable.cc (modified) (2 diffs)
• python_SDWriter.cc (added)

/trunk/src/SDContainer.cc

@@ -173 +173 @@
   }
 }
+
+Array<Float> SDContainer::getSpectrum(uInt whichBeam, uInt whichIF) const
+{
+  Matrix<Float> spectra(nChan_, nPol_);
+
+  // Beam.
+  ArrayAccessor<Float, Axis<0> > i0(spectrum_);
+  i0.reset(i0.begin(whichBeam));
+
+  // IF.
+  ArrayAccessor<Float, Axis<1> > i1(i0);
+  i1.reset(i1.begin(whichIF));
+
+  // Polarization.
+  ArrayAccessor<Float, Axis<2> > i2(i1);
+  ArrayAccessor<Float, Axis<1> > o1(spectra);
+
+  while (i2 != i2.end()) {
+    // Channel.
+    ArrayAccessor<Float, Axis<3> > i3(i2);
+    ArrayAccessor<Float, Axis<0> > o0(o1);
+
+    while (i3 != i3.end()) {
+      *o0 = *i3;
+
+      i3++;
+      o0++;
+    }
+
+    i2++;
+    o1++;
+  }
+
+  return spectra;
+}
+
+Array<uChar> SDContainer::getFlags(uInt whichBeam, uInt whichIF) const
+{
+  Matrix<uChar> flagtra(nChan_, nPol_);
+
+  // Beam.
+  ArrayAccessor<uChar, Axis<0> > i0(flags_);
+  i0.reset(i0.begin(whichBeam));
+
+  // IF.
+  ArrayAccessor<uChar, Axis<1> > i1(i0);
+  i1.reset(i1.begin(whichIF));
+
+  // Polarization.
+  ArrayAccessor<uChar, Axis<2> > i2(i1);
+  ArrayAccessor<uChar, Axis<1> > o1(flagtra);
+
+  while (i2 != i2.end()) {
+    // Channel.
+    ArrayAccessor<uChar, Axis<3> > i3(i2);
+    ArrayAccessor<uChar, Axis<0> > o0(o1);
+
+    while (i3 != i3.end()) {
+      *o0 = *i3;
+
+      i3++;
+      o0++;
+    }
+
+    i2++;
+    o1++;
+  }
+
+  return flagtra;
+}
+
+Array<Float> SDContainer::getTsys(uInt whichBeam, uInt whichIF) const
+{
+  Vector<Float> tsys(nPol_);
+
+  // Beam.
+  ArrayAccessor<Float, Axis<0> > i0(tsys_);
+  i0.reset(i0.begin(whichBeam));
+
+  // IF.
+  ArrayAccessor<Float, Axis<1> > i1(i0);
+  i1.reset(i1.begin(whichIF));
+
+  // Channel.
+  ArrayAccessor<Float, Axis<3> > i3(i1);
+
+  // Polarization.
+  ArrayAccessor<Float, Axis<2> > i2(i3);
+  ArrayAccessor<Float, Axis<0> > o0(tsys);
+
+  while (i2 != i2.end()) {
+    *o0 = *i2;
+
+    i2++;
+    o0++;
+  }
+
+  return tsys;
+}

/trunk/src/SDContainer.h

@@ -109 +109 @@
   const Array<uChar>& getFlags() const { return flags_; }
   const Array<Float>& getTsys() const { return tsys_; }
+  
+  Array<Float> getSpectrum(uInt whichBeam, uInt whichIF) const;
+  Array<uChar> getFlags(uInt whichBeam, uInt whichIF) const;
+  Array<Float> getTsys(uInt whichBeam, uInt whichIF) const;
 
   Double timestamp;
   String sourcename;
   Double interval;
-  uInt scanid;
+  Int scanid;
   
 private:

/trunk/src/SDMemTable.cc

@@ -65 +65 @@
   beamSel_(0),
   polSel_(0) {
-  name_ = String(name);
-  Table tab(name_);
-  table_ = tab.copyToMemoryTable(name_);
+  Table tab("dummy");
+  table_ = tab.copyToMemoryTable("dummy");
 }
 
@@ -75 +74 @@
   this->polSel_= other.polSel_;
   this->chanMask_ = other.chanMask_;
-  this->name_ = String("dummy");
   this->table_ = other.table_.copyToMemoryTable(String("dummy"));
   // clear all rows()
@@ -91 +89 @@
   beamSel_(0),
   polSel_(0) {
-  name_ = String("SDMemTable");
   String exprs = String("select * from $1 where SCANID == ")
     +String::toString(scanID);
   cerr << exprs << endl;
   Table t = tableCommand(exprs,tab);
-  table_ = t.copyToMemoryTable(name_);
+  table_ = t.copyToMemoryTable("dummy");
 }
 
@@ -119 +116 @@
   // Now create a new table from the description.
 
-  SetupNewTable aNewTab(name_, td, Table::New);
+  SetupNewTable aNewTab("dummy", td, Table::New);
   table_ = Table(aNewTab, Table::Memory, 0);  
-}
-
-std::string SDMemTable::name() const {
-  return name_;
 }
 
@@ -206 +199 @@
   return mask;
 }
-std::vector<float> SDMemTable::getSpectrum(Int whichRow) const {
+std::vector<float> SDMemTable::getSpectrum(Int whichRow) {
 
   std::vector<float> spectrum;
@@ -222 +215 @@
   }
   return spectrum;
+}
+void SDMemTable::getSpectrum(Vector<Float>& spectrum, Int whichRow=0) {
+  ROArrayColumn<Float> spec(table_, "SPECTRA");
+  Array<Float> arr;
+  spec.get(whichRow, arr);
+  spectrum.resize(arr.shape()(3));
+  ArrayAccessor<Float, Axis<0> > aa0(arr);
+  aa0.reset(aa0.begin(uInt(beamSel_)));//go to beam
+  ArrayAccessor<Float, Axis<1> > aa1(aa0);
+  aa1.reset(aa1.begin(uInt(IFSel_)));// go to IF
+  ArrayAccessor<Float, Axis<2> > aa2(aa1);
+  aa2.reset(aa2.begin(uInt(polSel_)));// go to pol
+
+  ArrayAccessor<Float, Axis<0> > va(spectrum);
+  for (ArrayAccessor<Float, Axis<3> > i(aa2); i != i.end(); ++i) {
+    (*va) = (*i);
+    va++;
+  }
+}
+
+void SDMemTable::getMask(Vector<Bool>& mask, Int whichRow=0) const {
+  ROArrayColumn<uChar> spec(table_, "FLAGTRA");
+  Array<uChar> arr;
+  spec.get(whichRow, arr);
+  mask.resize(arr.shape()(3));
+
+  ArrayAccessor<uChar, Axis<0> > aa0(arr);
+  aa0.reset(aa0.begin(uInt(beamSel_)));//go to beam
+  ArrayAccessor<uChar, Axis<1> > aa1(aa0);
+  aa1.reset(aa1.begin(uInt(IFSel_)));// go to IF
+  ArrayAccessor<uChar, Axis<2> > aa2(aa1);
+  aa2.reset(aa2.begin(uInt(polSel_)));// go to pol
+
+  Bool useUserMask = ( chanMask_.size() == arr.shape()(3) );
+  
+  ArrayAccessor<Bool, Axis<0> > va(mask);
+  std::vector<bool> tmp;
+  tmp = chanMask_; // WHY the fxxx do I have to make a copy here. The
+                   // iterator should work on chanMask_??
+  std::vector<bool>::iterator miter;
+  miter = tmp.begin();
+
+  for (ArrayAccessor<uChar, Axis<3> > i(aa2); i != i.end(); ++i) {
+    bool out =!static_cast<bool>(*i);
+    if (useUserMask) {
+      out = out && (*miter);
+      miter++;
+    }
+    (*va) = out;
+    va++;
+  }  
 }
 
@@ -303 +347 @@
 }
 
+SDContainer SDMemTable::getSDContainer(uInt whichRow) const {
+  ROScalarColumn<Double> mjd(table_, "TIME");
+  ROScalarColumn<String> srcn(table_, "SRCNAME");
+  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");
+
+  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);
+  Array<Float> spectrum;
+  Array<Float> tsys;
+  Array<uChar> flagtrum;
+  spec.get(whichRow, spectrum);
+  sdc.putSpectrum(spectrum);
+  flags.get(whichRow, flagtrum);
+  sdc.putFlags(flagtrum);
+  ts.get(whichRow, tsys);
+  sdc.putTsys(tsys);
+  return sdc;
+}
 bool SDMemTable::putSDHeader(const SDHeader& sdh) {
   table_.lock();
@@ -322 +391 @@
   cerr << "Table Header set" << endl;
   return true;
-}
-
+}\
+
+SDHeader SDMemTable::getSDHeader() const {
+  SDHeader sdh;
+  table_.keywordSet().get("nBeam",sdh.nbeam);
+  table_.keywordSet().get("nIF",sdh.nif);
+  table_.keywordSet().get("nPol",sdh.npol);
+  table_.keywordSet().get("nChan",sdh.nchan);
+  table_.keywordSet().get("Observer", sdh.observer);
+  table_.keywordSet().get("Project", sdh.project);
+  table_.keywordSet().get("Obstype", sdh.obstype);
+  table_.keywordSet().get("AntennaName", sdh.antennaname);
+  table_.keywordSet().get("AntennaPosition", sdh.antennaposition);
+  table_.keywordSet().get("Equinox", sdh.equinox);
+  table_.keywordSet().get("FreqRefFrame", sdh.freqref);
+  table_.keywordSet().get("FreqRefVal", sdh.reffreq);
+  table_.keywordSet().get("Bandwidth", sdh.bandwidth);
+  table_.keywordSet().get("UTC", sdh.utc);
+  return sdh;
+}
 void SDMemTable::makePersistent(const std::string& filename) {
   table_.deepCopy(filename,Table::New);
@@ -376 +463 @@
   return n;
 }
-
 /*
 void SDMemTable::maskChannels(const std::vector<Int>& whichChans ) {

/trunk/src/SDMemTable.h

@@ -69 +69 @@
   virtual bool putSDHeader(const SDHeader& sdh);
   virtual bool putSDFreqTable(const SDFrequencyTable& sdft) {;}
+
+  //get the dat wrapped up in a meta container
+  virtual SDContainer getSDContainer(uInt whichRow=0) const;
+  virtual SDHeader getSDHeader() const;
   
   // get spectrum,mask and tsys for the given row, at the selected
-  // cursor
-  virtual std::vector<float> getSpectrum(Int whichRow) const;
+  // cursor - all as stl vectors
+  virtual std::vector<float> getSpectrum(Int whichRow);
   virtual std::vector<bool> getMask(Int whichRow) const;
+
   virtual Float getTsys(Int whichRow) const;
+  // get all as aips++ Vectors
+  virtual void getSpectrum(Vector<Float>& spectrum, Int whichRow=0);
+  virtual void getMask(Vector<Bool>& mask,Int whichRow=0) const;
 
-  // get info fro current row
+  // get info for current row
   virtual Double getTime(Int whichRow) const ;
   virtual std::string getSourceName(Int whichRow) const;
@@ -95 +103 @@
   virtual void summary() const;
   
-  // the (irrelevant) name 
-  std::string name() const;
-
   // write to disk as aips++ table
   void makePersistent(const std::string& filename);
@@ -104 +109 @@
   SDMemTable getScan(Int scanID);
 
-  const TableRecord& getHeader() const {;}
+  const TableRecord& getHeader() const {return table_.keywordSet();}
   // get a handle to the "raw" aips++ table
   const Table& table() { return table_; }
@@ -114 +119 @@
   Int nChan() const;
 
+  // return the number of rows (integrations) in the table
+  Int nRows() const { return table_.nrow(); }
+
   // return a row as a Masked array, internally converting uChar flags
   // to bool mask
@@ -120 +128 @@
 
 private:
-  // set up tabel structure
+  // set up table structure
   void setup();
   // the current cursor into the array

/trunk/src/SDMemTableWrapper.h

@@ -97 +97 @@
   CountedPtr<SDMemTable> getCP() const {return table_;}
   void summary() { table_->summary(); }
-  std::string name() { return table_->name(); }
   
 private:
@@ -125 +124 @@
   SDMemTableWrapper multiply(const SDMemTableWrapper& in,
                              Float factor) {
-    return SDMemTableWrapper(SDMath::multiply(in.getCP(),factor));
+    return SDMemTableWrapper(SDMath::multiply(in.getCP(),factor));    
   }
+  /*
+  std::vector<float> baseline(const SDMemTableWrapper& in, const std::string& fitexpr) {
+    return SDMath::baseline(in.getCP(), fitexpr);
+  }
+  */
 };
 

/trunk/src/SDReader.cc

@@ -77 +77 @@
     return;
   }
+
   nBeam_ = beams.nelements();
-  //cout << "Reading " + format + " format from " + inName << endl;
-  //cout << "nChannels = " << nChan_ << ", " << "nPol = " << nPol_ << endl
-  //     << "nIF = " << nIF_ << endl 
-  //     << "nBeams = " << nBeam_ << endl;
-  
   // Get basic parameters.
   header_ = SDHeader();
@@ -89 +85 @@
   header_.nbeam = nBeam_;
 
-  //cerr << " getting header ..." << endl;
   Int status = reader_->getHeader(header_.observer, header_.project, 
                                   header_.antennaname, header_.antennaposition,
@@ -135 +130 @@
   Complex         xCalFctr;
   Vector<Complex> xPol;
-  mjd = 0;
   uInt n = seq.size();
-  //cerr <<  header_.nif << ", " << header_.nbeam << endl;
+
   uInt stepsize = header_.nif*header_.nbeam;
   cerr << "SDReader stepsize = " << stepsize << endl;
-  uInt scanid = 0;
-  String prevName = "_noname_";// temporary until scanid is present
   uInt seqi = 0;
   //SDFrequencyTable sdft();

/trunk/src/python_SD.cc

@@ -27 +27 @@
 //#                        AUSTRALIA
 //#
-//# $Id:
+//# $Id$
 //#---------------------------------------------------------------------------
 #include <string>
@@ -41 +41 @@
   atnf_sd::python::python_SDMemTable();
   atnf_sd::python::python_SDReader();
+  atnf_sd::python::python_SDWriter();
   atnf_sd::python::python_SDMath();
 

/trunk/src/python_SD.h

@@ -27 +27 @@
 //#                        AUSTRALIA
 //#
-//# $Id:
+//# $Id$
 //#---------------------------------------------------------------------------
 #ifndef _PYTHON_SD_H_
@@ -37 +37 @@
 void python_SDMemTable();
 void python_SDReader();
+void python_SDWriter();
 void python_SDMath();
 

/trunk/src/python_SDMemTable.cc

@@ -46 +46 @@
     .def( init < SDMemTableWrapper, int > () )
     .def("getscan", &SDMemTableWrapper::getScan)
-    .def("getspectrum", &SDMemTableWrapper::getSpectrum)
-    .def("getmask", &SDMemTableWrapper::getMask)
+    .def("getspectrum", &SDMemTableWrapper::getSpectrum,
+         (boost::python::arg("whichRow")=0) )
+    .def("getmask", &SDMemTableWrapper::getMask,
+         (boost::python::arg("whichRow")=0) )
     .def("gettsys", &SDMemTableWrapper::getTsys)
     .def("getsourcename", &SDMemTableWrapper::getSourceName)
@@ -66 +68 @@
     .def("makepersistent",  &SDMemTableWrapper::makePersistent)
     .def("summary",  &SDMemTableWrapper::summary)
-    .def("name",  &SDMemTableWrapper::name)
   ;
 };