Changeset 330

Timestamp:

01/31/05 12:11:36 (20 years ago)

Author:

kil064

Message:

reqork frequency alignment to

• only make the required numnber of aligners
• write out a correct frequency table with new FreqIDs

Location:

trunk/src

Files:

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

trunk/src/SDMath.cc

@@ -32 +32 @@
 
 #include <casa/aips.h>
+#include <casa/iostream.h>
+#include <casa/iomanip.h>
 #include <casa/BasicSL/String.h>
 #include <casa/Arrays/IPosition.h>
@@ -42 +44 @@
 #include <casa/Arrays/MaskArrMath.h>
 #include <casa/Arrays/MaskArrLogi.h>
+#include <casa/Arrays/Matrix.h>
 #include <casa/BasicMath/Math.h>
 #include <casa/Containers/Block.h>
@@ -1260 +1263 @@
    const uInt nChan = sh.nchan;
    const uInt nRows = in.nRow();
+   const uInt nIF = sh.nif;
 
 // Get Table reference
@@ -1270 +1274 @@
    ROScalarColumn<String> srcCol(tabIn, "SRCNAME");
    ROArrayColumn<uInt> fqIDCol(tabIn, "FREQID");
-//
    Vector<Double> times = mjdCol.getColumn();
-   Vector<String> srcNames = srcCol.getColumn();
-   Vector<uInt> freqID;
-
-// Generate Source table
-
-   Vector<String> srcTab;
-   Vector<uInt> srcIdx, firstRow;
-   generateSourceTable (srcTab, srcIdx, firstRow, srcNames);
-   const uInt nSrcTab = srcTab.nelements();
-   cerr << "Found " << srcTab.nelements() << " sources to align " << endl;
+
+// Generate DataDesc table
+ 
+   Matrix<uInt> ddIdx;
+   SDDataDesc dDesc;
+   generateDataDescTable (ddIdx, dDesc, nIF, in, tabIn, srcCol, fqIDCol);
 
 // Get reference Epoch to time of first row or given String
@@ -1300 +1299 @@
    MPosition refPos = in.getAntennaPosition();
 
-// Get Frequency Table
-
-   SDFrequencyTable fTab = in.getSDFreqTable();
-   const uInt nFreqIDs = fTab.length();
-
 // Create FrequencyAligner Block. One VA for each possible
 // source/freqID combination
 
-   PtrBlock<FrequencyAligner<Float>* > a(nFreqIDs*nSrcTab);
-   generateFrequencyAligners (a, in, nChan, nFreqIDs, nSrcTab, firstRow,
-                              freqSystem, refPos, refEpoch);
+   PtrBlock<FrequencyAligner<Float>* > a(dDesc.length());
+   generateFrequencyAligners (a, dDesc, in, nChan, freqSystem, refPos, refEpoch);
+
+// Generate and fill output Frequency Tabke
+
+   SDFrequencyTable freqTabOut = in.getSDFreqTable();
+   freqTabOut.setLength(0);
+   Vector<String> units(1);
+   units = String("Hz");
+   Bool linear=True;
+//
+   for (uInt i=0; i<dDesc.length(); i++) {
+
+// Get Aligned SC in Hz
+
+      SpectralCoordinate sC = a[i]->alignedSpectralCoordinate(linear);
+      sC.setWorldAxisUnits(units);
+
+// Add FreqID
+
+      freqTabOut.addFrequency(sC.referencePixel()[0],
+                              sC.referenceValue()[0],
+                              sC.increment()[0]);
+   }
 
 // Interpolation method
@@ -1320 +1335 @@
 
    SDMemTable* pTabOut = new SDMemTable(in,True);
+   pTabOut->putSDFreqTable(freqTabOut);
 
 // Loop over rows in Table
 
+   Bool extrapolate=False;
    const IPosition polChanAxes(2, asap::PolAxis, asap::ChanAxis);
-
-   Bool extrapolate=False;
    Bool useCachedAbcissa = False;
    Bool first = True;
@@ -1331 +1346 @@
    Vector<Float> yOut;
    Vector<Bool> maskOut;
+   Vector<uInt> freqID(nIF);
    uInt ifIdx, faIdx;
 //
@@ -1343 +1359 @@
      MVEpoch mv2(tQ2);
      MEpoch epoch(mv2, epochRef);
-
-// Get FreqID vector.  One freqID per IF
-
-     fqIDCol.get(iRow, freqID);
 
 // Get copy of data
@@ -1359 +1371 @@
 // of polarization.  For all other axes (IF and BEAM) the abcissa
 // will change.  So we iterate through the data by pol-chan planes
