Changeset 847 for trunk/src

Timestamp:

02/24/06 10:03:21 (19 years ago)

Author:

mar637

Message:

numerous changes before move to new svn repository sourcecode.atnf.csiro.au

Location:

trunk/src

Files:

• SDMemTableWrapper.h (modified) (5 diffs)
• STFiller.cpp (modified) (1 diff)
• STFrequencies.cpp (modified) (9 diffs)
• STFrequencies.h (modified) (3 diffs)
• STMath.cpp (modified) (1 diff)
• STMolecules.cpp (modified) (1 diff)
• STMolecules.h (modified) (1 diff)
• Scantable.cpp (modified) (8 diffs)
• Scantable.h (modified) (3 diffs)

trunk/src/SDMemTableWrapper.h

@@ -1 @@
-//#---------------------------------------------------------------------------
-//# SDMemTableWrapper.h: Wrapper classes to use CountedPtr
-//#---------------------------------------------------------------------------
-//# Copyright (C) 2004
-//# ATNF
-//#
-//# This program is free software; you can redistribute it and/or modify it
-//# under the terms of the GNU General Public License as published by the Free
-//# Software Foundation; either version 2 of the License, or (at your option)
-//# any later version.
-//#
-//# This program is distributed in the hope that it will be useful, but
-//# WITHOUT ANY WARRANTY; without even the implied warranty of
-//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
-//# Public License for more details.
-//#
-//# You should have received a copy of the GNU General Public License along
-//# with this program; if not, write to the Free Software Foundation, Inc.,
-//# 675 Massachusetts Ave, Cambridge, MA 02139, USA.
-//#
-//# Correspondence concerning this software should be addressed as follows:
-//#        Internet email: Malte.Marquarding@csiro.au
-//#        Postal address: Malte Marquarding,
-//#                        Australia Telescope National Facility,
-//#                        P.O. Box 76,
-//#                        Epping, NSW, 2121,
-//#                        AUSTRALIA
-//#
-//# $Id:
-//#---------------------------------------------------------------------------
-#ifndef SDMEMTABLEWRAPPER_H
-#define SDMEMTABLEWRAPPER_H
+//
+// C++ Interface: Scantable
+//
+// Description:
+//
+//
+// Author: Malte Marquarding <asap@atnf.csiro.au>, (C) 2006
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#ifndef ASAPSCANTABLEWRAPPER_H
+#define ASAPSCANTABLEWRAPPER_H
 
 #include <vector>
@@ -38 +19 @@
 #include "MathUtils.h"
 #include "SDFitTable.h"
