Changeset 1924 for branches/polybatch/src

Timestamp:

09/14/10 12:17:16 (14 years ago)

Author:

Malte Marquarding

Message:

Ticket #206: use STFitEntry as return objetc instead of pointer wrnagling.

Location:

branches/polybatch/src

Files:

• STFit.cpp (modified) (4 diffs)
• STFit.h (modified) (1 diff)
• STFitEntry.cpp (modified) (2 diffs)
• STFitEntry.h (modified) (2 diffs)
• STFitter.cpp (modified) (2 diffs)
• STFitter.h (modified) (3 diffs)
• Scantable.cpp (modified) (1 diff)
• Scantable.h (modified) (2 diffs)
• ScantableWrapper.h (modified) (2 diffs)
• python_STFitEntry.cpp (modified) (2 diffs)

branches/polybatch/src/STFit.cpp

@@ -70 +70 @@
   table_.addColumn(ArrayColumnDesc<Int>("COMPONENTS"));
   table_.addColumn(ArrayColumnDesc<Double>("PARAMETERS"));
+  //  table_.addColumn(ArrayColumnDesc<Double>("ERRORS"));
   table_.addColumn(ArrayColumnDesc<Bool>("PARMASKS"));
   table_.addColumn(ArrayColumnDesc<String>("FRAMEINFO"));
@@ -77 +78 @@
   compCol_.attach(table_,"COMPONENTS");
   parCol_.attach(table_,"PARAMETERS");
+  //  errCol_.attach(table_,"ERRORS");
   maskCol_.attach(table_,"PARMASKS");
   frameCol_.attach(table_,"FRAMEINFO");
@@ -102 +104 @@
   // add new row if new id
   if ( !foundentry ) table_.addRow();
+
   funcCol_.put(rno, mathutil::toVectorString(fit.getFunctions()));
   compCol_.put(rno, Vector<Int>(fit.getComponents()));
-  parCol_.put(rno, Vector<Double>(fit.getParameters()));
+  const std::vector<float>& pvec = fit.getParameters();
+  Vector<Double> dvec(pvec.size());
+  for (size_t i=0; i < dvec.nelements(); ++i) {
+    dvec[i] = Double(pvec[i]);
+  }
+  parCol_.put(rno, dvec);
+  /*
+  const std::vector<double>& evec = fit.getErrors();
+  for (size_t i=0; i < dvec.nelements(); ++i) {
+    dvec[i] = Double(evec[i]);
+  }
+  errCol_.put(rno, dvec);
+  */
   maskCol_.put(rno, Vector<Bool>(fit.getParmasks()));
   frameCol_.put(rno, mathutil::toVectorString(fit.getFrameinfo()));
   idCol_.put(rno, resultid);
+
   return resultid;
 }
@@ -130 +146 @@
   fit.setComponents(istl);
   Vector<Double> dvec;
-  std::vector<double> dstl;
   rec.get("PARAMETERS", dvec);
+  std::vector<float> dstl(dvec.begin(), dvec.end());
+  fit.setParameters(dstl);
+  /*
   dvec.tovector(dstl);
   fit.setParameters(dstl);
+  dvec.resize();
+  rec.get("ERRORS", dvec);
+  dvec.tovector(dstl);
+  fit.setErrors(dstl);
+  */
   Vector<Bool> bvec;
   std::vector<bool> bstl;

branches/polybatch/src/STFit.h

@@ -49 +49 @@
   casa::ArrayColumn<casa::Int> compCol_;
   casa::ArrayColumn<casa::Double> parCol_;
+  //  casa::ArrayColumn<casa::Double> errCol_;
   casa::ArrayColumn<casa::Bool> maskCol_;
   casa::ArrayColumn<casa::String> frameCol_;

branches/polybatch/src/STFitEntry.cpp

@@ -11 +11 @@
 //
 #include "STFitEntry.h"
+#include <casa/iostream.h>
 
