Changeset 716

Timestamp:

11/17/05 14:37:33 (19 years ago)

Author:

mar637

Message:

added frequency switching; implemented use of SDLog

Location:

trunk/src

Files:

• SDMath.cc (modified) (44 diffs)
• SDMath.h (modified) (7 diffs)
• SDMathWrapper.cc (modified) (25 diffs)
• SDMathWrapper.h (modified) (5 diffs)
• python_SDMath.cc (modified) (2 diffs)

trunk/src/SDMath.cc

@@ -31 +31 @@
 #include <vector>
 
+
 #include <casa/aips.h>
 #include <casa/iostream.h>
+#include <casa/sstream.h>
 #include <casa/iomanip.h>
 #include <casa/BasicSL/String.h>
@@ -89 +91 @@
 
 SDMath::SDMath()
-{;}
+{
+}
 
 SDMath::SDMath(const SDMath& other)
@@ -113 +116 @@
                                        const String& refTime, 
                                        const String& method, 
-                                       Bool perFreqID) const
+                                       Bool perFreqID)
 {
   // Get frame info from Table
@@ -136 +139 @@
 SDMath::average(const std::vector<CountedPtr<SDMemTable> >& in,
                 const Vector<Bool>& mask, Bool scanAv,
-                const String& weightStr, Bool alignFreq) const
+                const String& weightStr, Bool alignFreq)
 // Weighted averaging of spectra from one or more Tables.
 {
@@ -365 +368 @@
 SDMath::binaryOperate(const CountedPtr<SDMemTable>& left,
                       const CountedPtr<SDMemTable>& right,
-                      const String& op, Bool preserve, Bool doTSys) const
+                      const String& op, Bool preserve, Bool doTSys)
 {
 
@@ -509 +512 @@
   IPosition start, end;
   Bool doAll = False;
-  setCursorSlice (start, end, doAll, *in);
+  setCursorSlice(start, end, doAll, *in);
 
 // Loop over rows
@@ -554 +557 @@
 
 
-SDMemTable* SDMath::bin(const SDMemTable& in, Int width) const
+SDMemTable* SDMath::bin(const SDMemTable& in, Int width)
 {
   SDHeader sh = in.getSDHeader();
@@ -615 +618 @@
 
 SDMemTable* SDMath::resample(const SDMemTable& in, const String& methodStr,
-                             Float width) const
+                             Float width)
 //
 // Should add the possibility of width being specified in km/s. This means
@@ -729 +732 @@
 
 SDMemTable* SDMath::unaryOperate(const SDMemTable& in, Float val, Bool doAll,
-                                 uInt what, Bool doTSys) const
+                                 uInt what, Bool doTSys)
 //
 // what = 0   Multiply
@@ -776 +779 @@
 
 SDMemTable* SDMath::averagePol(const SDMemTable& in, const Vector<Bool>& mask,
-                               const String& weightStr) const
+                               const String& weightStr)
 //
 // Average all polarizations together, weighted by variance
@@ -973 +976 @@
 SDMemTable* SDMath::smooth(const SDMemTable& in, 
                            const casa::String& kernelType,
-                           casa::Float width, Bool doAll) const
+                           casa::Float width, Bool doAll)
 //
 // Should smooth TSys as well
@@ -1047 +1050 @@
 
 SDMemTable* SDMath::convertFlux(const SDMemTable& in, Float D, Float etaAp, 
-                                Float JyPerK, Bool doAll) const
+                                Float JyPerK, Bool doAll)
 // 
 // etaAp = aperture efficiency (-1 means find)
@@ -1066 +1069 @@
   Bool toKelvin = True;
   Double cFac = 1.0;    
+
   if (fluxUnit==JY) {
-    cout << "Converting to K" << endl;
-    
+    pushLog("Converting to K");
     Quantum<Double> t(1.0,fluxUnit);
     Quantum<Double> t2 = t.get(JY);
@@ -1076 +1079 @@
     sh.fluxunit = "K";
   } else if (fluxUnit==K) {
-    cout << "Converting to Jy" << endl;
-    
+    pushLog("Converting to Jy");
     Quantum<Double> t(1.0,fluxUnit);
     Quantum<Double> t2 = t.get(K);
@@ -1087 +1089 @@
     throw(AipsError("Unrecognized brightness units in Table - must be consistent with Jy or K"));
   }
+
   pTabOut->putSDHeader(sh);
   
@@ -1096 +1099 @@
     factor *= JyPerK;
     if (toKelvin) factor = 1.0 / JyPerK;
-    cout << "Jy/K = " << JyPerK << endl;
+    ostringstream oss;
+    oss << "Jy/K = " << JyPerK;
+    pushLog(String(oss));
     Vector<Float> factors(in.nRow(), factor);
     scaleByVector(pTabOut, in, doAll, factors, False);
   } else if (etaAp>0.0) {
     Bool throwIt = True;
-    Instrument inst = SDAttr::convertInstrument (sh.antennaname, throwIt);
+    Instrument inst = SDAttr::convertInstrument(sh.antennaname, throwIt);
     SDAttr sda;
     if (D < 0) D = sda.diameter(inst);
-    Float JyPerK = SDAttr::findJyPerK (etaAp,D);
-    cout << "Jy/K = " << JyPerK << endl;
+    Float JyPerK = SDAttr::findJyPerK(etaAp,D);
+    ostringstream oss;
+    oss << "Jy/K = " << JyPerK;
+    pushLog(String(oss));
     factor *= JyPerK;
     if (toKelvin) {
@@ -1120 +1127 @@
     // change per integration.
     
-    cout << "Looking up conversion factors" << endl;
+    pushLog("Looking up conversion factors");
     convertBrightnessUnits (pTabOut, in, toKelvin, cFac, doAll);
   }
-
   return pTabOut;
 }
