Changeset 880 for trunk

Timestamp:

03/08/06 11:57:12 (19 years ago)

Author:

mar637

Message:

added linefinder

Location:

trunk/python

Files:

• __init__.py (modified) (1 diff)
• asapfitter.py (modified) (2 diffs)
• asaplinefind.py (modified) (3 diffs)
• scantable.py (modified) (1 diff)

trunk/python/__init__.py

@@ -253 +253 @@
 
 from asapmath import *
-#from scantable import *
-#from asaplinefind import *
+from scantable import *
+from asaplinefind import *
 #from asapfit import *
 

trunk/python/asapfitter.py

@@ -452 +452 @@
         else:
             scan = self.data
-        rows = range(scan.nrow())
+        rows = xrange(scan.nrow())
         from asap import asaplog
         asaplog.push("Fitting:")
         for r in rows:
-            out = "Scan[%d] Beam[%d] IF[%d] Pol[%d] Cycle[%d]" %        (self.data.getscan(r),self.data.getbeam(r),self.data.getif(r),self.data.getpol(r), self.data.getcycle(r))
-            asaplog.push(out)
+            out = " Scan[%d] Beam[%d] IF[%d] Pol[%d] Cycle[%d]" %        (scan.getscan(r),scan.getbeam(r),scan.getif(r),scan.getpol(r), scan.getcycle(r))
+            asaplog.push(out, False)
             self.x = scan._getabcissa(r)
             self.y = scan._getspectrum(r)
@@ -463 +463 @@
             self.fit()
             x = self.get_parameters()
-            scan._setspectrum(self.fitter.getresidual(),iRow)
+            scan._setspectrum(self.fitter.getresidual(), r)
         print_log()
         return scan

trunk/python/asaplinefind.py

@@ -16 +16 @@
           print "No lines found!"
        sc2=sc.poly_baseline(fl.get_mask(),7)
-    
+
     The algorithm involves a simple threshold criterion. The line is
     considered to be detected if a specified number of consequtive
@@ -26 +26 @@
     lowest variances across the spectrum (i.e. histogram equalization is
     used to avoid missing weak lines if strong ones are present). For
-    bad baseline shapes it is reccommended to increase the threshold and 
+    bad baseline shapes it is recommended to increase the threshold and
     possibly switch the averaging option off (see set_options) to
     detect strong lines only, fit a high order baseline and repeat the line
-    search. 
+    search.
 
     """
 
     def __init__(self):
-        """
-        Create a line finder object.
-        """
-        self.finder = _asap.linefinder()
-        return
+        """
+        Create a line finder object.
+        """
+        self.finder = _asap.linefinder()
+        return
 
     def set_options(self,threshold=1.7320508075688772,min_nchan=3,
         avg_limit=8,box_size=0.2):
-        """
-        Set the parameters of the algorithm
-        Parameters:
-             threshold    a single channel S/N ratio above which the 
-                          channel is considered to be a detection
-                          Default is sqrt(3), which together with
-                          min_nchan=3 gives a 3-sigma criterion
-             min_nchan    a minimal number of consequtive channels, 
+        """
+        Set the parameters of the algorithm
+        Parameters:
+             threshold    a single channel S/N ratio above which the
+                          channel is considered to be a detection
+                          Default is sqrt(3), which together with
+                          min_nchan=3 gives a 3-sigma criterion
+             min_nchan    a minimal number of consequtive channels,
                           which should satisfy a threshold criterion to
-                          be a detection. Default is 3.
-             avg_limit    A number of consequtive channels not greater than
-                          this parameter can be averaged to search for
-                          broad lines. Default is 8.
-             box_size     A running mean box size specified as a fraction
+                          be a detection. Default is 3.
+             avg_limit    A number of consequtive channels not greater than
+                          this parameter can be averaged to search for
+                          broad lines. Default is 8.
+             box_size     A running mean box size specified as a fraction
                           of the total spectrum length. Default is 1/5
-        Note:  For bad baselines threshold should be increased, 
-               and avg_limit decreased (or even switched off completely by
-               setting this parameter to 1) to avoid detecting baseline
-               undulations instead of real lines.  
+        Note:  For bad baselines threshold should be increased,
+               and avg_limit decreased (or even switched off completely by
+               setting this parameter to 1) to avoid detecting baseline
+               undulations instead of real lines.
         """
         self.finder.setoptions(threshold,min_nchan,avg_limit,box_size)
-        return
-             
+        return
+
     def set_scan(self,scan,mask=None,edge=(0,0)):