+using namespace casa;
 namespace asap {
 
-STFitEntry::STFitEntry()
+  STFitEntry::STFitEntry()
+  /* : 
+    functions_( std::vector<std::string>()),
+    components_(std::vector<int>()),
+    parameters_(std::vector<float>()),
+    errors_(std::vector<float>()),
+    parmasks_(std::vector<bool>()),
+    frameinfo_(std::vector<std::string>())
+  */
 {
 }
@@ -20 +30 @@
 {
   if ( this != &other ) {
-    this->functions_ = other.functions_;
+    this->functions_ = std::vector<std::string>();
     this->components_ = other.components_;
     this->parameters_ = other.parameters_;
-    this->parmasks_ = other.parmasks_;
+    this->errors_ = other.errors_;
     this->frameinfo_ = other.frameinfo_;
   }
 }
 
+STFitEntry& STFitEntry::operator=(const STFitEntry& other)
+{
+  if ( this != &other ) {
+    this->functions_ = other.functions_;
+    this->components_ = other.components_;
+    this->parameters_ = other.parameters_;
+    this->errors_ = other.errors_;
+    this->parmasks_ = other.parmasks_;
+    this->frameinfo_ = other.frameinfo_;
+  }
+  return *this;
+}
 
 STFitEntry::~STFitEntry()

branches/polybatch/src/STFitEntry.h

@@ -28 +28 @@
   STFitEntry(const STFitEntry& other);
 
+  STFitEntry& operator=(const STFitEntry& other);
+
   ~STFitEntry();
 
@@ -34 +36 @@
   void setComponents(const std::vector<int>& c)
     { components_ = c; }
-  void setParameters(const std::vector<double>& p)
+  void setParameters(const std::vector<float>& p)
     { parameters_ = p; }
+  void setErrors(const std::vector<float>& p)
+    { errors_ = p; }
   void setParmasks(const std::vector<bool>& m)
     { parmasks_ = m; }
   void setFrameinfo(const std::vector<std::string>& f)
     { frameinfo_ = f; }
-
   std::vector<std::string> getFunctions() const { return functions_; }
   std::vector<int> getComponents() const { return components_; }
-  std::vector<double> getParameters() const { return parameters_; }
+  std::vector<float> getParameters() const { return parameters_; }
+  std::vector<float> getErrors() const { return errors_; }
   std::vector<bool> getParmasks() const { return parmasks_; }
   std::vector<std::string> getFrameinfo() const { return frameinfo_; }
 
 private:
+
   std::vector<std::string> functions_;
   std::vector<int> components_;
-  std::vector<double> parameters_;
+  std::vector<float> parameters_;
+  std::vector<float> errors_;
   std::vector<bool> parmasks_;
   std::vector<std::string> frameinfo_;

branches/polybatch/src/STFitter.cpp

@@ -142 +142 @@
     if (ncomp < 1) throw (AipsError("Need at least one gaussian to fit."));
     funcs_.resize(ncomp);
+    funcnames_.clear();
+    funccomponents_.clear();
     for (Int k=0; k<ncomp; ++k) {
       funcs_[k] = new Gaussian1D<Float>();
+      funcnames_.push_back(expr);
+      funccomponents_.push_back(3);
     }
   } else if (expr == "poly") {
     funcs_.resize(1);
+    funcnames_.clear();
+    funccomponents_.clear();
     funcs_[0] = new Polynomial<Float>(ncomp);
+      funcnames_.push_back(expr);
+      funccomponents_.push_back(ncomp);
   } else if (expr == "lorentz") {
     if (ncomp < 1) throw (AipsError("Need at least one lorentzian to fit."));
     funcs_.resize(ncomp);
+    funcnames_.clear();
+    funccomponents_.clear();
     for (Int k=0; k<ncomp; ++k) {
       funcs_[k] = new Lorentzian1D<Float>();
+      funcnames_.push_back(expr);
+      funccomponents_.push_back(3);
     }
   } else {
@@ -409 +421 @@
 }
 
+STFitEntry Fitter::getFitEntry() const
+{
+  STFitEntry fit;
+  fit.setParameters(getParameters());
+  fit.setErrors(getErrors());
+  fit.setComponents(funccomponents_);
+  fit.setFunctions(funcnames_);
+  fit.setParmasks(getFixedParameters());
+  return fit;
+}

branches/polybatch/src/STFitter.h

@@ -40 +40 @@
 #include <scimath/Functionals/CompoundFunction.h>
 
+#include "STFitEntry.h"
+
 namespace asap {
 
@@ -69 +71 @@
 
   std::vector<float> evaluate(int whichComp) const;
+
+  STFitEntry getFitEntry() const;
+
 private:
   void clear();
@@ -75 +80 @@
   casa::Vector<casa::Bool> m_;
   casa::PtrBlock<casa::Function<casa::Float>* > funcs_;
+  std::vector<std::string> funcnames_;
+  std::vector<int> funccomponents_;
+  
   //Bool estimateSet_;
   casa::Float chisquared_;

branches/polybatch/src/Scantable.cpp

@@ -1750 +1750 @@
 }
 