-// to mimimize the work.  At this point, I think the Direction
-// is stored as the same for each beam. DOn't know where the 
-// offsets are or what to do about them right now.  For now
-// all beams get same position and velocoity abcissa.
+// to mimimize the work.  Probably won't work for multiple beams
+// at this point.
 
      ArrayIterator<Float> itValuesPlane(values, polChanAxes);
@@ -1372 +1382 @@
         const IPosition& pos = itValuesPlane.pos();
         ifIdx = pos(asap::IFAxis);
-        faIdx = (srcIdx[iRow]*nFreqIDs) + freqID[ifIdx];
+        faIdx = ddIdx(iRow,ifIdx);
 //
         VectorIterator<Float> itValuesVec(itValuesPlane.array(), 1); 
         VectorIterator<Bool> itMaskVec(itMaskPlane.array(), 1);
-//
+
+// Iterate through the plane by vector and align
+
         first = True;
         useCachedAbcissa=False;
@@ -1383 +1395 @@
                                  itMaskVec.vector(), epoch, useCachedAbcissa,
                                  interp, extrapolate); 
+//
            itValuesVec.vector() = yOut;
            itMaskVec.vector() = maskOut;
@@ -1401 +1414 @@
 // cerr << "values out = " << values(IPosition(4,0,0,0,0),IPosition(4,0,0,0,9)) << endl;
 
-// Create and put back
+// Create SDContainer and put back
 
     SDContainer sc = in.getSDContainer(iRow);
     putDataInSDC(sc, values, mask);
+    for (uInt i=0; i<nIF; i++) {
+       uInt idx = ddIdx(iRow,i);
+       freqID(i) = dDesc.freqID(idx);
+    }
+    sc.putFreqMap(freqID);
 //
     pTabOut->putSDContainer(sc);
    }
-
-
-// Write out correct frequency table information for output.
-// CLone from input and overwrite
-
-   SDFrequencyTable freqTab = in.getSDFreqTable();
-   freqTab.setLength(0);
-
-// Note that we don't have anyway to hold frequency table information 
-// in the SDMemTable which is source dependent.  Each FrequencyAligner 
-// is generated for an freqID/Source combination.  Don't know what to 
-// do about this apart from to pick the aligned SC from the first source 
-// at the moment.  ASAP really needs to handle data description id 
-// like in aips++ which is a combination of source and freqid. Otherwise
-// all else I can do in this function is disallow multiple sources
-
-   Bool linear=True;
-   Vector<String> units(1);
-   units = String("Hz");
-   for (uInt fqID=0; fqID<nFreqIDs; fqID++) {
-      for (uInt iSrc=0; iSrc<nSrcTab; iSrc++) {
-         uInt idx = (iSrc*nFreqIDs) + fqID;
-
-// Get Aligned SC in Hz
-
-         if (iSrc==0) {
-            SpectralCoordinate sC = a[idx]->alignedSpectralCoordinate(linear);
-            sC.setWorldAxisUnits(units);
-
-// Write out frequency table information to SDMemTable
-
-            Int idx = freqTab.addFrequency(sC.referencePixel()[0],
-                                           sC.referenceValue()[0],
-                                           sC.increment()[0]);
-         }
-      }
-   }
-   pTabOut->putSDFreqTable(freqTab);
 
 // Now we must set the base and extra frames to the 
