Changeset 1514

Timestamp:

02/23/09 20:55:35 (15 years ago)

Author:

Kana Sugimoto

Message:

New Development: No

JIRA Issue: Yes (CAS-1079)

Ready to Release: Yes

Interface Changes: Yes

What Interface Changed:
Added the new functions to get min/max position (channel) of spectra.

1. std::vector<int> asap::python::stmath::_minmaxpos(ScantableWrapper?& in,

std::vector<bool>& mask, std::string& which)

@python_STMath.cpp

2. std::vector<int> STMathWrapper::minMaxPos(ScantableWrapper?& in,

std::vector<bool>& mask, std::string& which)

@STMathWrapper.h

3. std::vector<int> STMath::minMaxPos(CountedPtr?< Scantable > & in,

std::vector< bool > & mask, std::string& which)

@STMath.h & .cpp

4. IPosition mathutil::minMaxPos(String& which, MaskedArray?<Float>& data) @MathUtils?.h & .cpp

Test Programs:

Run scantable.stats() with the parameter stat='minpos' or 'maxpos',
and you'll get min/max value with its psition.

Put in Release Notes: No

Module(s): scantable.stats()

Description:

These modifications are to return min/max value with its
position (channel/frequency/velocity) by running scantable.stats().

Diagram:
scantable.stats() ->asap::python::stmath::_minmaxpos
-> STMathWrapper::minMaxPos -> STMath::minMaxPos() -> mathutil::minMaxPos()
-> casa::minMax (@casacore/casa/casa/Arrays/MaskArrMath.tcc)

Location:

branches/alma/src

Files:

• MathUtils.cpp (modified) (1 diff)
• MathUtils.h (modified) (2 diffs)
• STMath.cpp (modified) (1 diff)
• STMath.h (modified) (1 diff)
• STMathWrapper.h (modified) (1 diff)
• python_STMath.cpp (modified) (1 diff)

branches/alma/src/MathUtils.cpp

@@ -76 +76 @@
 }
 
+IPosition mathutil::minMaxPos(const String& which,
+                           const MaskedArray<Float>& data)
+{
+   Float minVal, maxVal;
+   IPosition minPos(data.ndim(), 0), maxPos(data.ndim(), 0); 
+   minMax(minVal, maxVal, minPos, maxPos, data);
+   String str(which);
+   str.upcase();
+   if (str.matches(String("MINPOS"))) {
+     return minPos;
+   } else if (str.matches(String("MAXPOS"))) {
+     return maxPos;
+   } else {
+      String msg = str + " is not a valid type of statistics";
+      throw(AipsError(msg));
+   } 
+   //return 0.0;
+}
 
 void mathutil::replaceMaskByZero(Vector<Float>& data, const Vector<Bool>& mask)

branches/alma/src/MathUtils.h

@@ -37 +37 @@
 #include <casa/Arrays/Vector.h>
 #include <casa/BasicSL/String.h>
+#include <casa/Arrays/IPosition.h>
 
 namespace mathutil {
@@ -77 +78 @@
                  const casa::MaskedArray<casa::Float>& data);
 
+// Return a position of min or max value
+ casa::IPosition minMaxPos(const casa::String& which,
+                 const casa::MaskedArray<casa::Float>& data);
+
 // Replace masked value by zero
 void replaceMaskByZero(casa::Vector<casa::Float>& data,

branches/alma/src/STMath.cpp

@@ -1093 +1093 @@
     }
     out.push_back(outstat);
+  }
+  return out;
+}
+
+std::vector< int > STMath::minMaxPos( const CountedPtr< Scantable > & in,
+                                        const std::vector< bool > & mask,
+                                        const std::string& which )
+{
+
+  Vector<Bool> m(mask);
+  const Table& tab = in->table();
+  ROArrayColumn<Float> specCol(tab, "SPECTRA");
+  ROArrayColumn<uChar> flagCol(tab, "FLAGTRA");
+  std::vector<int> out;
+  for (uInt i=0; i < tab.nrow(); ++i ) {
+    Vector<Float> spec; specCol.get(i, spec);
+    Vector<uChar> flag; flagCol.get(i, flag);
+    MaskedArray<Float> ma  = maskedArray(spec, flag);
+    if (ma.ndim() != 1) {
+      throw (ArrayError(
+          "std::vector<int> STMath::minMaxPos("
+          "ContedPtr<Scantable> &in, std::vector<bool> &mask, "
+          " std::string &which)"
+          " - MaskedArray is not 1D"));
+    }
+    IPosition outpos(1,0);
+    if ( spec.nelements() == m.nelements() ) {
+      outpos = mathutil::minMaxPos(which, ma(m));
+    } else {
+      outpos = mathutil::minMaxPos(which, ma);
+    }
+    out.push_back(outpos[0]);
   }
   return out;

branches/alma/src/STMath.h

@@ -207 +207 @@
                                const std::string& which);
 
+  std::vector< int > minMaxPos(const casa::CountedPtr<Scantable>& in,
+                               const std::vector<bool>& mask,
+                               const std::string& which);
+
   casa::CountedPtr<Scantable> bin( const casa::CountedPtr<Scantable>& in,
                                    int width=5);

branches/alma/src/STMathWrapper.h

@@ -121 +121 @@
   { return STMath::statistic(in.getCP(), mask, which); }
 
+  std::vector<int> minMaxPos(const ScantableWrapper& in,
+                               const std::vector<bool>& mask,
+                               const std::string& which)
+  { return STMath::minMaxPos(in.getCP(), mask, which); }
+
   ScantableWrapper bin( const ScantableWrapper& in, int width=5)
   { return ScantableWrapper(STMath::bin(in.getCP(), width)); }

branches/alma/src/python_STMath.cpp

@@ -57 +57 @@
         .def("_dofs", &STMathWrapper::dofs)
         .def("_stats", &STMathWrapper::statistic)
+        .def("_minmaxpos", &STMathWrapper::minMaxPos)
         .def("_freqswitch", &STMathWrapper::freqSwitch)
         .def("_bin", &STMathWrapper::bin)