-        """
-        Set the 'data' (scantable) to work with.
-        Parameters:
-             scan:    a scantable
-             mask:       an optional mask retreived from scantable
-             edge:       an optional number of channel to drop at
-                         the edge of spectrum. If only one value is
-                         specified, the same number will be dropped from
-                         both sides of the spectrum. Default is to keep
-                         all channels
         """
-        if not scan:
-           raise RuntimeError, 'Please give a correct scan'
- 
-        if isinstance(edge,int):
-           edge=(edge,)
+        Set the 'data' (scantable) to work with.
+        Parameters:
+             scan:    a scantable
+             mask:       an optional mask retreived from scantable
+             edge:       an optional number of channel to drop at
+                         the edge of spectrum. If only one value is
+                         specified, the same number will be dropped from
+                         both sides of the spectrum. Default is to keep
+                         all channels
+        """
+        if not scan:
+           raise RuntimeError, 'Please give a correct scan'
+        if not scan._check_ifs():
+                raise RuntimeError, 'IFs with different numbers of channels are not yet supported'
+
+        if isinstance(edge,int):
+           edge=(edge,)
 
         from asap import _is_sequence_or_number as _is_valid
@@ -89 +91 @@
            a pair of integers specified as a tuple"
 
-        if len(edge)>2:
-           raise RuntimeError, "The edge parameter should have two \
+        if len(edge)>2:
+           raise RuntimeError, "The edge parameter should have two \
            or less elements"
-        if mask is None:
-            from numarray import ones
-            self.finder.setscan(scan,ones(scan.nchan()),tuple(edge))
-        else:    
-            self.finder.setscan(scan,mask,tuple(edge))
-        return 
+        if mask is None:
+            from numarray import ones
+            self.finder.setscan(scan,ones(scan.nchan(-1)),tuple(edge))
+        else:
+            self.finder.setscan(scan,mask,tuple(edge))
+        return
     def find_lines(self,nRow=0):
-        """
-        Search for spectral lines in the scan assigned in set_scan.
-        Current Beam/IF/Pol is used, Row is specified by parameter
-        A number of lines found will be returned
-        """
-        return self.finder.findlines(nRow)
+        """
+        Search for spectral lines in the scan assigned in set_scan.
+        Current Beam/IF/Pol is used, Row is specified by parameter
+        A number of lines found will be returned
+        """
+        return self.finder.findlines(nRow)
     def get_mask(self,invert=False):
-        """
-        Get the mask to mask out all lines that have been found (default)
+        """
+        Get the mask to mask out all lines that have been found (default)
 
-        Parameters:
-              invert  if True, only channels belong to lines will be unmasked
+        Parameters:
+              invert  if True, only channels belong to lines will be unmasked
 
-        Note: all channels originally masked by the input mask or
-              dropped out by the edge parameter will still be excluded
-              regardless on the invert option
+        Note: all channels originally masked by the input mask or
+              dropped out by the edge parameter will still be excluded
+              regardless on the invert option
         """
-        return self.finder.getmask(invert)
+        return self.finder.getmask(invert)
     def get_ranges(self,defunits=True):
-        """
-        Get ranges (start and end channels or velocities) for all spectral
-        lines found. 
+        """
+        Get ranges (start and end channels or velocities) for all spectral
+        lines found.
 
-        Parameters:
-              defunits  if True (default), the range will use the same units
-                        as set for the scan (e.g. LSR velocity)
-                        if False, the range will be expressed in channels 
-        """
-        if (defunits):
-            return self.finder.getlineranges()
-        else:
-            return self.finder.getlinerangesinchannels()
+        Parameters:
+              defunits  if True (default), the range will use the same units
+                        as set for the scan (e.g. LSR velocity)
+                        if False, the range will be expressed in channels
+        """
+        if (defunits):
+            return self.finder.getlineranges()
+        else:
+            return self.finder.getlinerangesinchannels()

trunk/python/scantable.py

@@ -1020 +1020 @@
         else: return s
 
