Changeset 227

Timestamp:

01/19/05 19:31:46 (20 years ago)

Author:

kil064

Message:

add gain-elevation correction capability

Location:

trunk/src

Files:

• SDMath.cc (modified) (11 diffs)
• SDMath.h (modified) (6 diffs)
• SDMathWrapper.cc (modified) (2 diffs)
• python_SDMath.cc (modified) (1 diff)

trunk/src/SDMath.cc

@@ -49 +49 @@
 #include <scimath/Mathematics/VectorKernel.h>
 #include <scimath/Mathematics/Convolver.h>
+#include <scimath/Mathematics/InterpolateArray1D.h>
 
 #include <tables/Tables/Table.h>
 #include <tables/Tables/ScalarColumn.h>
 #include <tables/Tables/ArrayColumn.h>
+#include <tables/Tables/ReadAsciiTable.h>
 
 #include <lattices/Lattices/LatticeUtilities.h>
@@ -96 +98 @@
 CountedPtr<SDMemTable> SDMath::average(const Block<CountedPtr<SDMemTable> >& in,
                                        const Vector<Bool>& mask, Bool scanAv,
-                                       const std::string& weightStr)
+                                       const String& weightStr)
 //Bool alignVelocity)
 //
@@ -327 +329 @@
            oldScanID = scanID;
            outScanID += 1;               // Scan ID for next accumulation period
-
-}
+        }
 
 // Accumulate
@@ -948 +949 @@
 
 
+SDMemTable* SDMath::gainElevation (const SDMemTable& in, const String& fileName,
+                                   const String& methodStr, Bool doAll)
+{
+  SDHeader sh = in.getSDHeader();
+  SDMemTable* pTabOut = new SDMemTable(in, True);
+  const uInt nRow = in.nRow();
+
+// Get elevation column from data
+
+  const Table& tab = in.table();
+  ROScalarColumn<Float> elev(tab, "ELEVATION");
+
+// Read gain-elevation ascii file data into a Table.
+
+  Table geTable = readAsciiFile (fileName);
+  ROScalarColumn<Float> geElCol(geTable, "ELEVATION");
+  ROScalarColumn<Float> geFacCol(geTable, "FACTOR");
+  Vector<Float> xIn = geElCol.getColumn();
+  Vector<Float> yIn = geFacCol.getColumn();
+  Vector<Bool> maskIn(xIn.nelements(),True);
+
+// Get elevation vector from data
+
+  Vector<Float> xOut = elev.getColumn();
+  xOut *= Float(180 / C::pi);
+
+// Interpolate (and extrapolate) with desired method
+
+   Int method = 0;
+   convertInterpString(method, methodStr);
+//
+   Vector<Float> yOut;
+   Vector<Bool> maskOut;
+   InterpolateArray1D<Float,Float>::interpolate(yOut, maskOut, xOut, 
+                                                xIn, yIn, maskIn, method,
+                                                True, True);
+
+// For operations only on specified cursor location
+
+  IPosition start, end;
+  getCursorLocation(start, end, in);
+
+// Loop over rows and interpolate correction factor
+  
+  const uInt axis = asap::ChanAxis;
+  for (uInt i=0; i < in.nRow(); ++i) {
+
+// Get data
+
+    MaskedArray<Float> dataIn(in.rowAsMaskedArray(i));
+    Array<Float>& valuesIn = dataIn.getRWArray();              // writable reference
+    const Array<Bool>& maskIn = dataIn.getMask();  
+
+// Apply factor
+
+    if (doAll) {
+       VectorIterator<Float> itValues(valuesIn, asap::ChanAxis);
+       while (!itValues.pastEnd()) {
+          itValues.vector() *= yOut(i);                    // Writes back into dataIn
+//
+          itValues.next();
+       }
+    } else {
+       Array<Float> valuesIn2 = valuesIn(start,end);
+       valuesIn2 *= yOut(i);
+       valuesIn(start,end) = valuesIn2;
+    }
+
+// Write out
+
+    SDContainer sc = in.getSDContainer(i);
+    putDataInSDC(sc, valuesIn, maskIn);
+//
+    pTabOut->putSDContainer(sc);
+  }
+
+// Delete temporary gain/el Table
+
+  geTable.markForDelete();
+//  
+  return pTabOut;
+}
+
+
+
 // 'private' functions
 
@@ -956 +1042 @@
                      Int scanID, Double timeStamp,
                      Double interval, const String& sourceName,
-                     const Vector<uInt>& freqID)
+                     const Vector<uInt>& freqID) const
 {
 // Data and mask
@@ -980 +1066 @@
                         const Array<Float>& nPts,
                         WeightType wtType, Int axis,
-                        Int nAxesSub)
+                        Int nAxesSub) const
 {
    IPosition pos2(nAxesSub,0);
@@ -1017 +1103 @@
                         uInt iTab, uInt iRow, uInt axis, 
                         uInt nAxesSub, Bool useMask,
-                        WeightType wtType)
+                        WeightType wtType) const
 {
 
@@ -1085 +1171 @@
 
 void SDMath::getCursorLocation(IPosition& start, IPosition& end,
-                               const SDMemTable& in)
+                               const SDMemTable& in) const
 {
   const uInt nDim = 4;
@@ -1107 +1193 @@
 
 
-void SDMath::convertWeightString(WeightType& wtType, const std::string& weightStr)
+void SDMath::convertWeightString(WeightType& wtType, const String& weightStr) const
 {
   String tStr(weightStr);
@@ -1123 +1209 @@
 }
 
+void SDMath::convertInterpString(Int& type, const String& interp) const
+{
+  String tStr(interp);
+  tStr.upcase();
+  if (tStr.contains(String("NEAR"))) {
+     type = InterpolateArray1D<Float,Float>::nearestNeighbour;
+  } else if (tStr.contains(String("LIN"))) {
+     type = InterpolateArray1D<Float,Float>::linear;
+  } else if (tStr.contains(String("CUB"))) {
+     type = InterpolateArray1D<Float,Float>::cubic;
+  } else if (tStr.contains(String("SPL"))) {
+     type = InterpolateArray1D<Float,Float>::spline;
+  } else {
+    throw(AipsError("Unrecognized interpolation type"));
+  }
+}
+
 void SDMath::putDataInSDC(SDContainer& sc, const Array<Float>& data,
-                          const Array<Bool>& mask)
+                          const Array<Bool>& mask) const
 {
     sc.putSpectrum(data);
@@ -1132 +1235 @@
     sc.putFlags(outflags);
 }
