Changeset 1579

Timestamp:

06/29/09 13:52:18 (15 years ago)

Author:

Malte Marquarding

Message:

Ticket #46; changed scnatable.lag_flag to handle a start/end value rather than a width. lag channels can also be specified directly by seeting the unit to

Location:

trunk

Files:

• python/scantable.py (modified) (3 diffs)
• src/STMath.cpp (modified) (2 diffs)

trunk/python/scantable.py

@@ -708 +708 @@
         self._add_history("flag", varlist)
 
-    def lag_flag(self, frequency, width=0.0, unit="GHz", insitu=None):
+    def lag_flag(self, start, end, unit="GHz", insitu=None):
         """
         Flag the data in 'lag' space by providing a frequency to remove.
@@ -714 +714 @@
         No taper is applied.
         Parameters:
-            frequency:    the frequency (really a period within the bandwidth) 
-                          to remove
-            width:        the width of the frequency to remove, to remove a 
-                          range of frequencies around the centre.
-            unit:         the frequency unit (default "GHz")
+            start:    the start frequency (really a period within the
+                      bandwidth)  or period to remove
+            end:      the end frequency or period to remove
+            unit:     the frequency unit (default "GHz") or "" for
+                      explicit lag channels
         Notes:
-            It is recommended to flag edges of the band or strong 
+            It is recommended to flag edges of the band or strong
             signals beforehand.
         """
@@ -726 +726 @@
         self._math._setinsitu(insitu)
         varlist = vars()
-        base = { "GHz": 1000000000., "MHz": 1000000., "kHz": 1000., "Hz": 1. }
-        if not base.has_key(unit):
+        base = { "GHz": 1000000000., "MHz": 1000000., "kHz": 1000., "Hz": 1.}
+        if not (unit == "" or 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*base[unit]))
+            if unit == "":
+                s = scantable(self._math._lag_flag(self, start, end, "lags"))
+            else:
+                s = scantable(self._math._lag_flag(self, start*base[unit],
+                                                   end*base[unit], "frequency"))
         except RuntimeError, msg:
             if rcParams['verbose']:

trunk/src/STMath.cpp

@@ -1962 +1962 @@
 CountedPtr< Scantable >
   asap::STMath::lagFlag( const CountedPtr< Scantable > & in,
-                          double frequency, double width )
+                         double start, double end,
+                         const std::string& mode)
 {
   CountedPtr< Scantable > out = getScantable(in, false);
@@ -1980 +1981 @@
       Vector<Float> spec = specCol(i);
       Vector<uChar> flag = flagCol(i);
-      Int lag0 = Int(spec.nelements()*abs(inc)/(frequency+width)+0.5);
-      Int lag1 = Int(spec.nelements()*abs(inc)/(frequency-width)+0.5);
+      int fstart = -1;
+      int fend = -1;
       for (int k=0; k < flag.nelements(); ++k ) {
         if (flag[k] > 0) {
-          spec[k] = 0.0;
+          fstart = k;
+          while (flag[k] > 0 && k < flag.nelements()) {
+            fend = k;
+            k++;
+          }
         }
+        Float interp = 0.0;
+        if (fstart-1 > 0 ) {
+          interp = spec[fstart-1];
+          if (fend+1 < spec.nelements()) {
+            interp = (interp+spec[fend+1])/2.0;
+          }
+        } else {
+          interp = spec[fend+1];
+        }
+        if (fstart > -1 && fend > -1) {
+          for (int j=fstart;j<=fend;++j) {
+            spec[j] = interp;
+          }
+        }
+        fstart =-1;
+        fend = -1;
       }
       Vector<Complex> lags;
       ffts.fft0(lags, spec);
-      Int start =  max(0, lag0);
-      Int end =  min(Int(lags.nelements()-1), lag1);
-      if (start == end) {
-        lags[start] = Complex(0.0);
+      Int lag0(start+0.5);
+      Int lag1(end+0.5);
+      if (mode == "frequency") {
+        lag0 = Int(spec.nelements()*abs(inc)/(start)+0.5);
+        lag1 = Int(spec.nelements()*abs(inc)/(end)+0.5);
+      }
+      Int lstart =  max(0, lag0);
+      Int lend =  min(Int(lags.nelements()-1), lag1);
+      if (lstart == lend) {
+        lags[lstart] = Complex(0.0);
       } else {
-        for (int j=start; j <=end ;++j) {
+        if (lstart > lend) {
+          Int tmp = lend;
+          lend = lstart;
+          lstart = tmp;
+        }
+        for (int j=lstart; j <=lend ;++j) {
           lags[j] = Complex(0.0);
         }