@@ -1131 +1137 @@
                                   const Vector<Float>& coeffs,
                                   const String& fileName,
-                                  const String& methodStr, Bool doAll) const
+                                  const String& methodStr, Bool doAll)
 {
 
@@ -1176 +1182 @@
        throw(AipsError("There is no known gain-elevation polynomial known for this instrument"));
      }
-     cout << "Making polynomial correction with " << msg << " coefficients" << endl;
+     pushLog("Making polynomial correction with "+msg+" coefficients");
      const uInt nRow = in.nRow();
      Vector<Float> factor(nRow);
@@ -1193 +1199 @@
     // Read and correct
     
-    cout << "Making correction from ascii Table" << endl;
+    pushLog("Making correction from ascii Table");
     scaleFromAsciiTable (pTabOut, in, fileName, col0, col1, 
                          methodStr, doAll, x, True);
@@ -1202 +1208 @@
  
 
-SDMemTable* SDMath::opacity(const SDMemTable& in, Float tau, Bool doAll) const
+SDMemTable* SDMath::opacity(const SDMemTable& in, Float tau, Bool doAll)
 {
 
@@ -1245 +1251 @@
 
    SDHeader sh = in.getSDHeader();
-   Instrument inst = SDAttr::convertInstrument (sh.antennaname, False);
+   Instrument inst = SDAttr::convertInstrument(sh.antennaname, False);
    SDAttr sdAtt;
    if (sdAtt.feedPolType(inst) != LINEAR) {
@@ -1299 +1305 @@
 //
    SDHeader sh = in.getSDHeader();
-   Instrument inst = SDAttr::convertInstrument (sh.antennaname, False);
+   Instrument inst = SDAttr::convertInstrument(sh.antennaname, False);
    SDAttr sdAtt;
    if (sdAtt.feedPolType(inst) != LINEAR) {
@@ -1378 +1384 @@
 
 void SDMath::convertBrightnessUnits (SDMemTable* pTabOut, const SDMemTable& in, 
-                                     Bool toKelvin, Float cFac, Bool doAll) const
+                                     Bool toKelvin, Float cFac, Bool doAll)
 {
 
@@ -1389 +1395 @@
 
    Bool throwIt = True;
-   Instrument inst = SDAttr::convertInstrument (sh.antennaname, throwIt);
+   Instrument inst = SDAttr::convertInstrument(sh.antennaname, throwIt);
 
 // Get Diameter (m)
 
    SDAttr sdAtt;
-
 // Get epoch of first row
 
@@ -1410 +1415 @@
 //
    Vector<Float> JyPerK = sdAtt.JyPerK(inst, dateObs, freqs);
-   cout << "Jy/K = " << JyPerK << endl;
+   ostringstream oss;
+   oss << "Jy/K = " << JyPerK;
+   pushLog(String(oss));
    Vector<Float> factors = cFac * JyPerK;
    if (toKelvin) factors = Float(1.0) / factors;
@@ -1474 +1481 @@
                                    const String& refTime, 
                                    const String& methodStr,
-                                   Bool perFreqID) const
+                                   Bool perFreqID)
 {
 // Get Header
@@ -1511 +1518 @@
      refEpoch = in.getEpoch(0);
    }
-   cout << "Aligning at reference Epoch " << formatEpoch(refEpoch) 
-        << " in frame " << MFrequency::showType(freqSystem) << endl;
+   pushLog("Aligning at reference Epoch "+formatEpoch(refEpoch) 
+                  +" in frame "+MFrequency::showType(freqSystem));
    
    // Get Reference Position
@@ -1561 +1568 @@
    // New output Table
    
-   cout << "Create output table" << endl;
+   pushLog("Create output table");
    SDMemTable* pTabOut = new SDMemTable(in,True);
    pTabOut->putSDFreqTable(freqTabOut);
@@ -1580 +1587 @@
    for (uInt iRow=0; iRow<nRows; ++iRow) {
      if (iRow%10==0) {
-       cout << "Processing row " << iRow << endl;
+       pushLog("Processing row "+iRow);
      }
      
@@ -1688 +1695 @@
 
 
-SDMemTable* SDMath::frequencySwitch(const SDMemTable& in) const
+SDMemTable* SDMath::frequencySwitch(const SDMemTable& in)
 {
   if (in.nIF() != 2) {
@@ -1748 +1755 @@
                      Int scanID, Double timeStamp,
                      Double interval, const String& sourceName,
-                     const Vector<uInt>& freqID) const
+                     const Vector<uInt>& freqID)
 {
 // Data and mask
@@ -1777 +1784 @@
                         uInt iTab, uInt iRow, uInt axis, 
                         uInt nAxesSub, Bool useMask,
-                        WeightType wtType) const
+                        WeightType wtType)
 {
 
@@ -1886 +1893 @@
                        Double intSum,
                        WeightType wtType, Int axis,
-                       Int nAxesSub) const
+                       Int nAxesSub)
 {
    IPosition pos2(nAxesSub,0);
@@ -1964 +1971 @@
 
 void SDMath::convertWeightString(WeightType& wtType, const String& weightStr,
-                                 Bool listType) const
+                                 Bool listType)
 {
   String tStr(weightStr);
@@ -1989 +1996 @@
   }
 //
