Changeset 309

Timestamp:

01/27/05 21:49:56 (19 years ago)

Author:

kil064

Message:

remove 'velocityALignment' functions for new 'frequencyAlignment' ones

Location:

trunk/src

Files:

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

trunk/src/SDMath.cc

@@ -55 +55 @@
 #include <coordinates/Coordinates/CoordinateSystem.h>
 #include <coordinates/Coordinates/CoordinateUtil.h>
-#include <coordinates/Coordinates/VelocityAligner.h>
+#include <coordinates/Coordinates/FrequencyAligner.h>
 
 #include <lattices/Lattices/LatticeUtilities.h>
@@ -108 +108 @@
 
 
-SDMemTable* SDMath::velocityAlignment (const SDMemTable& in, const String& refTime) const
-{
-
-// Get velocity/frame info from Table
+SDMemTable* SDMath::frequencyAlignment (const SDMemTable& in, const String& refTime) const
+{
+
+// Get frame info from Table
 
    std::vector<std::string> info = in.getCoordInfo();
 
-// Parse unit ("" means channels)
-
-   String velUnit(info[0]);
-   if (velUnit.length()==0) {
-      throw(AipsError("You have not set a velocity abcissa unit - use function set_unit"));
-   } else {
-      Unit velUnitU(velUnit);
-      if (velUnitU!=Unit(String("m/s"))) {
-         throw(AipsError("Specified abcissa unit is not consistent with km/s - use function set_unit"));
-      }
+// Parse frequency system
+
+   String systemStr(info[1]);
+   String baseSystemStr(info[3]);
+   if (baseSystemStr==systemStr) {
+      throw(AipsError("You have not set a frequency frame different from the initial - use function set_freqframe"));
    }
-
-// Parse doppler
-
-   String dopplerStr(info[2]);
-   String velSystemStr(info[1]);
-   String velBaseSystemStr(info[3]);
-   if (velBaseSystemStr==velSystemStr) {
-      throw(AipsError("You have not set a velocity frame different from the initial - use function set_freqframe"));
-   }
-
-// Parse frequency system
-
-   MFrequency::Types velSystem;
-   MFrequency::getType(velSystem, velSystemStr);
-   MDoppler::Types doppler;
-   MDoppler::getType(doppler, dopplerStr);
+//
+   MFrequency::Types freqSystem;
+   MFrequency::getType(freqSystem, systemStr);
 
 // Do it
 
-   return velocityAlign (in, velSystem, velUnit, doppler, refTime);
+   return frequencyAlign (in, freqSystem, refTime);
 }
 
@@ -152 +135 @@
 CountedPtr<SDMemTable> SDMath::average(const Block<CountedPtr<SDMemTable> >& in,
                                        const Vector<Bool>& mask, Bool scanAv,
-                                       const String& weightStr, Bool alignVelocity) const
+                                       const String& weightStr, Bool alignFreq) const
 //
 // Weighted averaging of spectra from one or more Tables.
@@ -256 +239 @@
   for (uInt iTab=0; iTab<nTables; iTab++) {
 
-// Should check that the frequency tables don't change if doing VelocityAlignment
+// Should check that the frequency tables don't change if doing FreqAlignment
 
 // Attach columns to Table
@@ -646 +629 @@
 {
    Bool doVel = False;
+   if (doVel) {
+      for (uInt j=0; j<in.nCoordinates(); ++j) {
+         SpectralCoordinate sC = in.getSpectralCoordinate(j);
+      }
+   } 
+
 
 // Interpolation method
@@ -1257 +1246 @@
 // 'private' functions
 
-SDMemTable* SDMath::velocityAlign (const SDMemTable& in,
-                                   MFrequency::Types velSystem,
-                                   const String& velUnit,
-                                   MDoppler::Types doppler,
+
+SDMemTable* SDMath::frequencyAlign (const SDMemTable& in,
+                                   MFrequency::Types freqSystem,
                                    const String& refTime) const
 {
@@ -1301 +1289 @@
       refEpoch = in.getEpoch(0);
    }
-   cerr << "Aligning at reference Epoch " << formatEpoch(refEpoch) << endl;
+   cerr << "Aligning at reference Epoch " << formatEpoch(refEpoch) << 
+           " in frame " << MFrequency::showType(freqSystem) << endl;
 
 // Get Reference Position
@@ -1312 +1301 @@
    const uInt nFreqIDs = fTab.length();
 
-// Create VelocityAligner Block. One VA for each possible
+// Create FrequencyAligner Block. One VA for each possible
 // source/freqID combination
 
-   PtrBlock<VelocityAligner<Float>* > vA(nFreqIDs*nSrcTab);
-   generateVelocityAligners (vA, in, nChan, nFreqIDs, nSrcTab, firstRow,
-                             velSystem, velUnit, doppler,  refPos, refEpoch);
+   PtrBlock<FrequencyAligner<Float>* > a(nFreqIDs*nSrcTab);
+   generateFrequencyAligners (a, in, nChan, nFreqIDs, nSrcTab, firstRow,
+                              freqSystem, refPos, refEpoch);
 
 // New output Table
@@ -1326 +1315 @@
 
    const IPosition polChanAxes(2, asap::PolAxis, asap::ChanAxis);
-   VelocityAligner<Float>::Method method = VelocityAligner<Float>::LINEAR;
+   FrequencyAligner<Float>::Method method = FrequencyAligner<Float>::LINEAR;
    Bool extrapolate=False;
    Bool useCachedAbcissa = False;
@@ -1333 +1322 @@
    Vector<Float> yOut;
    Vector<Bool> maskOut;
-   uInt ifIdx, vaIdx;
+   uInt ifIdx, faIdx;
 //
    for (uInt iRow=0; iRow<nRows; ++iRow) {
@@ -1358 +1347 @@
 // cerr << "values in = " << values(IPosition(4,0,0,0,0),IPosition(4,0,0,0,9)) << endl;
 
-// For each row, the Velocity abcissa will be the same regardless
+// For each row, the Frequency abcissa will be the same regardless
 // of polarization.  For all other axes (IF and BEAM) the abcissa
 // will change.  So we iterate through the data by pol-chan planes
@@ -1370 +1359 @@
      while (!itValuesPlane.pastEnd()) {
 
-// Find the IF index and then the VA PtrBlock index
+// Find the IF index and then the FA PtrBlock index
 
         const IPosition& pos = itValuesPlane.pos();
         ifIdx = pos(asap::IFAxis);
-        vaIdx = (srcIdx[iRow]*nFreqIDs) + freqID[ifIdx];
+        faIdx = (srcIdx[iRow]*nFreqIDs) + freqID[ifIdx];
 //
         VectorIterator<Float> itValuesVec(itValuesPlane.array(), 1); 
@@ -1382 +1371 @@
         useCachedAbcissa=False;
         while (!itValuesVec.pastEnd()) {     
-           ok = vA[vaIdx]->align (yOut, maskOut, itValuesVec.vector(),
+           ok = a[faIdx]->align (yOut, maskOut, itValuesVec.vector(),
                                   itMaskVec.vector(), epoch, useCachedAbcissa,
                                   method, extrapolate); 
@@ -1411 +1400 @@
    }
 
+
+// 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 
+// input frame
+
+   std::vector<string> info = pTabOut->getCoordInfo();
+   info[1] = MFrequency::showType(freqSystem);   // Conversion frame
+   info[3] = info[1];                            // Base frame
+   pTabOut->setCoordInfo(info);
+
 // Clean up PointerBlock
 
-  for (uInt i=0; i<vA.nelements(); i++) delete vA[i];
-//
-  pTabOut->resetCursor();
-  return pTabOut;
+   for (uInt i=0; i<a.nelements(); i++) delete a[i];
+//
+   return pTabOut;
 }
 
@@ -1780 +1814 @@
 
 
-void SDMath::generateVelocityAligners (PtrBlock<VelocityAligner<Float>* >& vA, 
+
+void SDMath::generateFrequencyAligners (PtrBlock<FrequencyAligner<Float>* >& a, 
                                        const SDMemTable& in, uInt nChan,
                                        uInt nFreqIDs, uInt nSrcTab, 
                                        const Vector<uInt>& firstRow,
-                                       MFrequency::Types velSystem,
-                                       const String& velUnit,
-                                       MDoppler::Types doppler,
+                                       MFrequency::Types system,
                                        const MPosition& refPos,
                                        const MEpoch& refEpoch) const
@@ -1795 +1828 @@
          MDirection refDir = in.getDirection(firstRow[iSrc]);
          uInt idx = (iSrc*nFreqIDs) + fqID;
-         vA[idx] = new VelocityAligner<Float>(sC, nChan, refEpoch, refDir, refPos,
-                                              velUnit, doppler, velSystem);
+         a[idx] = new FrequencyAligner<Float>(sC, nChan, refEpoch, refDir, refPos, system);
       }
    }
 }
 
+

trunk/src/SDMath.h

@@ -36 +36 @@
 #include <casa/aips.h>
 #include <casa/Utilities/CountedPtr.h>
-#include <coordinates/Coordinates/VelocityAligner.h>
+#include <coordinates/Coordinates/FrequencyAligner.h>
 
 #include "SDDefs.h"
@@ -44 +44 @@
 class casa::MPosition;
 template<class T> class casa::PtrBlock;
-//template<class T> class casa::VelocityAligner;
 
 
@@ -78 +77 @@
                                          casa::Bool scanAverage, 
                                          const casa::String& weightStr,
-                                         casa::Bool alignVelocity=casa::False) const;
+                                         casa::Bool align=casa::False) const;
 
 // Statistics. If row<0, all rows are done otherwise, just the 
@@ -106 +105 @@
                               const casa::String& method, casa::Bool doAll) const;
 
-// Velocity Alignment
-   SDMemTable* velocityAlignment (const SDMemTable& in, const casa::String& refTime) const;
+// Frequency Alignment
+   SDMemTable* frequencyAlignment (const SDMemTable& in, const casa::String& refTime) const;
 
 // Opacity correction
@@ -194 +193 @@
                              const casa::Vector<casa::String>& srcNames) const;
 
-// Generate velocity aligners
-   void generateVelocityAligners (casa::PtrBlock<casa::VelocityAligner<casa::Float>* >& vA,
-                                  const SDMemTable& in, casa::uInt nChan,
-                                  casa::uInt nFreqIDs, casa::uInt nSrcTab,
-                                  const casa::Vector<casa::uInt>& firstRow,
-                                  casa::MFrequency::Types velSystem,
-                                  const casa::String& velUnit,
-                                  casa::MDoppler::Types doppler,
-                                  const casa::MPosition& refPos,
-                                  const casa::MEpoch& refEpoch) const;
-
-// Align in Velocity
-   SDMemTable* velocityAlign (const SDMemTable& in,
-                              casa::MFrequency::Types velSystem,
-                              const casa::String& velUnit,
-                              casa::MDoppler::Types doppler,
+// Generate frequency aligners
+   void generateFrequencyAligners (casa::PtrBlock<casa::FrequencyAligner<casa::Float>* >& a,
+                                   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;
+
+// Align in Frequency
+   SDMemTable* frequencyAlign (const SDMemTable& in,
+                              casa::MFrequency::Types system,
                               const casa::String& timeRef) const;