Changeset 1192

Timestamp:

08/28/06 16:33:58 (18 years ago)

Author:

mar637

Message:

added lag_flag - flagging of frequencies in fft space

Location:

trunk

Files:

• python/__init__.py (modified) (1 diff)
• python/scantable.py (modified) (1 diff)
• src/STMath.cpp (modified) (2 diffs)
• src/STMath.h (modified) (1 diff)
• src/STMathWrapper.h (modified) (1 diff)
• src/python_STMath.cpp (modified) (1 diff)

trunk/python/__init__.py

@@ -409 +409 @@
             set_restfreqs   - set a list of rest frequencies
             flag            - flag selected channels in the data
+            lag_flag        - flag specified frequency in the data
             save            - save the scantable to disk as either 'ASAP',
                               'SDFITS' or 'ASCII'

trunk/python/scantable.py

@@ -639 +639 @@
             else: raise
         self._add_history("flag", varlist)
+
+    def lag_flag(self, frequency, unit="GHz", width=0, insitu=None):
+        """
+        Flag the data in 'lag' space by providing a frequency to remove.
+        Flagged data in the scantable gets set to 0.0 before the fft.
+        No taper is applied.
+        Parameters:
+            frequency:    the frequency to remove
+            unit:         the frequency unit ()default "GHz")
+            width:        the number of 'lag' channels to extent the frequency
+                          by, i.e. the interval
+                          [bandwidth/frequency-width, bandwidth/frequency+width]
+        """
+        if insitu is None: insitu = rcParams['insitu']
+        self._math._setinsitu(insitu)
+        varlist = vars()
+        base = { "GHz": 100000000., "MHz": 1000000., "kHz": 1000., "Hz": 1. }
+        if not base.has_key(unit):
+            raise ValueError("%s is not a valid unit." % unit)
+        try:
+            s = scantable(self._math._lag_flag(self, frequency*base[unit], width))
+        except RuntimeError, msg:
+            if rcParams['verbose']:
+                print msg
+                return
+            else: raise
+        s._add_history("lag_flag", varlist)
+        print_log()
+        if insitu:
+            self._assign(s)
+        else:
+            return s
 
 

trunk/src/STMath.cpp

@@ -31 +31 @@
 #include <tables/Tables/TableIter.h>
 #include <tables/Tables/TableCopy.h>
+#include <scimath/Mathematics/FFTServer.h>
 
 #include <lattices/Lattices/LatticeUtilities.h>
@@ -1377 +1378 @@
   return out;
 }
+
+CountedPtr< Scantable >
+  asap::STMath::lagFlag( const CountedPtr< Scantable > & in,
+                          double frequency, int width )
+{
+  CountedPtr< Scantable > out = getScantable(in, false);
+  Table& tout = out->table();
+  TableIterator iter(tout, "FREQ_ID");
+  FFTServer<Float,Complex> ffts;
+  while ( !iter.pastEnd() ) {
+    Table tab = iter.table();
+    Double rp,rv,inc;
+    ROTableRow row(tab);
+    const TableRecord& rec = row.get(0);
+    uInt freqid = rec.asuInt("FREQ_ID");
+    out->frequencies().getEntry(rp, rv, inc, freqid);
+    ArrayColumn<Float> specCol(tab, "SPECTRA");
+    ArrayColumn<uChar> flagCol(tab, "FLAGTRA");
+    for (int i=0; i<int(tab.nrow()); ++i) {
+      Vector<Float> spec = specCol(i);
+      Vector<uChar> flag = flagCol(i);
+      Int lag = Int(spec.nelements()*abs(inc)/frequency);
+      for (int k=0; k < flag.nelements(); ++k ) {
+        if (flag[k] > 0) {
+          spec[k] = 0.0;
+        }
+      }
+      Vector<Complex> lags;
+      ffts.fft(lags, spec);
+      Int start =  max(0, lag-width);
+      Int end =  min(Int(lags.nelements()-1), lag+width);
+      if (start == end) {
+        lags[start] = Complex(0.0);
+      } else {
+        for (int j=start; j <=end ;++j) {
+          lags[j] = Complex(0.0);
+        }
+      }
+      ffts.fft(spec, lags);
+      specCol.put(i, spec);
+    }
+    ++iter;
+  }
+  return out;
+}

trunk/src/STMath.h

@@ -184 +184 @@
                const std::string& srctype = "on");
 
+  /**
+   * "hard" flag the data, this flags everything selected in setSelection()
+   * @param frequency the frequency to remove
+   * @param width the number of lags to flag left to the side of the frequency
+   */
+  casa::CountedPtr<Scantable>
+    lagFlag( const casa::CountedPtr<Scantable>& in, double frequency,
+              int width);
+
 private:
   casa::CountedPtr<Scantable>  applyToPol( const casa::CountedPtr<Scantable>& in,

trunk/src/STMathWrapper.h

@@ -156 +156 @@
   { return ScantableWrapper(STMath::mxExtract(in.getCP(),scantype)); }
 
+  ScantableWrapper lagFlag( const ScantableWrapper& in,
+                            double frequency, int width )
+  { return ScantableWrapper(STMath::lagFlag(in.getCP(), frequency, width)); }
+
 };
 

trunk/src/python_STMath.cpp

@@ -67 +67 @@
         .def("_freq_align", &STMathWrapper::frequencyAlign)
         .def("_mx_extract", &STMathWrapper::mxExtract)
+        .def("_lag_flag", &STMathWrapper::lagFlag)
           ;
     };