-void Scantable::polyBaselineBatch(const std::vector<bool>& mask, int order, int rowno)
+void Scantable::polyBaselineBatch(const std::vector<bool>& mask, int order)
+{
+  Fitter fitter = Fitter();
+  for (uInt rowno=0; rowno < nrow(); ++rowno) {
+    doPolyBaseline(mask, order, rowno, fitter);
+    setSpectrum(fitter.getResidual(), rowno);
+  }
+}
+
+STFitEntry Scantable::polyBaseline(const std::vector<bool>& mask, int order, int rowno)
 {
   Fitter fitter = Fitter();
   doPolyBaseline(mask, order, rowno, fitter);
   setSpectrum(fitter.getResidual(), rowno);
-}
-
-void Scantable::polyBaseline(const std::vector<bool>& mask, int order, int rowno, long pars_ptr, long pars_size, long errs_ptr, long errs_size, long fmask_ptr, long fmask_size)
-{
-  Fitter fitter = Fitter();
-  doPolyBaseline(mask, order, rowno, fitter);
-  setSpectrum(fitter.getResidual(), rowno);
-
-  std::vector<float> pars = fitter.getParameters();
-  if (pars_size != pars.size()) {
-    throw(AipsError("wrong pars size"));
-  }
-  float *ppars = reinterpret_cast<float*>(pars_ptr);
-  for (int i = 0; i < pars_size; i++) {
-    ppars[i] = pars[i];
-  }
-
-  std::vector<float> errs = fitter.getErrors();
-  if (errs_size != errs.size()) {
-    throw(AipsError("wrong errors size"));
-  }
-  float *perrs = reinterpret_cast<float*>(errs_ptr);
-  for (int i = 0; i < errs_size; i++) {
-    perrs[i] = errs[i];
-  }
-
-  std::vector<bool> fmask = getMask(rowno);
-  if (fmask_size != fmask.size()) {
-    throw(AipsError("wrong fmask size"));
-  }
-  int *pfmask = reinterpret_cast<int*>(fmask_ptr);
-  for (int i = 0; i < fmask_size; i++) {
-    pfmask[i] = ((fmask[i] && mask[i]) ? 1 : 0);
-  }
+  return fitter.getFitEntry();
 }
 

branches/polybatch/src/Scantable.h

@@ -18 +18 @@
 // AIPS++
 #include <casa/aips.h>
+#include <casa/Containers/Record.h>
 #include <casa/Arrays/MaskedArray.h>
 #include <casa/BasicSL/String.h>
@@ -489 +490 @@
   bool getFlagtraFast(int whichrow);
 
-  void polyBaselineBatch(const std::vector<bool>& mask, int order, int rowno);
-  void polyBaseline(const std::vector<bool>& mask, int order, int rowno, long pars_ptr, long pars_size, long errs_ptr, long errs_size, long fmask_ptr, long fmask_size);
-
+  void polyBaselineBatch(const std::vector<bool>& mask, int order);
+  STFitEntry polyBaseline(const std::vector<bool>& mask, int order, int rowno);
 
 private:

branches/polybatch/src/ScantableWrapper.h

@@ -19 +19 @@
 #include "MathUtils.h"
 #include "STFit.h"
+#include "STFitEntry.h"
 #include "Scantable.h"
 #include "STCoordinate.h"
@@ -250 +251 @@
   { table_->reshapeSpectrum( nmin, nmax ); }
 
-  void polyBaseline(const std::vector<bool>& mask, int order, int rowno, long pars_ptr, long pars_size, long errs_ptr, long errs_size, long fmask_ptr, long fmask_size)
-  { table_->polyBaseline(mask, order, rowno, pars_ptr, pars_size, errs_ptr, errs_size, fmask_ptr, fmask_size); }
-
-  void polyBaselineBatch(const std::vector<bool>& mask, int order, int rowno)
-  { table_->polyBaselineBatch(mask, order, rowno); }
+  STFitEntry polyBaseline(const std::vector<bool>& mask, int order, int rowno)
+  { return table_->polyBaseline(mask, order, rowno); }
+
+  void polyBaselineBatch(const std::vector<bool>& mask, int order)
+  { table_->polyBaselineBatch(mask, order); }
 
   bool getFlagtraFast(int whichrow=0) const

branches/polybatch/src/python_STFitEntry.cpp

@@ -44 +44 @@
         .def("getfixedparameters", &STFitEntry::getParmasks)
         .def("getparameters", &STFitEntry::getParameters)
+        .def("geterrors", &STFitEntry::getErrors)
         .def("getfunctions", &STFitEntry::getFunctions)
         .def("getcomponents", &STFitEntry::getComponents)
@@ -49 +50 @@
         .def("setfixedparameters", &STFitEntry::setParmasks)
         .def("setparameters", &STFitEntry::setParameters)
+        .def("seterrors", &STFitEntry::setErrors)
         .def("setfunctions", &STFitEntry::setFunctions)
         .def("setcomponents", &STFitEntry::setComponents)