-  if (listType) cout << msg << endl;
+  if (listType) pushLog(msg);
 }
 
 
 void SDMath::convertInterpString(casa::InterpolateArray1D<Double,Float>::InterpolationMethod& type,  
-                                 const casa::String& interp) const
+                                 const casa::String& interp)
 {
   String tStr(interp);
@@ -2012 +2019 @@
 
 void SDMath::putDataInSDC(SDContainer& sc, const Array<Float>& data,
-                          const Array<Bool>& mask) const
+                          const Array<Bool>& mask)
 {
     sc.putSpectrum(data);
@@ -2021 +2028 @@
 }
 
-Table SDMath::readAsciiFile (const String& fileName) const
+Table SDMath::readAsciiFile(const String& fileName) const
 {
    String formatString;
@@ -2034 +2041 @@
                                  const String& col0, const String& col1,
                                  const String& methodStr, Bool doAll,
-                                 const Vector<Float>& xOut, Bool doTSys) const
+                                 const Vector<Float>& xOut, Bool doTSys)
 {
 
@@ -2048 +2055 @@
                             const String& col1,
                             const String& methodStr, Bool doAll,
-                            const Vector<Float>& xOut, Bool doTsys) const
+                            const Vector<Float>& xOut, Bool doTsys)
 {
 
@@ -2078 +2085 @@
 void SDMath::scaleByVector(SDMemTable* pTabOut, const SDMemTable& in, 
                            Bool doAll, const Vector<Float>& factor,
-                           Bool doTSys) const
+                           Bool doTSys)
 {
 
@@ -2131 +2138 @@
                                     const ROScalarColumn<String>& srcCol,
                                     const ROArrayColumn<uInt>& fqIDCol,
-                                    Bool perFreqID) const
+                                    Bool perFreqID)
 {
    const uInt nRows = tabIn.nrow();
@@ -2165 +2172 @@
 
 
-MEpoch SDMath::epochFromString(const String& str, MEpoch::Types timeRef) const
+MEpoch SDMath::epochFromString(const String& str, MEpoch::Types timeRef)
 {
    Quantum<Double> qt;
@@ -2192 +2199 @@
                                        const MPosition& refPos,
                                        const MEpoch& refEpoch,
-                                       Bool perFreqID) const
+                                       Bool perFreqID)
 {
    for (uInt i=0; i<dDesc.length(); i++) {

trunk/src/SDMath.h

@@ -39 +39 @@
 
 #include "SDDefs.h"
+#include "SDLog.h"
 
 class casa::Table;
@@ -48 +49 @@
 template<class T> class casa::ROArrayColumn;
 
-
-
 namespace asap {
 
 class SDMemTable;
 class SDDataDesc;
-
-class SDMath {
-
- public:
-
-// Default constructor 
-   SDMath();
-
-// Copy Constructor (copy semantics)
-   SDMath (const SDMath& other);
-
-// Assignment  (copy semantics)
-   SDMath &operator=(const SDMath& other);
-
-// Destructor
-   ~SDMath();
-
-// Binary Table operators. op=ADD, SUB, MUL, DIV, QUOTIENT
-   casa::CountedPtr<SDMemTable> binaryOperate (const casa::CountedPtr<SDMemTable>& left,
-                                               const casa::CountedPtr<SDMemTable>& right,
-                                               const casa::String& op, casa::Bool preserve,
-                                               casa::Bool tSys) const;
-
-// Average in time
-   casa::CountedPtr<SDMemTable> 
-   average(const std::vector<casa::CountedPtr<SDMemTable> >& in,
-           const casa::Vector<casa::Bool>& mask,
-           casa::Bool scanAverage, 
-           const casa::String& weightStr,
-           casa::Bool align=casa::False) const;
-
-// Statistics. If row<0, all rows are done otherwise, just the 
-// specified row.
-   std::vector<float> statistic(const casa::CountedPtr<SDMemTable>& in, 
-                                const casa::Vector<casa::Bool>& mask, 
-                                const casa::String& which, casa::Int row) const;
-
+  
+class SDMath : private SDLog {
+
+public:
+  
+  // Default constructor 
+  SDMath();
+  
+  // Copy Constructor (copy semantics)
+  SDMath(const SDMath& other);
+  
+  // Assignment  (copy semantics)
+  SDMath &operator=(const SDMath& other);
+  
+  // Destructor
+  ~SDMath();
+  
+  // Binary Table operators. op=ADD, SUB, MUL, DIV, QUOTIENT
+  casa::CountedPtr<SDMemTable> binaryOperate(const casa::CountedPtr<SDMemTable>& left,
+                                             const casa::CountedPtr<SDMemTable>& right,
+                                             const casa::String& op, casa::Bool preserve,
+                                             casa::Bool tSys);
+    
+    // Average in time
+    casa::CountedPtr<SDMemTable> average(const std::vector<casa::CountedPtr<SDMemTable> >& in,
+                                         const casa::Vector<casa::Bool>& mask,
+                                         casa::Bool scanAverage, 
+                                         const casa::String& weightStr,
+                                         casa::Bool align=casa::False);
+    
+  // Statistics. If row<0, all rows are done otherwise, just the 
+  // specified row.
+  std::vector<float> statistic(const casa::CountedPtr<SDMemTable>& in, 
+                               const casa::Vector<casa::Bool>& mask, 
+                               const casa::String& which, casa::Int row) const;
+                               
 // Bin up spectra
-   SDMemTable* bin(const SDMemTable& in, casa::Int width) const;
-
-// Resample spectra
+   SDMemTable* bin(const SDMemTable& in, casa::Int width);
+
+  // Resample spectra
    SDMemTable* resample(const SDMemTable& in, const casa::String& method, 
-                        casa::Float factor) const;
+                        casa::Float factor);
 
 // Smooth
-   SDMemTable* smooth (const SDMemTable& in, const casa::String& kernel,
-                       casa::Float width, casa::Bool doAll) const;
+  SDMemTable* smooth(const SDMemTable& in, const casa::String& kernel,
+                      casa::Float width, casa::Bool doAll);
 
 // Flux conversion between Jansky and Kelvin
-   SDMemTable* convertFlux (const SDMemTable& in, casa::Float D, casa::Float etaAp, 
-                            casa::Float JyPerK, casa::Bool doAll) const;
+   SDMemTable* convertFlux(const SDMemTable& in, casa::Float D, 
+                           casa::Float etaAp, 
+                           casa::Float JyPerK, casa::Bool doAll);
 
 // Gain-elevation correction
-   SDMemTable* gainElevation (const SDMemTable& in, const casa::Vector<casa::Float>& coeffs,
-                              const casa::String& fileName,
-                              const casa::String& method, casa::Bool doAll) const;
+   SDMemTable* gainElevation(const SDMemTable& in, 
+                             const casa::Vector<casa::Float>& coeffs,
+                             const casa::String& fileName,
+                             const casa::String& method, 
+                             casa::Bool doAll);
 
 // Frequency Alignment
-   SDMemTable* frequencyAlignment (const SDMemTable& in, const casa::String& refTime,
-                                   const casa::String& method, casa::Bool perFreqID) const;
+   SDMemTable* frequencyAlignment(const SDMemTable& in, const casa::String& refTime,
+                                   const casa::String& method, casa::Bool perFreqID);
 
 // Opacity correction
-   SDMemTable* opacity (const SDMemTable& in, casa::Float tau, casa::Bool doAll) const;
+   SDMemTable* opacity(const SDMemTable& in, casa::Float tau, casa::Bool doAll);
 
 // Simple unary mathematical operations.  what=0 (mul) or 1 (add)
    SDMemTable* unaryOperate(const SDMemTable& in, casa::Float offset, 
-                            casa::Bool doAll, casa::uInt what, casa::Bool tSys) const;
-
-// Average polarizations.
-   SDMemTable* averagePol(const SDMemTable& in, const casa::Vector<casa::Bool>& mask,
-                          const casa::String& wtStr) const;
+                            casa::Bool doAll, casa::uInt what, casa::Bool tSys);
+
+  // Average polarizations.
+  SDMemTable* averagePol(const SDMemTable& in, 
+                         const casa::Vector<casa::Bool>& mask,
+                         const casa::String& wtStr);
+
+  SDMemTable* frequencySwitch(const SDMemTable& in);
+  
 
 // Rotate XY phase. Value in degrees.
-   void rotateXYPhase (SDMemTable& in, casa::Float value, casa::Bool doAll);
+   void rotateXYPhase(SDMemTable& in, casa::Float value, casa::Bool doAll);
 
 // Rotate Q & U by operating on the raw correlations.Value in degrees.
-   void rotateLinPolPhase (SDMemTable& in, casa::Float value, casa::Bool doAll);
-
-
+   void rotateLinPolPhase(SDMemTable& in, casa::Float value, casa::Bool doAll);
+
+  
  private:
 
@@ -155 +160 @@
                   casa::uInt iTab, casa::uInt iRow, 
                   casa::uInt axis, casa::uInt nAxesSub,
-                  casa::Bool useMask, WeightType wtType) const;
+                  casa::Bool useMask, WeightType wtType);
 
 // Work out conversion factor for converting Jy<->K per IF per row and apply
-   void convertBrightnessUnits (SDMemTable* pTabOut, const SDMemTable& in, 
-                                casa::Bool toKelvin, casa::Float sFac, casa::Bool doAll) const;
+    void convertBrightnessUnits(SDMemTable* pTabOut, const SDMemTable& in, 
+                                casa::Bool toKelvin, casa::Float sFac, casa::Bool doAll);
 
 // Convert weight string to enum value
 
-   void convertWeightString (WeightType& wt, const casa::String& weightStr,
-                             casa::Bool listType) const;
+   void convertWeightString(WeightType& wt, const casa::String& weightStr,
+                             casa::Bool listType);;
 
 // Convert interpolation type string
-//   void convertInterpString(casa::Int& type, const casa::String& interp) const;
+//   void convertInterpString(casa::Int& type, const casa::String& interp);
    void convertInterpString(casa::InterpolateArray1D<casa::Double,casa::Float>::InterpolationMethod& method,  
-                             const casa::String& interp) const;
+                             const casa::String& interp);
 
 // Scale data with values from an ascii Table