-#     def auto_poly_baseline(self, mask=None, edge=(0,0), order=0,
-#                            threshold=3, insitu=None):
-#         """
-#         Return a scan which has been baselined (all rows) by a polynomial.
-#         Spectral lines are detected first using linefinder and masked out
-#         to avoid them affecting the baseline solution.
-#
-#         Parameters:
-#             mask:       an optional mask retreived from scantable
-#             edge:       an optional number of channel to drop at
-#                         the edge of spectrum. If only one value is
-#                         specified, the same number will be dropped from
-#                         both sides of the spectrum. Default is to keep
-#                         all channels
-#             order:      the order of the polynomial (default is 0)
-#             threshold:  the threshold used by line finder. It is better to
-#                         keep it large as only strong lines affect the
-#                         baseline solution.
-#             insitu:     if False a new scantable is returned.
-#                         Otherwise, the scaling is done in-situ
-#                         The default is taken from .asaprc (False)
-#
-#         Example:
-#             scan2=scan.auto_poly_baseline(order=7)
-#         """
-#         if insitu is None: insitu = rcParams['insitu']
-#         varlist = vars()
-#         from asap.asapfitter import fitter
-#         from asap.asaplinefind import linefinder
-#         from asap import _is_sequence_or_number as _is_valid
-#
-#         if not _is_valid(edge, int):
-#             raise RuntimeError, "Parameter 'edge' has to be an integer or a \
-#             pair of integers specified as a tuple"
-#
-#         # setup fitter
-#         f = fitter()
-#         f.set_function(poly=order)
-#
-#         # setup line finder
-#         fl=linefinder()
-#         fl.set_options(threshold=threshold)
-#
-#         if not insitu:
-#             workscan=self.copy()
-#         else:
-#             workscan=self
-#
-#         rows=range(workscan.nrow())
-#         from asap import asaplog
-#         for i in rows:
-#             asaplog.push("Processing:")
-#             asaplog.push(msg)
-#             fl.set_scan(workscan,mask,edge)
-#             fl.find_lines(i)
-#             f.set_scan(workscan, fl.get_mask())
-#             f.x = workscan._getabcissa(i)
-#             f.y = workscan._getspectrum(i)
-#             f.data = None
-#             f.fit()
-#             x = f.get_parameters()
-#             workscan._setspectrum(f.fitter.getresidual(), i)
-#         workscan._add_history("poly_baseline", varlist)
-#         if insitu:
-#             self._assign(workscan)
-#         else:
-#             return workscan
-#
+    def auto_poly_baseline(self, mask=None, edge=(0,0), order=0,
+                           threshold=3, insitu=None):
+        """
+        Return a scan which has been baselined (all rows) by a polynomial.
+        Spectral lines are detected first using linefinder and masked out
+        to avoid them affecting the baseline solution.
+
+        Parameters:
+            mask:       an optional mask retreived from scantable
+            edge:       an optional number of channel to drop at
+                        the edge of spectrum. If only one value is
+                        specified, the same number will be dropped from
+                        both sides of the spectrum. Default is to keep
+                        all channels
+            order:      the order of the polynomial (default is 0)
+            threshold:  the threshold used by line finder. It is better to
+                        keep it large as only strong lines affect the
+                        baseline solution.
+            insitu:     if False a new scantable is returned.
+                        Otherwise, the scaling is done in-situ
+                        The default is taken from .asaprc (False)
+
+        Example:
+            scan2=scan.auto_poly_baseline(order=7)
+        """
+        if insitu is None: insitu = rcParams['insitu']
+        varlist = vars()
+        from asap.asapfitter import fitter
+        from asap.asaplinefind import linefinder
+        from asap import _is_sequence_or_number as _is_valid
+
+        if not _is_valid(edge, int):
+            raise RuntimeError, "Parameter 'edge' has to be an integer or a \
+            pair of integers specified as a tuple"
+
+        # setup fitter
+        f = fitter()
+        f.set_function(poly=order)
+
+        # setup line finder
+        fl=linefinder()
+        fl.set_options(threshold=threshold)
+
+        if not insitu:
+            workscan=self.copy()
+        else:
+            workscan=self
+
+        rows=range(workscan.nrow())
+        from asap import asaplog
+        asaplog.push("Processing:")
+        for r in rows:
+            msg = " Scan[%d] Beam[%d] IF[%d] Pol[%d] Cycle[%d]" %        (workscan.getscan(r),workscan.getbeam(r),workscan.getif(r),workscan.getpol(r), workscan.getcycle(r))
+            asaplog.push(msg, False)
+            fl.set_scan(workscan, mask, edge)
+            fl.find_lines(r)
+            f.set_scan(workscan, fl.get_mask())
+            f.x = workscan._getabcissa(r)
+            f.y = workscan._getspectrum(r)
+            f.data = None
+            f.fit()
+            x = f.get_parameters()
+            workscan._setspectrum(f.fitter.getresidual(), r)
+        workscan._add_history("poly_baseline", varlist)
+        if insitu:
+            self._assign(workscan)
+        else:
+            return workscan
+
 #     def rotate_linpolphase(self, angle):
 #         """