+
+Table SDMath::readAsciiFile (const String& fileName) const
+{
+   String tableName("___asap_temp.tbl");
+   readAsciiTable (fileName, "", tableName);
+   Table tbl(tableName);
+   return tbl;
+}

trunk/src/SDMath.h

@@ -37 +37 @@
 #include <casa/Utilities/CountedPtr.h>
 
+class casa::Table;
+
 namespace asap {
 
@@ -64 +66 @@
    casa::CountedPtr<SDMemTable>  average(const casa::Block<casa::CountedPtr<SDMemTable> >& in,
                                          const casa::Vector<casa::Bool>& mask,
-                                         casa::Bool scanAverage, const std::string& weightStr);
+                                         casa::Bool scanAverage, const casa::String& weightStr);
 //                                         casa::Bool alignVelocity);
 
@@ -81 +83 @@
    SDMemTable* convertFlux (const SDMemTable& in, casa::Float area, 
                             casa::Float eta, casa::Bool doAll);
+
+// Gain-elevation correction
+   SDMemTable* gainElevation (const SDMemTable& in, const casa::String& fileName,
+                              const casa::String& method, casa::Bool doAll);
 
 // Simple mathematical operations.  what=0 (mul) or 1 (add)
@@ -104 +110 @@
                    const casa::Block<casa::CountedPtr<SDMemTable> >& in,
                    casa::uInt iTab, casa::uInt iRow, casa::uInt axis, casa::uInt nAxesSub,
-                   casa::Bool useMask, WeightType wtType);
+                   casa::Bool useMask, WeightType wtType) const;
 
 // Function to fill Scan Container when averaging in time
@@ -113 +119 @@
                 casa::Int scanID, casa::Double timeStamp,
                 casa::Double interval, const casa::String& sourceName,
-                const casa::Vector<casa::uInt>& freqID);
+                const casa::Vector<casa::uInt>& freqID) const;
 
 // Put the data and mask into the SDContainer
    void putDataInSDC (SDContainer& sc, const casa::Array<casa::Float>& data,
-                      const casa::Array<casa::Bool>& mask);
+                      const casa::Array<casa::Bool>& mask) const;
 
 // Function to normalize data when averaging in time
@@ -124 +130 @@
                   const casa::Array<casa::Float>& sumSq,
                   const casa::Array<casa::Float>& nPts,
-                  WeightType wtType, casa::Int axis, casa::Int nAxes);
+                  WeightType wtType, casa::Int axis, casa::Int nAxes) const;
 
 // Function to get the current cursor location
    void getCursorLocation (casa::IPosition& start, casa::IPosition& end,
-                           const SDMemTable& in);
+                           const SDMemTable& in) const;
 
 // Convert weight string to enum value
 
-   void convertWeightString (WeightType& wt, const std::string& weightStr);
+   void convertWeightString (WeightType& wt, const casa::String& weightStr) const;
+
+// Convert interpolation type string
+   void convertInterpString(casa::Int& type, const casa::String& interp) const;
+
+// Read ascii file
+
+   casa::Table readAsciiFile (const casa::String& fileName) const;
+                   
 };
 

trunk/src/SDMathWrapper.cc

@@ -162 +162 @@
 {
   SDMath sdm;
-  return sdm.statistic(in.getCP(), mask, which);
+  return sdm.statistic(in.getCP(), mask, String(which));
 }
 
@@ -185 +185 @@
 }
 
+
+void SDMathWrapper::gainElevationInSitu(SDMemTableWrapper& in, const string& fileName,
+                                        const string& method, bool doAll)
+{
+  SDMemTable* pIn = in.getPtr();
+  SDMath sdm;
+  SDMemTable* pOut = sdm.gainElevation(*pIn, String(fileName), String(method), Bool(doAll));
+  *pIn = *pOut;
+  delete pOut;
+}
+
+
+SDMemTableWrapper SDMathWrapper::gainElevation(const SDMemTableWrapper& in, 
+                                               const string& fileName, 
+                                               const string& method, bool doAll)
+{
+  const CountedPtr<SDMemTable>& pIn = in.getCP();
+  SDMath sdm;
+  return CountedPtr<SDMemTable>(sdm.gainElevation(*pIn, String(fileName), 
+                                                  String(method), Bool(doAll)));
+}
+

trunk/src/python_SDMath.cc

@@ -78 +78 @@
       def("convertflux_insitu", &SDMathWrapper::convertFluxInSitu);
 //
+      def("gainel", &SDMathWrapper::gainElevation);
+      def("gainel_insitu", &SDMathWrapper::gainElevationInSitu);
+//
       def("average", &SDMathWrapper::average);
 //