Changeset 146

Timestamp:

12/26/04 14:56:06 (19 years ago)

Author:

kil064

Message:

rework 'multiply' and 'multiplyInSitu' to use one common
'localMultiply' function behind the scenes.

Location:

trunk/src

Files:

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

trunk/src/SDMath.cc

@@ -268 +268 @@
         }
 
-// Accumulation step. First get data and deconstruct
-
-        MaskedArray<Float> dataIn(in[iTab]->rowAsMaskedArray(iRow));
-        Array<Float>& valuesIn = dataIn.getRWArray();           // writable reference
-        const Array<Bool>& maskIn = dataIn.getMask();          // RO reference
-//
-        if (wtType==NONE) {
-           const MaskedArray<Float> n(nInc,dataIn.getMask());
-           nPts += n;                               // Only accumulates where mask==T
-        } else if (wtType==VAR) {
-
-// We are going to average the data, weighted by the noise for each pol, beam and IF.
-// So therefore we need to iterate through by spectrum (axis 3)
-
-           VectorIterator<Float> itData(valuesIn, axis);
-           ReadOnlyVectorIterator<Bool> itMask(maskIn, axis);
-           while (!itData.pastEnd()) {
-
-// Make MaskedArray of Vector, optionally apply OTF mask, and find scaling factor
-
-             if (useMask) {
-                MaskedArray<Float> tmp(itData.vector(),mask&&itMask.vector());
-                fac = 1.0/variance(tmp);
-             } else {
-                MaskedArray<Float> tmp(itData.vector(),itMask.vector());
-                fac = 1.0/variance(tmp);
-             }
-
-// Scale data
-
-             itData.vector() *= fac;     // Writes back into 'dataIn'
-//
-// Accumulate variance per if/pol/beam averaged over spectrum
-// This method to get pos2 from itData.pos() is only valid
-// because the spectral axis is the last one (so we can just
-// copy the first nAXesSub positions out)
-
-             pos2 = itData.pos().getFirst(nAxesSub);
-             sumSq(pos2) += fac;
-//
-             itData.next();
-             itMask.next();
-           }
-        } else if (wtType==TSYS) {
-        }
-
-// Accumulate sum of (possibly scaled) data
-
-       sum += dataIn;
-
-// Accumulate Tsys, time, and interval
-
-       tSysSum += tSys;
-       timeSum += time;
-       intSum += interval;
-
-// Number of rows in accumulation
-
-       nAccum += 1;
+// Accumulate
+
+        accumulate (timeSum, intSum, nAccum, sum, sumSq, nPts, tSysSum, 
+                    tSys, nInc, mask, time, interval, in, iTab, iRow, axis, 
+                    nAxesSub, useMask, wtType);
+//
        oldSourceName = sourceName;
        oldFreqID = freqID;
@@ -433 +380 @@
 }
 
-void SDMath::multiplyInSitu(SDMemTable* in, Float factor) {
-  SDMemTable* sdmt = new SDMemTable(*in);
-  Table t = sdmt->table();
-  ArrayColumn<Float> spec(t,"SPECTRA");  
-  for (uInt i=0; i < t.nrow(); i++) {
-    MaskedArray<Float> marr(sdmt->rowAsMaskedArray(i));
-    marr *= factor;
-    spec.put(i, marr.getArray());
-  }
-  in = sdmt;
-  delete sdmt;sdmt=0;
-}
+
+
+void SDMath::multiplyInSitu(SDMemTable* pIn, Float factor)
+{
+  SDMemTable* pOut = localMultiply (*pIn, factor);
+  *pIn = *pOut;
+   delete pOut;
+}  
+
 
 CountedPtr<SDMemTable>
 SDMath::multiply(const CountedPtr<SDMemTable>& in, Float factor) 
