Changeset 1907 for trunk/src

Timestamp:

08/26/10 19:46:26 (14 years ago)

Author:

WataruKawasaki

Message:

New Development: No

JIRA Issue: Yes CAS-1937,CAS-2373

Ready to Release: Yes

Interface Changes: Yes

What Interface Changed: A new parameter 'batch' was added to

sd.scantable.poly_baseline(), while
'uselin' was removed.

Test Programs:

Put in Release Notes: Yes

Module(s): sdbaseline

Description: A faster version of sd.scantable.poly_baseline().

Location:

trunk/src

Files:

• STMath.cpp (modified) (1 diff)
• STMath.h (modified) (1 diff)
• STMathWrapper.h (modified) (1 diff)
• Scantable.cpp (modified) (1 diff)
• Scantable.h (modified) (4 diffs)
• ScantableWrapper.h (modified) (1 diff)
• python_STMath.cpp (modified) (1 diff)
• python_Scantable.cpp (modified) (1 diff)

trunk/src/STMath.cpp

@@ -1796 +1796 @@
     out.push_back(outstat);
   }
+  return out;
+}
+
+std::vector< float > STMath::statisticRow( const CountedPtr< Scantable > & in,
+                                        const std::vector< bool > & mask,
+                                        const std::string& which,
+                                        int row )
+{
+
+  Vector<Bool> m(mask);
+  const Table& tab = in->table();
+  ROArrayColumn<Float> specCol(tab, "SPECTRA");
+  ROArrayColumn<uChar> flagCol(tab, "FLAGTRA");
+  std::vector<float> out;
+
+  Vector<Float> spec; specCol.get(row, spec);
+  Vector<uChar> flag; flagCol.get(row, flag);
+  MaskedArray<Float> ma  = maskedArray(spec, flag);
+  float outstat = 0.0;
+  if ( spec.nelements() == m.nelements() ) {
+    outstat = mathutil::statistics(which, ma(m));
+  } else {
+    outstat = mathutil::statistics(which, ma);
+  }
+  out.push_back(outstat);
+
   return out;
 }

trunk/src/STMath.h

@@ -277 +277 @@
                                const std::vector<bool>& mask,
                                const std::string& which);
+
+  std::vector<float> statisticRow(const casa::CountedPtr<Scantable>& in,
+                               const std::vector<bool>& mask,
+                               const std::string& which,
+                               int row);
 
   std::vector< int > minMaxChan(const casa::CountedPtr<Scantable>& in,

trunk/src/STMathWrapper.h

@@ -132 +132 @@
   { return STMath::statistic(in.getCP(), mask, which); }
 
+  std::vector<float> statisticRow(const ScantableWrapper& in,
+                               const std::vector<bool>& mask,
+                               const std::string& which,
+                               int row)
+  { return STMath::statisticRow(in.getCP(), mask, which, row); }
+
   std::vector<int> minMaxChan(const ScantableWrapper& in,
                                const std::vector<bool>& mask,

trunk/src/Scantable.cpp

@@ -1712 +1712 @@
 }
 
+bool Scantable::getFlagtraFast(int whichrow)
+{
+  uChar flag;
+  Vector<uChar> flags;
+  flagsCol_.get(uInt(whichrow), flags);
+  for (int i = 0; i < flags.size(); i++) {
+    if (i==0) {
+      flag = flags[i];
+    }
+    else {
+      flag &= flags[i];
+    }
+    return ((flag >> 7) == 1);
+   }
+}
+
+void Scantable::doPolyBaseline(const std::vector<bool>& mask, int order, int rowno, Fitter& fitter)
+{
+  fitter.setExpression("poly", order);
+
+  std::vector<double> abcsd = getAbcissa(rowno);
+  std::vector<float> abcs;
+  for (int i = 0; i < abcsd.size(); i++) {
+    abcs.push_back((float)abcsd[i]);
+  }
+  std::vector<float> spec = getSpectrum(rowno);
+  std::vector<bool> fmask = getMask(rowno);
+  for (int i = 0; i < fmask.size(); i++) {
+    fmask[i] = fmask[i] && mask[i];
+  }
+  fitter.setData(abcs, spec, fmask);
+
+  fitter.lfit();
+}
+
+void 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, int pars_ptr, int pars_size, int errs_ptr, int errs_size, int fmask_ptr, int 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];
+  }
+
+  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] ? 1 : 0);
+  }
+}
+
 }
 //namespace asap

trunk/src/Scantable.h

@@ -47 +47 @@
 #include "STFit.h"
 #include "STFitEntry.h"
+#include "STFitter.h"
 
 namespace asap {
@@ -486 +487 @@
   void regridChannel( int nchan, double dnu, int irow ) ;
 
+  bool getFlagtraFast(int whichrow);
+
+  void polyBaseline(const std::vector<bool>& mask, int order, int rowno);
+  void polyBaseline(const std::vector<bool>& mask, int order, int rowno, int pars_ptr, int pars_size, int errs_ptr, int errs_size, int fmask_ptr, int fmask_size);
+
 
 private:
@@ -506 +512 @@
    */
   std::string formatDirection(const casa::MDirection& md) const;
-
 
   /**
@@ -598 +603 @@
                                                       const casa::String&,
                                                       const casa::Array<T2>&);
+
+  void doPolyBaseline(const std::vector<bool>& mask, int order, int rowno, Fitter& fitter);
 };
 

trunk/src/ScantableWrapper.h

@@ -250 +250 @@
   { table_->reshapeSpectrum( nmin, nmax ); }
 
+  void polyBaseline(const std::vector<bool>& mask, int order, int rowno, int pars_ptr, int pars_size, int errs_ptr, int errs_size, int fmask_ptr, int fmask_size)
+  { table_->polyBaseline(mask, order, rowno, pars_ptr, pars_size, errs_ptr, errs_size, fmask_ptr, fmask_size); }
+
+  void polyBaseline(const std::vector<bool>& mask, int order, int rowno)
+  { table_->polyBaseline(mask, order, rowno); }
+
+  bool getFlagtraFast(int whichrow=0) const
+    { return table_->getFlagtraFast(whichrow); }
+
+
 private:
   casa::CountedPtr<Scantable> table_;

trunk/src/python_STMath.cpp

@@ -59 +59 @@
         .def("_dofs", &STMathWrapper::dofs)
         .def("_stats", &STMathWrapper::statistic)
+        .def("_statsrow", &STMathWrapper::statisticRow)
         .def("_minmaxchan", &STMathWrapper::minMaxChan)
         .def("_freqswitch", &STMathWrapper::freqSwitch)

trunk/src/python_Scantable.cpp

@@ -139 +139 @@
          (boost::python::arg("nmin")=-1, 
           boost::python::arg("nmax")=-1) )
+    .def("_poly_baseline", &ScantableWrapper::polyBaseline)
+    .def("_getflagtrafast", &ScantableWrapper::getFlagtraFast,
+         (boost::python::arg("whichrow")=0) )
   ;
 };