Changeset 152

Timestamp:

12/26/04 20:51:14 (20 years ago)

Author:

kil064

Message:

function 'add' and 'multiply' now take arg. doAll to
indicate whether operation to be applied to
all spectral or cursor selection only.

Combine functions 'localMultiply' and 'localAdd' into
'localOperate'

Location:

trunk/src

Files:

• SDMath.cc (modified) (4 diffs)
• SDMath.h (modified) (5 diffs)

trunk/src/SDMath.cc

@@ -380 +380 @@
 }
 
-
-
-void SDMath::multiplyInSitu(SDMemTable* pIn, Float factor)
-{
-  SDMemTable* pOut = localMultiply (*pIn, factor);
+void SDMath::multiplyInSitu(SDMemTable* pIn, Float factor, Bool doAll)
+{
+  const uInt what = 0;
+  SDMemTable* pOut = localOperate (*pIn, factor, doAll, what);
   *pIn = *pOut;
    delete pOut;
@@ -391 +390 @@
 
 CountedPtr<SDMemTable>
-SDMath::multiply(const CountedPtr<SDMemTable>& in, Float factor) 
-{
-  return CountedPtr<SDMemTable>(localMultiply(*in,factor));
-}
+SDMath::multiply(const CountedPtr<SDMemTable>& in, Float factor, Bool doAll)
+{
+  const uInt what = 0;
+  return CountedPtr<SDMemTable>(localOperate (*in, factor, doAll, what));
+}
+
+
+void SDMath::addInSitu (SDMemTable* pIn, Float offset, Bool doAll)
+{
+  const uInt what = 1;
+  SDMemTable* pOut = localOperate (*pIn, offset, doAll, what);
+  *pIn = *pOut;
+   delete pOut;
+}  
+
 
 CountedPtr<SDMemTable>
-SDMath::add(const CountedPtr<SDMemTable>& in, Float offset) 
-//
-// Add offset to values
-//
-{
-  SDMemTable* sdmt = new SDMemTable(*in,False);
-  Table t = sdmt->table();
-  ArrayColumn<Float> spec(t,"SPECTRA");
-
-  for (uInt i=0; i < t.nrow(); i++) {
-    MaskedArray<Float> marr(sdmt->rowAsMaskedArray(i));
-    marr += offset;
-    spec.put(i, marr.getArray());
-  }
-  return CountedPtr<SDMemTable>(sdmt);
+SDMath::add(const CountedPtr<SDMemTable>& in, Float offset, Bool doAll)
+{
+  const uInt what = 1;
+  return CountedPtr<SDMemTable>(localOperate(*in, offset, doAll, what));
 }
 
@@ -657 +656 @@
 // Specify cursor location
 
-  uInt i = in->getBeam();
-  uInt j = in->getIF();
-  uInt k = in->getPol();
-  IPosition start(4,i,j,k,0);
-  IPosition end(4,i,j,k,in->nChan()-1);
+  IPosition start, end;
+  getCursorLocation (start, end, *in);
 
 // Loop over rows
@@ -831 +827 @@
 }
 
-SDMemTable* SDMath::localMultiply (const SDMemTable& in, Float factor) 
-{
-  SDMemTable* pOut = new SDMemTable(in,False);
-  const Table& tOut = pOut->table();
-  ArrayColumn<Float> spec(tOut,"SPECTRA");  
-//
-  for (uInt i=0; i < tOut.nrow(); i++) {
-    MaskedArray<Float> marr(pOut->rowAsMaskedArray(i));
-    marr *= factor;
-    spec.put(i, marr.getArray());
-  }
+SDMemTable* SDMath::localOperate (const SDMemTable& in, Float val, Bool doAll,
+                                  uInt what)
+//
+// what = 0   Multiply
+//        1   Add
+{
+   SDMemTable* pOut = new SDMemTable(in,False);
+   const Table& tOut = pOut->table();
+   ArrayColumn<Float> spec(tOut,"SPECTRA");  
+//
+   if (doAll) {
+      for (uInt i=0; i < tOut.nrow(); i++) {
+
+// Get
+
+         MaskedArray<Float> marr(pOut->rowAsMaskedArray(i));
+
+// Operate
+
+         if (what==0) {
+            marr *= val;
+         } else if (what==1) {
+            marr += val;
+         }
+
+// Put
+
+         spec.put(i, marr.getArray());
+      }
+   } else {
+
+// Get cursor location
+
+      IPosition start, end;
+      getCursorLocation (start, end, in);
+//
+      for (uInt i=0; i < tOut.nrow(); i++) {
+
+// Get
+
+         MaskedArray<Float> dataIn(pOut->rowAsMaskedArray(i));
+
+// Modify. More work than we would like to deal with the mask
+
+         Array<Float>& values = dataIn.getRWArray();
+         Array<Bool> mask(dataIn.getMask());
+//
+         Array<Float> values2 = values(start,end);
+         Array<Bool> mask2 = mask(start,end);
+         MaskedArray<Float> t(values2,mask2);
+         if (what==0) {
+            t *= val;
+         } else if (what==1) {
+            t += val;
+         }
+         values(start, end) = t.getArray();     // Write back into 'dataIn'
+
+// Put
+         spec.put(i, dataIn.getArray());
+      }
+   }
+//
    return pOut;
 }
 
 
+
+void SDMath::getCursorLocation (IPosition& start, IPosition& end,
+                                const SDMemTable& in)
+{
+  const uInt nDim = 4;
+  const uInt i = in.getBeam();
+  const uInt j = in.getIF();
+  const uInt k = in.getPol();
+  const uInt n = in.nChan();
+//
+  IPosition s(nDim,i,j,k,0);
+  IPosition e(nDim,i,j,k,n-1);
+//
+  start.resize(nDim);
+  start = s;
+  end.resize(nDim);
+  end = e;
+}

trunk/src/SDMath.h

@@ -42 +42 @@
 
 namespace SDMath {
-  //public:
+
+// Quotient
+
   casa::CountedPtr<SDMemTable> quotient(const casa::CountedPtr<SDMemTable>& on, 
                                          const casa::CountedPtr<SDMemTable>& off);
-//
-  void multiplyInSitu(SDMemTable* in, casa::Float factor);
+
+// Multiply
+
+  void multiplyInSitu(SDMemTable* in, casa::Float factor, casa::Bool all);
   casa::CountedPtr<SDMemTable> multiply(const casa::CountedPtr<SDMemTable>& in, 
-                                        casa::Float factor);
-//
+                                        casa::Float factor, casa::Bool all);
+
+// Addition
+
+  void addInSitu (SDMemTable* in, casa::Float offset, casa::Bool all);
   casa::CountedPtr<SDMemTable> add(const casa::CountedPtr<SDMemTable>& in, 
-                             casa::Float offset);
-  
+                                   casa::Float offset, casa::Bool all);
+
+//  Hanning
+
   casa::CountedPtr<SDMemTable> hanning(const casa::CountedPtr<SDMemTable>& in);
+
+// Bin up
+
+  casa::CountedPtr<SDMemTable> bin(const casa::CountedPtr<SDMemTable>& in, 
+                             casa::Int width);
+
+// Average in time
 
   casa::CountedPtr<SDMemTable>
@@ -60 +76 @@
            bool scanAverage, const std::string& weightStr);
 
+// Average polarizations
+
   casa::CountedPtr<SDMemTable> 
   averagePol(const casa::CountedPtr<SDMemTable>& in, const casa::Vector<casa::Bool>& mask);
 
+// Statistics
+
   std::vector<float> statistic(const casa::CountedPtr<SDMemTable>& in, 
                                 const std::vector<bool>& mask, const std::string& which);
-  
-  casa::CountedPtr<SDMemTable> bin(const casa::CountedPtr<SDMemTable>& in, 
-                             casa::Int width);
 
 // private (not actually...)
 
+// Weighting type for time averaging
+
   enum weightType {NONE,VAR,TSYS};
+
+// Function to use accumulate data during time averaging
 
   void accumulate (casa::Double& timeSum, casa::Double& intSum, casa::Int& nAccum,
@@ -82 +103 @@
                    casa::Bool useMask, weightType wtType);
 
+// Function to fill Scan Container when averaging in time
+
   void fillSDC (SDContainer& sc, const casa::Array<casa::Bool>& mask,
                 const casa::Array<casa::Float>& data,
@@ -89 +112 @@
                 const casa::Vector<casa::uInt>& freqID);
 
-  SDMemTable* localMultiply (const SDMemTable& in, casa::Float factor);
+// Function to normalize data when averaging in time
 
   void normalize (casa::MaskedArray<casa::Float>& data,
@@ -95 +118 @@
                   const casa::Array<casa::Float>& nPts,
                   weightType wtType, casa::Int axis, casa::Int nAxes);
+
+// Functions for simple mathematical operations.  what=0 (mul) or 1 (add)
+
+  SDMemTable* localOperate (const SDMemTable& in, casa::Float offset, 
+                            casa::Bool doAll, casa::uInt what);
+
+// Function to get the current cursor location
+   void getCursorLocation (casa::IPosition& start, casa::IPosition& end,
+                           const SDMemTable& in);
 };