Changeset 800

Timestamp:

01/10/06 15:11:58 (19 years ago)

Author:

mar637

Message:

Request: added channel based flagging

Location:

branches/Release12

Files:

• python/__init__.py (modified) (2 diffs)
• python/scantable.py (modified) (3 diffs)
• src/SDMemTable.cc (modified) (2 diffs)
• src/SDMemTable.h (modified) (1 diff)
• src/SDMemTableWrapper.h (modified) (1 diff)
• src/python_SDMemTable.cc (modified) (1 diff)

branches/Release12/python/__init__.py

@@ -268 +268 @@
 
 __date__ = '$Date$'.split()[1]
-__version__  = '1.2.1'
+__version__  = '1.2.2a'
 
 if rcParams['verbose']:
@@ -318 +318 @@
             set_restfreqs   - set a list of rest frequencies
             lines           - print list of known spectral lines
-            flag_spectrum   - flag a whole Beam/IF/Pol
+            flag_spectrum   - flag spectral channels
             save            - save the scantable to disk as either 'ASAP'
                               or 'SDFITS'

branches/Release12/python/scantable.py

@@ -721 +721 @@
 
 
-    def flag_spectrum(self, thebeam, theif, thepol):
+    def flag_spectrum(self, flags, row=-1, allaxes=None):
         """
         This flags a selected spectrum in the scan 'for good'.
@@ -727 +727 @@
         Use masks for non-permanent exclusion of channels.
         Parameters:
-            thebeam,theif,thepol:    all have to be explicitly
-                                     specified
-        Example:
-            scan.flag_spectrum(0,0,1)
-            flags the spectrum for Beam=0, IF=0, Pol=1
-        """
-        if (thebeam < self.nbeam() and
-            theif < self.nif() and
-            thepol < self.npol()):
-            sdtable.setbeam(self, thebeam)
-            sdtable.setif(self, theif)
-            sdtable.setpol(self, thepol)
-            sdtable._flag(self)
-            self._add_history("flag_spectrum", vars())
-        else:
-            print "Please specify a valid (Beam/IF/Pol)"
+            flags:   a mask created with scantable.create_mask
+            row:     the number of the row (intergration) to flag,
+                     the deafult is -1, which is ALL rows.
+            allaxes: if True apply to all spectra. Otherwise
+                     apply only to the selected (beam/pol/if)spectra only
+                     The default is taken from .asaprc (True if none)
+        Example:
+            scan.flag_spectrum() # flags everything, not very useful
+            msk = scan.create_mask([511,513])
+            scan,set_cursor(IF=1)
+            scan.flag_spectrum(msk, allaxes=False)
+            # flags the central three channels for all rows in the table,
+            # using the selected IF only (e.g. a birdie)
+        """
+        if allaxes is None: allaxes = rcParams['scantable.allaxes']
+        if len(flags) != self.nchan():
+            msg  = "Length of mask invalid.",valid
+            if rcParams['verbose']:
+                print msg
+                return
+            else:
+                raise AssertionError(msg)
+        rows = range(self.nrow())
+        if row > -1: rows = [row]
+        for r in rows:
+            if allaxes:
+                beamSel,IFSel,polSel = (self.getbeam(),self.getif(),self.getpol())
+                for i in range(self.nbeam()):
+                    self.setbeam(i)
+                    for j in range(self.nif()):
+                        self.setif(j)
+                        for k in range(self.npol()):
+                            self.setpol(k)
+                            sdtable._flagspectrum(self, flags, r)
+                self.setbeam(beamSel)
+                self.setif(IFSel)
+                self.setpol(polSel)
+            else:
+                sdtable._flagspectrum(self, flags, r)
+        self._add_history("flag_spectrum", vars())
         return
 
@@ -840 +864 @@
                          Otherwise, the scaling is done in-situ
                          The default is taken from .asaprc (False)
-            allaxes:         if True apply to all spectra. Otherwise
+            allaxes:     if True apply to all spectra. Otherwise
                          apply only to the selected (beam/pol/if)spectra only
                          The default is taken from .asaprc (True if none)

branches/Release12/src/SDMemTable.cc

@@ -1622 +1622 @@
 }
 */
-void SDMemTable::flag(int whichRow)
+void SDMemTable::flagSpectrum(const std::vector<bool>& flags, int whichRow)
   {
   Array<uChar> arr;
   flagsCol_.get(whichRow, arr);
+
+  std::vector<bool>::const_iterator it = flags.begin();
+  if ( flags.size() != arr.shape()(asap::ChanAxis) )
+    throw(AipsError("Incorrect number of channels in flags"));
 
   ArrayAccessor<uChar, Axis<asap::BeamAxis> > aa0(arr);
@@ -1634 +1638 @@
   aa2.reset(aa2.begin(uInt(polSel_)));// go to pol
 
+  uChar userflag = 1 << 7; // user flag bit
   for (ArrayAccessor<uChar, Axis<asap::ChanAxis> > i(aa2); i != i.end(); ++i) {
-    (*i) = uChar(True);
+    if (*it)
+      (*i) |= userflag;
+    ++it;
   }
 

branches/Release12/src/SDMemTable.h

@@ -182 +182 @@
   virtual void resetCursor();
 
-  // Hard flags the current spectrum, not reversible
-  virtual void flag(int whichRow);
+  // Hard flags the current spectrum, (currently) not reversible
+  virtual void flagSpectrum(const std::vector<bool>& flags, int whichRow);
 
   // return the currently selected values

branches/Release12/src/SDMemTableWrapper.h

@@ -131 +131 @@
   }
 
-  void flag(int whichRow=-1) {
-    table_->flag(whichRow);
-  }
+  void flagSpectrum(const std::vector<bool>& flags, int whichRow=-1) {
+    table_->flagSpectrum(flags, whichRow);
+  }
+
   std::string getSourceName(int whichRow=0) {
     return table_->getSourceName(whichRow);

branches/Release12/src/python_SDMemTable.cc

@@ -101 +101 @@
     .def("_gettime", &SDMemTableWrapper::getTime,
          (boost::python::arg("whichRow")=0) )
-    .def("_flag", &SDMemTableWrapper::flag,
+    .def("_flagspectrum", &SDMemTableWrapper::flagSpectrum,
          (boost::python::arg("whichRow")=-1) )
     .def("_save",  &SDMemTableWrapper::makePersistent)