@@ -176 +181 @@
                               const casa::String& col0, const casa::String& col1,
                               const casa::String& methodStr, casa::Bool doAll,
-                              const casa::Vector<casa::Float>& xOut, casa::Bool doTSys) const;
+                              const casa::Vector<casa::Float>& xOut, casa::Bool doTSys);
 
 // Scale data with values from a Table
@@ -182 +187 @@
                          const casa::String& col0, const casa::String& col1,
                          const casa::String& methodStr, casa::Bool doAll,
-                         const casa::Vector<casa::Float>& xOut, casa::Bool doTSys) const;
+                         const casa::Vector<casa::Float>& xOut, casa::Bool doTSys);
 
 // Scale data and optionally TSys by values in a Vector
-   void scaleByVector (SDMemTable* pTabOut, const SDMemTable& in,
+   void scaleByVector(SDMemTable* pTabOut, const SDMemTable& in,
                        casa::Bool doAll, const casa::Vector<casa::Float>& factor,
-                       casa::Bool doTSys) const;
+                       casa::Bool doTSys);
 
 // Convert time String to Epoch
-   casa::MEpoch epochFromString (const casa::String& str, casa::MEpoch::Types timeRef) const;
+   casa::MEpoch epochFromString(const casa::String& str, casa::MEpoch::Types timeRef);
 
 // Function to fill Scan Container when averaging in time
 