@@ -1757 +1737 @@
 
 
-void SDMath::generateSourceTable (Vector<String>& srcTab,
-                                  Vector<uInt>& srcIdx,
-                                  Vector<uInt>& firstRow,
-                                  const Vector<String>& srcNames) const
-//
-// This algorithm assumes that if there are multiple beams
-// that the source names are diffent.  Oterwise we would need
-// to look atthe direction for each beam...
-//
-{
-   const uInt nRow = srcNames.nelements();
-   srcTab.resize(0);
-   srcIdx.resize(nRow);
-   firstRow.resize(0);
-//
-   uInt nSrc = 0;
-   for (uInt i=0; i<nRow; i++) {
-      String srcName = srcNames[i];
-      
-// Do we have this source already ?
-
-      Int idx = -1;
-      if (nSrc>0) {
-         for (uInt j=0; j<nSrc; j++) {
-           if (srcName==srcTab[j]) {
-              idx = j;
-              break;
-           }
-         }
+
+
+void SDMath::generateDataDescTable (Matrix<uInt>& ddIdx,
+                                    SDDataDesc& dDesc,
+                                    uInt nIF,
+                                    const SDMemTable& in,
+                                    const Table& tabIn,
+                                    const ROScalarColumn<String>& srcCol,
+                                    const ROArrayColumn<uInt>& fqIDCol) const
+{
+   const uInt nRows = tabIn.nrow();
+   ddIdx.resize(nRows,nIF);
+//
+   String srcName;
+   Vector<uInt> freqIDs;
+   for (uInt iRow=0; iRow<nRows; iRow++) {
+      srcCol.get(iRow, srcName);
+      fqIDCol.get(iRow, freqIDs);
+      const MDirection& dir = in.getDirection(iRow);
+//
+      for (uInt iIF=0; iIF<nIF; iIF++) {
+         uInt idx = dDesc.addEntry(srcName, freqIDs[iIF], dir);
+         ddIdx(iRow,iIF) = idx;
       }
-
-// Add new entry if not found
-
-      if (idx==-1) {
-         nSrc++;
-         srcTab.resize(nSrc,True);
-         srcTab(nSrc-1) = srcName;
-         idx = nSrc-1;
-//
-         firstRow.resize(nSrc,True);
-         firstRow(nSrc-1) = i;       // First row for which this source occurs
-      }
-
-// Set index for this row
-
-      srcIdx[i] = idx;
    }
 }
@@ -1828 +1786 @@
 
 void SDMath::generateFrequencyAligners (PtrBlock<FrequencyAligner<Float>* >& a, 
-                                       const SDMemTable& in, uInt nChan,
-                                       uInt nFreqIDs, uInt nSrcTab, 
-                                       const Vector<uInt>& firstRow,
-                                       MFrequency::Types system,
-                                       const MPosition& refPos,
-                                       const MEpoch& refEpoch) const
-{
-   for (uInt fqID=0; fqID<nFreqIDs; fqID++) {
-      SpectralCoordinate sC = in.getSpectralCoordinate(fqID);
-      for (uInt iSrc=0; iSrc<nSrcTab; iSrc++) {
-         MDirection refDir = in.getDirection(firstRow[iSrc]);
-         uInt idx = (iSrc*nFreqIDs) + fqID;
-         a[idx] = new FrequencyAligner<Float>(sC, nChan, refEpoch, refDir, refPos, system);
-      }
+                                        const SDDataDesc& dDesc,
+                                        const SDMemTable& in, uInt nChan,
+                                        MFrequency::Types system,
+                                        const MPosition& refPos,
+                                        const MEpoch& refEpoch) const
+{
+   for (uInt i=0; i<dDesc.length(); i++) {
+      uInt freqID = dDesc.freqID(i);
+      const MDirection& refDir = dDesc.direction(i);
+//
+      SpectralCoordinate sC = in.getSpectralCoordinate(freqID);
+      a[i] = new FrequencyAligner<Float>(sC, nChan, refEpoch, refDir, refPos, system);
    }
 }

trunk/src/SDMath.h

@@ -44 +44 @@
 class casa::MPosition;
 template<class T> class casa::PtrBlock;
+template<class T> class casa::Matrix;
+template<class T> class casa::ROScalarColumn;
+template<class T> class casa::ROArrayColumn;
+
 
 
@@ -49 +53 @@
 
 class SDMemTable;
+class SDDataDesc;
 
 class SDMath {
@@ -191 +196 @@
    casa::Table readAsciiFile (const casa::String& fileName) const;
 
-// Generate source table
-   void generateSourceTable (casa::Vector<casa::String>& srcTab,
-                             casa::Vector<casa::uInt>& srcIdx,
-                             casa::Vector<casa::uInt>& firstRow,
-                             const casa::Vector<casa::String>& srcNames) const;
-
 // Generate frequency aligners
    void generateFrequencyAligners (casa::PtrBlock<casa::FrequencyAligner<casa::Float>* >& a,
+                                   const SDDataDesc& dDesc,
                                    const SDMemTable& in, casa::uInt nChan,
-                                   casa::uInt nFreqIDs, casa::uInt nSrcTab,
-                                   const casa::Vector<casa::uInt>& firstRow,
                                    casa::MFrequency::Types system,
                                    const casa::MPosition& refPos,
                                    const casa::MEpoch& refEpoch) const;
+
+// Generate data description table (combines source and freqID)
+   void generateDataDescTable (casa::Matrix<casa::uInt>& ddIdx,
+                               SDDataDesc& dDesc,
+                               casa::uInt nIF,
+                               const SDMemTable& in,
+                               const casa::Table& tabIn,
+                               const casa::ROScalarColumn<casa::String>& srcCol,
+                               const casa::ROArrayColumn<casa::uInt>& fqIDCol) const;
 
 // Align in Frequency
@@ -219 +226 @@
 };
 
+
+
+
 } // namespace