-//
-// Multiply values by factor
-//
-{
-  SDMemTable* sdmt = new SDMemTable(*in);
-  Table t = sdmt->table();
-  ArrayColumn<Float> spec(t,"SPECTRA");
-
-  for (uInt i=0; i < t.nrow(); i++) {
-    MaskedArray<Float> marr(sdmt->rowAsMaskedArray(i));
-    marr *= factor;
-    spec.put(i, marr.getArray());
-  }
-  return CountedPtr<SDMemTable>(sdmt);
+{
+  return CountedPtr<SDMemTable>(localMultiply(*in,factor));
 }
 
@@ -470 +402 @@
 //
 {
-  SDMemTable* sdmt = new SDMemTable(*in);
-
+  SDMemTable* sdmt = new SDMemTable(*in,False);
   Table t = sdmt->table();
   ArrayColumn<Float> spec(t,"SPECTRA");
@@ -765 +696 @@
 }
 
+
+
+// 'private' functions
+
 void SDMath::fillSDC (SDContainer& sc,
                       const Array<Bool>& mask,
@@ -823 +758 @@
 }
 
+
+void SDMath::accumulate (Double& timeSum, Double& intSum, Int& nAccum,
+                         MaskedArray<Float>& sum, Array<Float>& sumSq, 
+                         Array<Float>& nPts, Array<Float>& tSysSum, 
+                         const Array<Float>& tSys, const Array<Float>& nInc, 
+                         const Vector<Bool>& mask, Double time, Double interval,
+                         const Block<CountedPtr<SDMemTable> >& in,
+                         uInt iTab, uInt iRow, uInt axis, 
+                         uInt nAxesSub, Bool useMask,
+                         weightType wtType)
+{
+
+// Get data
+
+   MaskedArray<Float> dataIn(in[iTab]->rowAsMaskedArray(iRow));
+   Array<Float>& valuesIn = dataIn.getRWArray();           // writable reference
+   const Array<Bool>& maskIn = dataIn.getMask();          // RO reference
+//
+   if (wtType==NONE) {
+      const MaskedArray<Float> n(nInc,dataIn.getMask());
+      nPts += n;                               // Only accumulates where mask==T
+   } else if (wtType==VAR) {
+
+// We are going to average the data, weighted by the noise for each pol, beam and IF.
+// So therefore we need to iterate through by spectrum (axis 3)
+
+      VectorIterator<Float> itData(valuesIn, axis);
+      ReadOnlyVectorIterator<Bool> itMask(maskIn, axis);
+      Float fac = 1.0;
+      IPosition pos(nAxesSub,0);  
+//
+      while (!itData.pastEnd()) {
+
+// Make MaskedArray of Vector, optionally apply OTF mask, and find scaling factor
+
+        if (useMask) {
+           MaskedArray<Float> tmp(itData.vector(),mask&&itMask.vector());
+           fac = 1.0/variance(tmp);
+        } else {
+           MaskedArray<Float> tmp(itData.vector(),itMask.vector());
+           fac = 1.0/variance(tmp);
+        }
+
+// Scale data
+
+        itData.vector() *= fac;     // Writes back into 'dataIn'
+//
+// Accumulate variance per if/pol/beam averaged over spectrum
+// This method to get pos2 from itData.pos() is only valid
+// because the spectral axis is the last one (so we can just
+// copy the first nAXesSub positions out)
+
+        pos = itData.pos().getFirst(nAxesSub);
+        sumSq(pos) += fac;
+//
+        itData.next();
+        itMask.next();
+      }
+   } else if (wtType==TSYS) {
+   }
+
+// Accumulate sum of (possibly scaled) data
+
+   sum += dataIn;
+
+// Accumulate Tsys, time, and interval
+
+   tSysSum += tSys;
+   timeSum += time;
+   intSum += interval;
+   nAccum += 1;
+}
+
+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());
+  }
+   return pOut;
+}
+
+

trunk/src/SDMath.h

@@ -45 +45 @@
   casa::CountedPtr<SDMemTable> quotient(const casa::CountedPtr<SDMemTable>& on, 
                                          const casa::CountedPtr<SDMemTable>& off);
-
+//
   void multiplyInSitu(SDMemTable* in, casa::Float factor);
-
   casa::CountedPtr<SDMemTable> multiply(const casa::CountedPtr<SDMemTable>& in, 
-                                  casa::Float factor);
-
+                                        casa::Float factor);
+//
   casa::CountedPtr<SDMemTable> add(const casa::CountedPtr<SDMemTable>& in, 
                              casa::Float offset);
@@ -74 +73 @@
   enum weightType {NONE,VAR,TSYS};
 
+  void accumulate (casa::Double& timeSum, casa::Double& intSum, casa::Int& nAccum,
+                   casa::MaskedArray<casa::Float>& sum, casa::Array<casa::Float>& sumSq,
+                   casa::Array<casa::Float>& nPts, casa::Array<casa::Float>& tSysSum,
+                   const casa::Array<casa::Float>& tSys,  const casa::Array<casa::Float>& nInc,
+                   const casa::Vector<casa::Bool>& mask, casa::Double time, casa::Double interval,
+                   const casa::Block<casa::CountedPtr<SDMemTable> >& in,
+                   casa::uInt iTab, casa::uInt iRow, casa::uInt axis, casa::uInt nAxesSub,
+                   casa::Bool useMask, weightType wtType);
+
   void fillSDC (SDContainer& sc, const casa::Array<casa::Bool>& mask,
                 const casa::Array<casa::Float>& data,
@@ -80 +88 @@
                 casa::Double interval, const casa::String& sourceName,
                 const casa::Vector<casa::uInt>& freqID);
-   void normalize (casa::MaskedArray<casa::Float>& data,
-                   const casa::Array<casa::Float>& sumSq,
-                   const casa::Array<casa::Float>& nPts,
-                   weightType wtType, casa::Int axis, casa::Int nAxes);
 
+  SDMemTable* localMultiply (const SDMemTable& in, casa::Float factor);
 
+  void normalize (casa::MaskedArray<casa::Float>& data,
+                  const casa::Array<casa::Float>& sumSq,
+                  const casa::Array<casa::Float>& nPts,
+                  weightType wtType, casa::Int axis, casa::Int nAxes);
 };
 
@@ -91 +100 @@
 
 #endif
+
+
+
+
+