-  void fillSDC (SDContainer& sc, const casa::Array<casa::Bool>& mask,
+  void fillSDC(SDContainer& sc, const casa::Array<casa::Bool>& mask,
                 const casa::Array<casa::Float>& data,
                 const casa::Array<casa::Float>& tSys,
                 casa::Int scanID, casa::Double timeStamp,
                 casa::Double interval, const casa::String& sourceName,
-                const casa::Vector<casa::uInt>& freqID) const;
+                const casa::Vector<casa::uInt>& freqID);
 
 // Format EPoch
-   casa::String formatEpoch(const casa::MEpoch& epoch)  const;
+   casa::String formatEpoch(const casa::MEpoch& epoch) const; 
 
 // Align in Frequency
-   SDMemTable* frequencyAlign (const SDMemTable& in,
+   SDMemTable* frequencyAlign(const SDMemTable& in,
                               casa::MFrequency::Types system,
                               const casa::String& timeRef,
                               const casa::String& method, 
-                               casa::Bool perIF) const;
+                               casa::Bool perIF);
 
 // Generate frequency aligners
-   void generateFrequencyAligners (casa::PtrBlock<casa::FrequencyAligner<casa::Float>* >& a,
+   void generateFrequencyAligners(casa::PtrBlock<casa::FrequencyAligner<casa::Float>* >& a,
                                    const SDDataDesc& dDesc,
                                    const SDMemTable& in, casa::uInt nChan,
@@ -218 +223 @@
                                    const casa::MPosition& refPos,
                                    const casa::MEpoch& refEpoch, 
-                                   casa::Bool perFreqID) const;
-
-// Generate data description table (combines source and freqID)
-   void generateDataDescTable (casa::Matrix<casa::uInt>& ddIdx,
+                                   casa::Bool perFreqID);
+
+// Generate data description table(combines source and freqID);
+   void generateDataDescTable(casa::Matrix<casa::uInt>& ddIdx,
                                SDDataDesc& dDesc,
                                casa::uInt nIF,
@@ -228 +233 @@
                                const casa::ROScalarColumn<casa::String>& srcCol,
                                const casa::ROArrayColumn<casa::uInt>& fqIDCol,
-                               casa::Bool perFreqID) const;
+                               casa::Bool perFreqID);
 
 // Get row range from SDMemTable state
-   casa::Vector<casa::uInt> getRowRange (const SDMemTable& in) const;
+  casa::Vector<casa::uInt> getRowRange(const SDMemTable& in) const;
 
 // Is row in the row range ?
-   casa::Bool rowInRange (casa::uInt i, const casa::Vector<casa::uInt>& range) const;
+  casa::Bool rowInRange(casa::uInt i, const casa::Vector<casa::uInt>& range) const;
 
 // Set slice to cursor or all axes
-    void setCursorSlice (casa::IPosition& start, casa::IPosition& end, 
-                         casa::Bool doAll, const SDMemTable& in) const;
+    void setCursorSlice(casa::IPosition& start, casa::IPosition& end, 
+                        casa::Bool doAll, const SDMemTable& in) const;
 
 // Function to normalize data when averaging in time
 
-  void normalize (casa::MaskedArray<casa::Float>& data,
+  void normalize(casa::MaskedArray<casa::Float>& data,
                   const casa::Array<casa::Float>& sumSq,
                   const casa::Array<casa::Float>& tSysSumSq,
                   const casa::Array<casa::Float>& nPts,
                   casa::Double intSum,
-                  WeightType wtType, casa::Int axis, casa::Int nAxes) const;
+                 WeightType wtType, casa::Int axis, casa::Int nAxes);
 
 // 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;
+   void putDataInSDC(SDContainer& sc, const casa::Array<casa::Float>& data,
+                     const casa::Array<casa::Bool>& mask);
 
 // Read ascii file into a Table
 
-   casa::Table readAsciiFile (const casa::String& fileName) const;
-};
-
-
-
+  casa::Table readAsciiFile(const casa::String& fileName) const;
+
+}; // class
 
 } // namespace

trunk/src/SDMathWrapper.cc

@@ -30 +30 @@
 //#---------------------------------------------------------------------------
 
-
 #include "SDMathWrapper.h"
-#include "SDMath.h"
-
 
 using namespace asap;
 using namespace casa;
+
 
 SDMemTableWrapper SDMathWrapper::quotient(const SDMemTableWrapper& on,
@@ -42 +40 @@
                                           Bool preserveContinuum)
 {
-    SDMath sdm;
+    
     Bool doTSys = True;
-    return SDMemTableWrapper(sdm.binaryOperate(on.getCP(), off.getCP(), 
-                             String("QUOTIENT"), preserveContinuum, doTSys));
+    return SDMemTableWrapper(sdmath.binaryOperate(on.getCP(), off.getCP(), 
+                                                  String("QUOTIENT"), 
+                                                  preserveContinuum, doTSys));
 }
 