-#include "SDMemTable.h"
+#include "Scantable.h"
 
 namespace asap {
-
-class SDMemTableWrapper {
+/**
+  * This class contains and wraps a CountedPtr<Scantable>, as the CountedPtr
+  * class does not provide the dor operator which is need for references
+  * in boost::python
+  * see Scantable for interfce description
+  *
+  * @brief The main ASAP data container wrapper
+  * @author Malte Marquarding
+  * @date 2006-02-23
+  * @version 2.0a
+*/
+class ScantableWrapper {
 
 public:
-  SDMemTableWrapper(const std::string& name) :
-    table_(new SDMemTable(name)) {;}
-  SDMemTableWrapper() :
-    table_(new SDMemTable()) {;}
-
-  SDMemTableWrapper(casa::CountedPtr<SDMemTable> cp) : table_(cp) {;}
-  //SDMemTableWrapper(SDMemTable* sdmt) : table_(sdmt) {;}
-  SDMemTableWrapper(const SDMemTableWrapper& mt) :
+  ScantableWrapper(const std::string& name) :
+    table_(new Scantable(name)) {;}
+
+  ScantableWrapper() :
+    table_(new Scantable()) {;}
+
+  ScantableWrapper(casa::CountedPtr<Scantable> cp) : table_(cp) {;}
+
+  ScantableWrapper(const ScantableWrapper& mt) :
     table_(mt.getCP()) {;}
 
-  SDMemTableWrapper(const SDMemTableWrapper& mt, const std::string& expr) :
-    table_(new SDMemTable(mt.getCP()->table(), expr)) {;}
-
-  SDMemTableWrapper copy() {
-    //CountedPtr<SDMemTable> cp = new SDMemTable(*this, False);
-    return SDMemTableWrapper(new SDMemTable(*(this->getCP()), casa::False));
-  }
-
-  SDMemTableWrapper getScan(std::vector<int> scan) {
-    casa::String cond("SELECT FROM $1 WHERE SCANID IN ");
-    casa::Vector<casa::Int> v(scan);
-    casa::ostringstream oss;
-    oss << v;
-    cond += casa::String(oss);
-    return SDMemTableWrapper(*this, cond);
-  }
-
-  SDMemTableWrapper getSource(const std::string& source) {
-    casa::String cond("SELECT * from $1 WHERE SRCNAME == pattern('");
-    cond += source;cond += "')";
-    return SDMemTableWrapper(*this, cond);
-  }
-
-  SDMemTableWrapper getSQL(const std::string& sqlexpr) {
-    return SDMemTableWrapper(*this, sqlexpr);
-  }
+  ScantableWrapper(const ScantableWrapper& mt, const std::string& expr) :
+    table_(new Scantable(mt.getCP()->table(), expr)) {;}
+
+  ScantableWrapper copy() {
+    return ScantableWrapper(new Scantable(*(this->getCP()), false));
+  }
+
 
   std::vector<float> getSpectrum(int whichRow=0) const {
@@ -148 +121 @@
   }
 
-  void setSpectrum(std::vector<float> spectrum, int whichRow=0) {
-      table_->setSpectrum(spectrum, whichRow);
-  }
-
-  bool setIF(int whichIF=0) {return table_->setIF(whichIF);}
-  bool setBeam(int whichBeam=0) {return table_->setBeam(whichBeam);}
-  bool setPol(int whichPol=0) {return table_->setPol(whichPol);}
-
-  int getIF() {return table_->getIF();}
-  int getBeam() {return table_->getBeam();}
-  int getPol() {return table_->getPol();}
-
-  int nIF() {return table_->nIF();}
-  int nBeam() {return table_->nBeam();}
-  int nPol() {return table_->nPol();}
-  int nChan() {return table_->nChan();}
-  int nScan() {return table_->nScan();}
-  int nRow() {return table_->nRow();}
-  int nStokes() {return table_->nStokes();}
-
-  //sets the mask
-  bool setChannels(const std::vector<int>& whichChans) {
-    return setChannels(whichChans);
-  }
+  void setSpectrum(std::vector<float> spectrum, int whichrow=0) {
+      table_->setSpectrum(spectrum, whichrow);
+  }
+
+  int getIF(int whichrow) {return table_->getIF(whichrow);}
+  int getBeam(int whichrow) {return table_->getBeam(whichrow);}
+  int getPol(int whichrow) {return table_->getPol(whichrow);}
+
+  STSelector getSelection() { return table_->getSelection(); }
+
+  int nif(int scanno=-1) {return table_->nif(scanno);}
+  int nbeam(int scanno=-1) {return table_->nbeam(scanno);}
+  int npol(int scanno=-1) {return table_->npol(scanno);}
+  int nchan(int ifno=-1) {return table_->nchan(ifno);}
+  int nscan() {return table_->nscan();}
+  int nrow() {return table_->nrow();}
+  ///@todo int nstokes() {return table_->nStokes();}
+
   void makePersistent(const std::string& fname) {
     table_->makePersistent(fname);
   }
 
-  bool setRestFreqs(const std::vector<double>& restfreqs,
-                    const std::string& unit,
-                    const std::vector<std::string>& lines,
-                    const std::string& source, int whichIF) {
-    casa::Vector<casa::Double> restFreqs2(restfreqs);
-    return table_->setRestFreqs(restFreqs2, casa::String(unit),
-                                lines, casa::String(source),
-                                casa::Int(whichIF));
-  }
-
-  std::string spectralLines() const {return table_->spectralLines();}
-
-  std::vector<double> getRestFreqs() {
-    return table_->getRestFreqs();
+  void setRestFreqs(double rf, const std::string& unit) {
+    table_->setRestFreqs(rf, unit);
+  }
+
+  void setRestFreqs(const std::string& name) {
+    table_->setRestFreqs(name);
+  }
+
+  std::vector<double> getRestFrequencies() {
+    return table_->getRestFrequencies();
   }
 
@@ -199 +162 @@
   }
 
-  casa::CountedPtr<SDMemTable> getCP() const {return table_;}
-  SDMemTable* getPtr() {return &(*table_);}
+  casa::CountedPtr<Scantable> getCP() const {return table_;}
+  Scantable* getPtr() {return &(*table_);}
 
   std::string summary(bool verbose=false) const {
@@ -230 +193 @@
 
 private:
-  casa::CountedPtr<SDMemTable> table_;
+  casa::CountedPtr<Scantable> table_;
 };
 

trunk/src/STFiller.cpp

@@ -67 +67 @@
 {
   if (table_.null())  {
-    cout << "new scnatbale object" << endl;
     table_ = new Scantable();
   }

trunk/src/STFrequencies.cpp

@@ -33 +33 @@
 namespace asap {
 
-const casa::String STFrequencies::name_ = "FREQUENCIES";
-
-STFrequencies::STFrequencies(casa::Table::TableType tt) :
+const String STFrequencies::name_ = "FREQUENCIES";
+
+STFrequencies::STFrequencies(Table::TableType tt) :
   STSubTable( name_, tt )
 {
@@ -53 +53 @@
   table_.addColumn(ScalarColumnDesc<Double>("INCREMENT"));
 
-  table_.rwKeywordSet().define("REFFRAME", String("TOPO"));
+  table_.rwKeywordSet().define("FRAME", String("TOPO"));
+  table_.rwKeywordSet().define("BASEFRAME", String("TOPO"));
   table_.rwKeywordSet().define("EQUINOX",String( "J2000"));
   table_.rwKeywordSet().define("UNIT", String("Hz"));
@@ -108 +109 @@
 }
 
-SpectralCoordinate STFrequencies::getSpectralCoordinate( uInt freqID )
-{
-  Table t = table_(table_.col("ID") == Int(freqID) );
+SpectralCoordinate STFrequencies::getSpectralCoordinate( uInt id ) const
+{
+  Table t = table_(table_.col("ID") == Int(id) );
 
   if (t.nrow() == 0 ) {
-    throw(AipsError("STFrequencies::getSpectralCoordinate - freqID out of range"));
+    throw(AipsError("STFrequencies::getSpectralCoordinate - ID out of range"));
   }
 
@@ -121 +122 @@
   const TableRecord& rec = row.get(0);
 
-  return SpectralCoordinate( getFrame(), rec.asDouble("REFVAL"),
+  return SpectralCoordinate( getFrame(true), rec.asDouble("REFVAL"),
                              rec.asDouble("INCREMENT"),
                              rec.asDouble("REFPIX"));
 }
 
-void STFrequencies::rescale( casa::Float factor, const std::string& mode )
+SpectralCoordinate
+  asap::STFrequencies::getSpectralCoordinate( const MDirection& md,
+                                              const MPosition& mp,
+                                              const MEpoch& me,
+                                              Double restfreq, uInt id ) const
+{
+  SpectralCoordinate spc = getSpectralCoordinate(id);
+  spc.setRestFrequency(restfreq, True);
+  if ( !spc.setReferenceConversion(getFrame(), me, mp, md) ) {
+    throw(AipsError("Couldn't convert frequency frame."));
+  }
+  String unitstr = getUnitString();
+  if ( !unitstr.empty() ) {
+    Unit unitu(unitstr);
+    if ( unitu == Unit("Hz") ) {
+    } else {
+      spc.setVelocity(unitstr, getDoppler());
+    }
+  }
+  return spc;
+}
+
+
+void STFrequencies::rescale( Float factor, const std::string& mode )
 {
   TableRow row(table_);
@@ -137 +161 @@
     const TableRecord& rec = row.get(i);
 
-    SpectralCoordinate sc ( getFrame(), rec.asDouble("REFVAL"),
+    SpectralCoordinate sc ( getFrame(true), rec.asDouble("REFVAL"),
                             rec.asDouble("INCREMENT"), rec.asDouble("REFPIX") );
 
@@ -177 +201 @@
 
 
-casa::MFrequency::Types STFrequencies::getFrame( ) const
+MFrequency::Types STFrequencies::getFrame(bool base) const
 {
   // get the ref frame
-  String rf;
-  table_.keywordSet().get("REFFRAME", rf);
+  String rf = table_.keywordSet().asString("BASEFRAME");
 
   // Create SpectralCoordinate (units Hz)
@@ -192 +215 @@
 
   return mft;
+}
+
+std::string asap::STFrequencies::getFrameString( bool base ) const
+{
+  if ( base ) return table_.keywordSet().asString("BASEFRAME");
+  else return table_.keywordSet().asString("FRAME");
+}
+
+std::string asap::STFrequencies::getUnitString( ) const
+{
+  return table_.keywordSet().asString("UNIT");
+}
+
+Unit asap::STFrequencies::getUnit( ) const
+{
+  return Unit(table_.keywordSet().asString("UNIT"));
+}
+
+std::string asap::STFrequencies::getDopplerString( ) const
+{
+  return table_.keywordSet().asString("DOPPLER");
+}
+
+MDoppler::Types asap::STFrequencies::getDoppler( ) const
+{
+  String dpl = table_.keywordSet().asString("DOPPLER");
+
+  // Create SpectralCoordinate (units Hz)
+  MDoppler::Types mdt;
+  if (!MDoppler::getType(mdt, dpl)) {
+    throw(AipsError("Doppler type unknown"));
+  }
+  return mdt;
 }
 
@@ -226 +282 @@
   const Record& r = table_.keywordSet();
   const Record& ro = other.table_.keywordSet();
-  return ( r.asString("REFFRAME") == ro.asString("REFFRAME") &&
+  return ( r.asString("FRAME") == ro.asString("FRAME") &&
            r.asString("EQUINOX") == ro.asString("EQUINOX") &&
            r.asString("UNIT") == ro.asString("UNIT") &&
@@ -233 +289 @@
 }
 
+std::vector< std::string > asap::STFrequencies::getInfo( ) const
+{
+  const Record& r = table_.keywordSet();
+  std::vector<std::string> out;
+  out.push_back(r.asString("UNIT"));
+  out.push_back(r.asString("FRAME"));
+  out.push_back(r.asString("DOPPLER"));
+}
+
+void asap::STFrequencies::setInfo( const std::vector< std::string >& theinfo )
+{
+  if ( theinfo.size() != 3 ) throw(AipsError("setInfo needs three parameters"));
+  String un,rfrm,dpl;
+  un = theinfo[0];rfrm = theinfo[1];dpl = theinfo[2];
+  TableRecord& r = table_.rwKeywordSet();
+  setFrame(rfrm);
+  MDoppler::Types dtype;
+  dpl.upcase();
+  if (!MDoppler::getType(dtype, dpl)) {
+    throw(AipsError("Doppler type unknown"));
+  } else {
+    r.define("DOPPLER",dpl);
+  }
+}
+void asap::STFrequencies::setFrame( const std::string & frame )
+{
+  MFrequency::Types mdr;
+  if (!MFrequency::getType(mdr, frame)) {
+    Int a,b;const uInt* c;
+    const String* valid = MFrequency::allMyTypes(a, b, c);
+    String pfix = "Please specify a legal frame type. Types are\n";
+    throw(AipsError(pfix+(*valid)));
+  } else {
+    table_.rwKeywordSet().define("FRAME", frame);
+  }
+}
+
 } // namespace

trunk/src/STFrequencies.h

@@ -62 +62 @@
    * @return casa::SpectralCoordinate
    */
-  casa::SpectralCoordinate getSpectralCoordinate( casa::uInt freqID );
+  casa::SpectralCoordinate getSpectralCoordinate( casa::uInt freqID ) const;
+
+  casa::SpectralCoordinate getSpectralCoordinate( const casa::MDirection& md,
+                                                  const casa::MPosition& mp,
+                                                  const casa::MEpoch& me,
+                                                  casa::Double restfreq,
+                                                  casa::uInt freqID
+                                                  ) const;
 
   /**
@@ -68 +75 @@
    * @return casa::Unit
    */
-  const casa::Unit& getUnit() const;
+  casa::Unit getUnit() const;
+  std::string getUnitString() const;
+
   /**
    * Return the doppler type of the values
-   * @return casa::MDoppler
+   * @return casa::MDoppler::Types
    */
-  casa::MDoppler getDoppler() const;
+  casa::MDoppler::Types getDoppler() const;
+  std::string getDopplerString() const;
 
 
   /**
    * Return the frame type, e.g MFrequency::TOPO
+   * @param base return the base frame or the user frame
    * @return casa::MFrequency::Types
    */
-  casa::MFrequency::Types getFrame() const;
+  casa::MFrequency::Types getFrame(bool base=false) const;
 
   /**
    * Return a string representation of the frame type, e.g TOPO
-   * @return
+   * @param base return the base frame or the user frame
+   * @return the string representation of the frame
    */
-  std::string getFrameString() const;
+  std::string getFrameString(bool base=false) const;
 
   /**
@@ -124 +136 @@
   std::string print(int id=-1);
 
+  std::vector<std::string> getInfo() const;
+  void setInfo( const std::vector<std::string>& theinfo );
+
 private:
 

trunk/src/STMath.cpp

@@ -811 +811 @@
   setInsitu(insitu);
   Table& tout = out->table();
-  cout << "nrows " << in[1]->table().nrow() << endl;
   ScalarColumn<uInt> freqidcol(tout,"FREQ_ID"), molidcol(tout, "MOLECULE_ID");
   ScalarColumn<uInt> scannocol(tout,"SCANNO"),focusidcol(tout,"FOCUS_ID");

trunk/src/STMolecules.cpp

@@ -93 +93 @@
 }
 
+std::vector< double > asap::STMolecules::getRestFrequencies( ) const
+{
+  std::vector<double> out;
+  Vector<Double> rfs = restfreqCol_.getColumn();
+  rfs.tovector(out);
+  return out;
+}
+
 } //namespace

trunk/src/STMolecules.h

@@ -39 +39 @@
                  casa::String& formattedname, casa::uInt id);
 
+  std::vector<double> getRestFrequencies() const;
+
 private:
   void setup();

trunk/src/Scantable.cpp

@@ -224 +224 @@
   scanCol_.attach(table_, "SCANNO");
   beamCol_.attach(table_, "BEAMNO");
+  ifCol_.attach(table_, "IFNO");
+  polCol_.attach(table_, "POLNO");
   integrCol_.attach(table_, "INTERVAL");
   azCol_.attach(table_, "AZIMUTH");
@@ -292 +294 @@
 
 
-int Scantable::rowToScanIndex( int therow )
-{
-  int therealrow = -1;
-
-  return therealrow;
-}
-
 int Scantable::nscan() const {
   int n = 0;
@@ -344 +339 @@
 std::string Scantable::getFluxUnit() const
 {
-  String tmp;
-  table_.keywordSet().get("FluxUnit", tmp);
-  return tmp;
+  return table_.keywordSet().asString("FluxUnit");
 }
 
@@ -485 +478 @@
   }
   return 0;
+}
+
+
+int Scantable::getBeam(int whichrow) const
+{
+  return beamCol_(whichrow);
+}
+
+int Scantable::getIF(int whichrow) const
+{
+  return ifCol_(whichrow);
+}
+
+int Scantable::getPol(int whichrow) const
+{
+  return polCol_(whichrow);
 }
 
@@ -563 +572 @@
 }
 
-double Scantable::getInterval(int whichrow) const
-{
-  if (whichrow < 0) return 0.0;
-  Double intval;
-  integrCol_.get(Int(whichrow), intval);
-  return intval;
-}
-
 std::vector<bool> Scantable::getMask(int whichrow) const
 {
@@ -619 +620 @@
 {
   table_ = originalTable_;
+  attach();
   selector_.reset();
 }
@@ -629 +631 @@
   }
   table_ = tab;
+  attach();
   selector_ = selection;
 }
@@ -742 +745 @@
 }
 
+std::string Scantable::getAbcissaLabel( int whichrow ) const
+{
+  if ( whichrow > table_.nrow() ) throw(AipsError("Illegal ro number"));
+  const MPosition& mp = getAntennaPosition();
+  const MDirection& md = dirCol_(whichrow);
+  const MEpoch& me = timeCol_(whichrow);
+  const Double& rf = mmolidCol_(whichrow);
+  SpectralCoordinate spc =
+    freqTable_.getSpectralCoordinate(md, mp, me, rf, mfreqidCol_(whichrow));
+
+  String s = "Channel";
+  Unit u = Unit(freqTable_.getUnitString());
+  if (u == Unit("km/s")) {
+    s = CoordinateUtil::axisLabel(spc,0,True,True,True);
+  } else if (u == Unit("Hz")) {
+    Vector<String> wau(1);wau = u.getName();
+    spc.setWorldAxisUnits(wau);
+
+    s = CoordinateUtil::axisLabel(spc,0,True,True,False);
+  }
+  return s;
+
+}
+
+void asap::Scantable::setRestFrequencies( double rf, const std::string& unit )
+{
+  ///@todo lookup in line table
+  Unit u(unit);
+  Quantum<Double> urf(rf, u);
+  uInt id = moleculeTable_.addEntry(urf.getValue("Hz"), "", "");
+  TableVector<uInt> tabvec(table_, "MOLECULE_ID");
+  tabvec = id;
+}
+
+void asap::Scantable::setRestFrequencies( const std::string& name )
+{
+  throw(AipsError("setRestFrequencies( const std::string& name ) NYI"));
+  ///@todo implement
+}
+
 }//namespace asap

trunk/src/Scantable.h

@@ -217 +217 @@
   int ncycle(int scanno=-1) const;
 
-  double getInterval(int scanno=0) const;
-
-  float getTsys(int scanno=0) const;
-
-  std::vector<bool> getMask(int whichrow=0) const;
-  std::vector<float> getSpectrum(int whichrow=0) const;
+  int getBeam(int whichrow) const;
+  int getIF(int whichrow) const;
+  int getPol(int whichrow) const;
+
+  double getInterval(int whichrow) const
+    { return integrCol_(whichrow); }
+
+  float getTsys(int whichrow) const;
+  float getElevation(int whichrow) const
+    { return elCol_(whichrow); }
+  float getAzimuth(int whichrow) const
+    { return azCol_(whichrow); }
+  float getParangle(int whichrow) const
+    { return paraCol_(whichrow); }
+
+  std::vector<bool> getMask(int whichrow) const;
+  std::vector<float> getSpectrum(int whichrow) const;
 
   std::vector<float> getStokesSpectrum( int whichrow=0,
@@ -245 +256 @@
   std::string getTime(int whichrow=-1, bool showdate=true) const;
 
+  // returns unit, conversion frame, doppler, base-frame
+
+  /**
+   * Get the frequency set up
+   * This is forwarded to the STFrequencies subtable
+   * @return unit, frame, doppler
+   */
+  std::vector<std::string> getCoordInfo() const
+    { return freqTable_.getInfo(); };
+
+  void setCoordInfo(std::vector<string> theinfo)
+    { return freqTable_.setInfo(theinfo); };
+
+  std::string getAbcissaLabel(int whichrow) const;
+  std::vector<double> getRestFrequencies() const
+    { return moleculeTable_.getRestFrequencies(); }
+
+  void setRestFrequencies(double rf, const std::string& = "Hz");
+  void setRestFrequencies(const std::string& name);
 
   STFrequencies& frequencies() { return freqTable_; }
@@ -316 +346 @@
 
   // Cached Columns to avoid reconstructing them for each row get/put
-  casa::ScalarColumn<casa::Double> timeCol_, integrCol_;
+  casa::ScalarColumn<casa::Double> integrCol_;
   casa::MDirection::ScalarColumn dirCol_;
+  casa::MEpoch::ScalarColumn timeCol_;
   casa::ScalarColumn<casa::Double> azCol_;
   casa::ScalarColumn<casa::Double> elCol_;
   casa::ScalarColumn<casa::Float> paraCol_;
   casa::ScalarColumn<casa::String> srcnCol_, fldnCol_;
-  casa::ScalarColumn<casa::uInt> scanCol_, beamCol_, cycleCol_;
+  casa::ScalarColumn<casa::uInt> scanCol_, beamCol_, ifCol_, polCol_, cycleCol_;
   casa::ScalarColumn<casa::Int> rbeamCol_;
   casa::ArrayColumn<casa::Float> specCol_, tsCol_;