@@ -51 +50 @@
 SDMemTableWrapper SDMathWrapper::binaryOperate(const SDMemTableWrapper& left,
                                                const SDMemTableWrapper& right,
-                                               const std::string& op, bool doTSys)
-{
-    SDMath sdm;
-    return SDMemTableWrapper(sdm.binaryOperate(left.getCP(), right.getCP(), 
-                                               String(op), False, Bool(doTSys)));
-}
-
-
-void SDMathWrapper::scaleInSitu(SDMemTableWrapper& in, float factor, bool doAll, bool doTSys)
+                                               const std::string& op, 
+                                               bool doTSys)
+{
+    
+    return SDMemTableWrapper(sdmath.binaryOperate(left.getCP(), right.getCP(), 
+                                                  String(op), False, 
+                                                  Bool(doTSys)));
+}
+
+
+void SDMathWrapper::scaleInSitu(SDMemTableWrapper& in, float factor, 
+                                bool doAll, bool doTSys)
 {
   SDMemTable* pIn = in.getPtr();
   const uInt what = 0;
-//
-  SDMath sdm;
-  SDMemTable* pOut = sdm.unaryOperate (*pIn, Float(factor), 
+  
+  SDMemTable* pOut = sdmath.unaryOperate (*pIn, Float(factor), 
                                         Bool(doAll), what, Bool(doTSys));
   *pIn = *pOut;
@@ -76 +77 @@
   const CountedPtr<SDMemTable>& pIn = in.getCP();
   const uInt what = 0;
-  SDMath sdm;
-  return CountedPtr<SDMemTable>(sdm.unaryOperate(*pIn, Float(factor), Bool(doAll), 
+  
+  return CountedPtr<SDMemTable>(sdmath.unaryOperate(*pIn, Float(factor), Bool(doAll), 
                                                  what, Bool (doTSys)));
 }
@@ -86 +87 @@
   SDMemTable* pIn = in.getPtr();
   const uInt what = 1;
-//
-  SDMath sdm;
+  
   Bool doTSys = False;
-  SDMemTable* pOut = sdm.unaryOperate (*pIn, Float(offset), 
+  SDMemTable* pOut = sdmath.unaryOperate (*pIn, Float(offset), 
                                         Bool(doAll), what, doTSys);
   *pIn = *pOut;
@@ -100 +100 @@
   const CountedPtr<SDMemTable>& pIn = in.getCP();
   const uInt what = 1;
-  SDMath sdm;
+  
   Bool doTSys = False;
-  return CountedPtr<SDMemTable>(sdm.unaryOperate(*pIn, Float(offset),
+  return CountedPtr<SDMemTable>(sdmath.unaryOperate(*pIn, Float(offset),
                                                   Bool(doAll), what, doTSys));
 }
@@ -112 +112 @@
 {
   SDMemTable* pIn = in.getPtr();
-  SDMath sdm;
-  SDMemTable* pOut = sdm.smooth(*pIn, String(kernel), 
+  
+  SDMemTable* pOut = sdmath.smooth(*pIn, String(kernel), 
                                 Float(width), Bool(doAll));
   *pIn = *pOut;
@@ -125 +125 @@
 {
   const CountedPtr<SDMemTable>& pIn = in.getCP();
-  SDMath sdm;
-  return CountedPtr<SDMemTable>(sdm.smooth(*pIn, String(kernel), 
+  
+  return CountedPtr<SDMemTable>(sdmath.smooth(*pIn, String(kernel), 
                                            Float(width), Bool(doAll)));
 }
@@ -135 +135 @@
 {
   SDMemTable* pIn = in.getPtr();
-  SDMath sdm;
-  SDMemTable* pOut = sdm.bin (*pIn, Int(width));
+  
+  SDMemTable* pOut = sdmath.bin (*pIn, Int(width));
   *pIn = *pOut;
    delete pOut;
@@ -145 +145 @@
 {
   const CountedPtr<SDMemTable>& pIn = in.getCP();
-  SDMath sdm;
-  return CountedPtr<SDMemTable>(sdm.bin(*pIn, Int(width)));
+  
+  return CountedPtr<SDMemTable>(sdmath.bin(*pIn, Int(width)));
 }
 
@@ -153 +153 @@
 {
   SDMemTable* pIn = in.getPtr();
-  SDMath sdm;
-  SDMemTable* pOut = sdm.resample(*pIn, String(method), Float(width));
+  
+  SDMemTable* pOut = sdmath.resample(*pIn, String(method), Float(width));
   *pIn = *pOut;
    delete pOut;
@@ -163 +163 @@
 {
   const CountedPtr<SDMemTable>& pIn = in.getCP();
-  SDMath sdm;
-  return CountedPtr<SDMemTable>(sdm.resample(*pIn, String(method), Float(width)));
+  
+  return CountedPtr<SDMemTable>(sdmath.resample(*pIn, String(method), Float(width)));
 }
 
@@ -173 +173 @@
 {
   SDMemTable* pIn = in.getPtr();
-  SDMath sdm;
+  
   Vector<Bool> tMask(mask);
-  SDMemTable* pOut = sdm.averagePol (*pIn, tMask, String(weightStr));
+  SDMemTable* pOut = sdmath.averagePol (*pIn, tMask, String(weightStr));
   *pIn = *pOut;
    delete pOut;
@@ -185 +185 @@
 {
   const CountedPtr<SDMemTable>& pIn = in.getCP();
-  SDMath sdm;
+  
   Vector<Bool> tMask(mask);
-  return CountedPtr<SDMemTable>(sdm.averagePol(*pIn, tMask, String(weightStr)));
+  return CountedPtr<SDMemTable>(sdmath.averagePol(*pIn, tMask, String(weightStr)));
 }
 
@@ -195 +195 @@
                                             const std::string& which, int row) 
 {
-  SDMath sdm;
+  
   Vector<Bool> tMask(mask);
-  return sdm.statistic(in.getCP(), tMask, String(which), Int(row));
+  return sdmath.statistic(in.getCP(), tMask, String(which), Int(row));
 }
 
@@ -205 +205 @@
 {
   SDMemTable* pIn = in.getPtr();
-  SDMath sdm;
-  SDMemTable* pOut = sdm.convertFlux (*pIn, Float(D), Float(eta), Float(JyPerK), Bool(doAll));
+  
+  SDMemTable* pOut = sdmath.convertFlux (*pIn, Float(D), Float(eta), Float(JyPerK), Bool(doAll));
   *pIn = *pOut;
   delete pOut;
@@ -216 +216 @@
 {
   const CountedPtr<SDMemTable>& pIn = in.getCP();
-  SDMath sdm;
-  return CountedPtr<SDMemTable>(sdm.convertFlux(*pIn, Float(D), Float(eta), Float(JyPerK), Bool(doAll)));
+  
+  return CountedPtr<SDMemTable>(sdmath.convertFlux(*pIn, Float(D), Float(eta), Float(JyPerK), Bool(doAll)));
 }
 
@@ -228 +228 @@
   SDMemTable* pIn = in.getPtr();
   Vector<Float> tCoeffs(coeffs);
-  SDMath sdm;
-  SDMemTable* pOut = sdm.gainElevation(*pIn, tCoeffs, String(fileName), 
+  
+  SDMemTable* pOut = sdmath.gainElevation(*pIn, tCoeffs, String(fileName), 
                                        String(method), Bool(doAll));
   *pIn = *pOut;
@@ -243 +243 @@
   const CountedPtr<SDMemTable>& pIn = in.getCP();
   Vector<Float> tCoeffs(coeffs);
-  SDMath sdm;
-  return CountedPtr<SDMemTable>(sdm.gainElevation(*pIn, tCoeffs, String(fileName), 
+  
+  return CountedPtr<SDMemTable>(sdmath.gainElevation(*pIn, tCoeffs, String(fileName), 
                                                   String(method), Bool(doAll)));
 }
@@ -252 +252 @@
 {
   SDMemTable* pIn = in.getPtr();
-  SDMath sdm;
-  SDMemTable* pOut = sdm.frequencyAlignment(*pIn, String(refTime), String(method),
+  
+  SDMemTable* pOut = sdmath.frequencyAlignment(*pIn, String(refTime), String(method),
                                             Bool(perFreqID));
   *pIn = *pOut;
@@ -266 +266 @@
 {
   const CountedPtr<SDMemTable>& pIn = in.getCP();
-  SDMath sdm;
-  return CountedPtr<SDMemTable>(sdm.frequencyAlignment(*pIn, String(refTime), 
+  
+  return CountedPtr<SDMemTable>(sdmath.frequencyAlignment(*pIn, String(refTime), 
                                                        String(method), Bool(perFreqID)));
 }
@@ -274 +274 @@
 {
   SDMemTable* pIn = in.getPtr();
-  SDMath sdm;
-  sdm.rotateXYPhase(*pIn, Float(angle), Bool(doAll));
+  
+  sdmath.rotateXYPhase(*pIn, Float(angle), Bool(doAll));
 }
 
@@ -282 +282 @@
 {
   SDMemTable* pIn = in.getPtr();
-  SDMath sdm;
-  sdm.rotateLinPolPhase(*pIn, Float(angle), Bool(doAll));
+  
+  sdmath.rotateLinPolPhase(*pIn, Float(angle), Bool(doAll));
 }
 
@@ -292 +292 @@
 {
   SDMemTable* pIn = in.getPtr();
-  SDMath sdm;
-  SDMemTable* pOut = sdm.opacity(*pIn, Float(tau), Bool(doAll));
-  *pIn = *pOut;
-  delete pOut;
-}
-
+  
+  SDMemTable* pOut = sdmath.opacity(*pIn, Float(tau), Bool(doAll));
+  *pIn = *pOut;
+  delete pOut;
+}
 
 SDMemTableWrapper SDMathWrapper::opacity(const SDMemTableWrapper& in, 
@@ -303 +302 @@
 {
   const CountedPtr<SDMemTable>& pIn = in.getCP();
+  
+  return CountedPtr<SDMemTable>(sdmath.opacity(*pIn, Float(tau), Bool(doAll)));
+}
+
+void SDMathWrapper::frequencySwitchInSitu(SDMemTableWrapper& in)
+{
+  SDMemTable* pIn = in.getPtr();
   SDMath sdm;
-  return CountedPtr<SDMemTable>(sdm.opacity(*pIn, Float(tau), Bool(doAll)));
-}
-
+  SDMemTable* pOut = sdm.frequencySwitch(*pIn);
+  *pIn = *pOut;
+  delete pOut;
+}
+
+SDMemTableWrapper SDMathWrapper::frequencySwitch(const SDMemTableWrapper& in)
+{
+  const CountedPtr<SDMemTable>& pIn = in.getCP();
+  SDMath sdm;
+  return CountedPtr<SDMemTable>(sdm.frequencySwitch(*pIn));
+}

trunk/src/SDMathWrapper.h

@@ -38 +38 @@
 
 #include "SDMemTableWrapper.h"
+#include "SDMath.h"
 
 namespace asap {
@@ -43 +44 @@
 namespace SDMathWrapper {
 
-// Quotient
+
+  static SDMath sdmath;
+  // Quotient
   SDMemTableWrapper quotient(const SDMemTableWrapper& on,
                              const SDMemTableWrapper& off,
                              casa::Bool preserveContinuum);
 
-// Simple binary operations
-  SDMemTableWrapper binaryOperate (const SDMemTableWrapper& left,
-                                   const SDMemTableWrapper& right,
-                                   const std::string& op, bool doTSys);
-
-// Multiply
-  void scaleInSitu(SDMemTableWrapper& in, float factor, bool doAll, bool doTSys);
-  SDMemTableWrapper scale(const SDMemTableWrapper& in, float factor, bool all, bool doTSys);
-
-// Add
+  // Simple binary operations
+  SDMemTableWrapper binaryOperate(const SDMemTableWrapper& left,
+                                  const SDMemTableWrapper& right,
+                                  const std::string& op, bool doTSys);
+  
+  // Multiply
+  void scaleInSitu(SDMemTableWrapper& in, float factor, bool doAll, 
+                   bool doTSys);
+  SDMemTableWrapper scale(const SDMemTableWrapper& in, float factor, 
+                          bool all, bool doTSys);
+  
+  // Add
   void addInSitu(SDMemTableWrapper& in, float offset, bool doAall);
   SDMemTableWrapper add(const SDMemTableWrapper& in, float offset, bool all);
@@ -72 +77 @@
 
 // Resample 
-  void resampleInSitu(SDMemTableWrapper& in, const std::string& method, float width);
-  SDMemTableWrapper resample(const SDMemTableWrapper& in, const std::string& method, 
+  void resampleInSitu(SDMemTableWrapper& in, const std::string& method, 
+                      float width);
+  SDMemTableWrapper resample(const SDMemTableWrapper& in, 
+                             const std::string& method, 
                              float width);
 
 // Convert brightness between Jy and K
-  void convertFluxInSitu(SDMemTableWrapper& in, float D, float eta, float JyPerK, bool doAll);
-  SDMemTableWrapper convertFlux(const SDMemTableWrapper& in, float D, float eta, float JyPerK, bool doAll);
+  void convertFluxInSitu(SDMemTableWrapper& in, float D, float eta, 
+                         float JyPerK, bool doAll);
+  SDMemTableWrapper convertFlux(const SDMemTableWrapper& in, float D, 
+                                float eta, float JyPerK, bool doAll);
 
 // Apply gain elevation correction
@@ -101 +110 @@
 
 // Apply opacity correction
-  void opacityInSitu (SDMemTableWrapper& in, float tau, bool doAll);
-  SDMemTableWrapper opacity (const SDMemTableWrapper& in, float tau, bool doAll);
+  void opacityInSitu(SDMemTableWrapper& in, float tau, bool doAll);
+  SDMemTableWrapper opacity(const SDMemTableWrapper& in, float tau, 
+                            bool doAll);
 
 // Average in time
@@ -116 +126 @@
                                const std::string& weightStr);
 
-// Statistics
+  // Frequency Switching
+  void SDMathWrapper::frequencySwitchInSitu(SDMemTableWrapper& in);
+
+  SDMemTableWrapper 
+  SDMathWrapper::frequencySwitch(const SDMemTableWrapper& in);
+
+  // Statistics
   std::vector<float> statistic(const SDMemTableWrapper& in,
                                const std::vector<bool>& mask, 
                                const std::string& which, int row);
+
 };
 

trunk/src/python_SDMath.cc

@@ -58 +58 @@
       }
       Vector<Bool> msk(mask);
-      //
-      SDMath sdm;
-      return SDMemTableWrapper(sdm.average(b, msk, Bool(scanAv), weightStr));
+      
+      return SDMemTableWrapper(sdmath.average(b, msk, Bool(scanAv), weightStr));
     };
   } // namespace SDMathWrapper
@@ -67 +66 @@
     void python_SDMath() {
       def("b_operate", &SDMathWrapper::binaryOperate);
-      //
+      
       def("quotient", &SDMathWrapper::quotient);
-//
+
       def("scale", &SDMathWrapper::scale);
       def("scale_insitu", &SDMathWrapper::scaleInSitu);
-//
+
       def("add", &SDMathWrapper::add);
       def("add_insitu", &SDMathWrapper::addInSitu);
-//
+
       def("smooth", &SDMathWrapper::smooth);
       def("smooth_insitu", &SDMathWrapper::smoothInSitu);
-//
+
       def("convertflux", &SDMathWrapper::convertFlux);
       def("convertflux_insitu", &SDMathWrapper::convertFluxInSitu);
-//
+
       def("gainel", &SDMathWrapper::gainElevation);
       def("gainel_insitu", &SDMathWrapper::gainElevationInSitu);
-//
+
       def("freq_align", &SDMathWrapper::frequencyAlignment);
       def("freq_align_insitu", &SDMathWrapper::frequencyAlignmentInSitu);
-//
+
       def("opacity", &SDMathWrapper::opacity);
       def("opacity_insitu", &SDMathWrapper::opacityInSitu);
-//
+
       def("average", &SDMathWrapper::average);
-//
+
       def("averagepol", &SDMathWrapper::averagePol);
       def("averagepol_insitu", &SDMathWrapper::averagePolInSitu);
-//
+
       def("bin", &SDMathWrapper::bin);
       def("bin_insitu", &SDMathWrapper::binInSitu);
-//
+
       def("resample", &SDMathWrapper::resample);
       def("resample_insitu", &SDMathWrapper::resampleInSitu);
-//
+
       def("stats", &SDMathWrapper::statistic);
-// 
-      def ("_rotate_xyphase", &SDMathWrapper::rotateXYPhaseInSitu);
-      def ("_rotate_linpolphase", &SDMathWrapper::rotateLinPolPhaseInSitu);
+ 
+      def("_rotate_xyphase", &SDMathWrapper::rotateXYPhaseInSitu);
+      def("_rotate_linpolphase", &SDMathWrapper::rotateLinPolPhaseInSitu);
+
+      def("_frequency_switch", &SDMathWrapper::frequencySwitch);
     };