Changeset 1446 for branches/alma/python/scantable.py

Timestamp:

11/12/08 17:04:01 (16 years ago)

Author:

TakTsutsumi

Message:

Merged recent updates (since 2007) from nrao-asap

File:

• branches/alma/python/scantable.py (modified) (13 diffs)

branches/alma/python/scantable.py

@@ -300 +300 @@
         self._setselection(selection)
 
+    def get_row(self, row=0, insitu=None):
+        """
+        Select a row in the scantable.
+        Return a scantable with single row.
+        Parameters:
+            row: row no of integration, default is 0.
+            insitu: if False a new scantable is returned.
+                    Otherwise, the scaling is done in-situ
+                    The default is taken from .asaprc (False)
+        """
+        if insitu is None: insitu = rcParams['insitu']
+        if not insitu:
+            workscan = self.copy()
+        else:
+            workscan = self
+        # Select a row
+        sel=selector()
+        sel.set_scans([workscan.getscan(row)])
+        sel.set_cycles([workscan.getcycle(row)])
+        sel.set_beams([workscan.getbeam(row)])
+        sel.set_ifs([workscan.getif(row)])
+        sel.set_polarisations([workscan.getpol(row)])
+        sel.set_name(workscan._getsourcename(row))
+        workscan.set_selection(sel)
+        if not workscan.nrow() == 1:
+            msg = "Cloud not identify single row. %d rows selected."%(workscan.nrow())
+            raise RuntimeError(msg)
+        del sel
+        if insitu:
+            self._assign(workscan)
+        else:
+            return workscan
+
     def stats(self, stat='stddev', mask=None):
         """
@@ -528 +561 @@
         return self._get_column(self._getdirectionvec, row)
 
-
     def set_unit(self, unit='channel'):
         """
@@ -768 +800 @@
         return msk
 
-    def get_restfreqs(self):
+    def get_masklist(self, mask=None, row=0):
+        """
+        Compute and return a list of mask windows, [min, max].
+        Parameters:
+            mask:       channel mask, created with create_mask.
+            row:        calcutate the masklist using the specified row
+                        for unit conversions, default is row=0
+                        only necessary if frequency varies over rows.
+        Returns:
+            [min, max], [min2, max2], ...
+                Pairs of start/end points (inclusive)specifying
+                the masked regions
+        """
+        if not (isinstance(mask,list) or isinstance(mask, tuple)):
+            raise TypeError("The mask should be list or tuple.")
+        if len(mask) < 2:
+            raise TypeError("The mask elements should be > 1")
+        if self.nchan() != len(mask):
+            msg = "Number of channels in scantable != number of mask elements"
+            raise TypeError(msg)
+        data = self._getabcissa(row)
+        u = self._getcoordinfo()[0]
+        if rcParams['verbose']:
+            if u == "": u = "channel"
+            msg = "The current mask window unit is %s" % u
+            i = self._check_ifs()
+            if not i:
+                msg += "\nThis mask is only valid for IF=%d" % (self.getif(i))
+            asaplog.push(msg)
+        masklist=[]
+        ist, ien = None, None
+        ist, ien=self.get_mask_indices(mask)
+        if ist is not None and ien is not None:
+            for i in xrange(len(ist)):
+                range=[data[ist[i]],data[ien[i]]]
+                range.sort()
+                masklist.append([range[0],range[1]])
+        return masklist
+
+    def get_mask_indices(self, mask=None):
+        """
+        Compute and Return lists of mask start indices and mask end indices.
+         Parameters:
+            mask:       channel mask, created with create_mask.
+        Returns:
+            List of mask start indices and that of mask end indices,
+            i.e., [istart1,istart2,....], [iend1,iend2,....].
+        """
+        if not (isinstance(mask,list) or isinstance(mask, tuple)):
+            raise TypeError("The mask should be list or tuple.")
+        if len(mask) < 2:
+            raise TypeError("The mask elements should be > 1")
+        istart=[]
+        iend=[]
+        if mask[0]: istart.append(0)
+        for i in range(len(mask)-1):
+            if not mask[i] and mask[i+1]:
+                istart.append(i+1)
+            elif mask[i] and not mask[i+1]:
+                iend.append(i)
+        if mask[len(mask)-1]: iend.append(len(mask)-1)
+        if len(istart) != len(iend):
+            raise RuntimeError("Numbers of mask start != mask end.")
+        for i in range(len(istart)):
+            if istart[i] > iend[i]:
+                raise RuntimeError("Mask start index > mask end index")
+                break
+        return istart,iend
+
+#    def get_restfreqs(self):
+#        """
+#        Get the restfrequency(s) stored in this scantable.
+#        The return value(s) are always of unit 'Hz'
+#        Parameters:
+#            none
+#        Returns:
+#            a list of doubles
+#        """
+#        return list(self._getrestfreqs())
+
+    def get_restfreqs(self, ids=None):
         """
         Get the restfrequency(s) stored in this scantable.
         The return value(s) are always of unit 'Hz'
         Parameters:
-            none
+            ids: (optional) a list of MOLECULE_ID for that restfrequency(s) to
+                 be retrieved
         Returns:
-            a list of doubles
-        """
-        return list(self._getrestfreqs())
-
+            dictionary containing ids and a list of doubles for each id
+        """
+        if ids is None:
+            rfreqs={}
+            idlist = self.getmolnos()
+            for i in idlist:
+                rfreqs[i]=list(self._getrestfreqs(i))
+            return rfreqs
+        else:
+            if type(ids)==list or type(ids)==tuple:
+                rfreqs={}
+                for i in ids:
+                    rfreqs[i]=list(self._getrestfreqs(i))
+                return rfreqs
+            else:
+                return list(self._getrestfreqs(ids))
+            #return list(self._getrestfreqs(ids))
 
     def set_restfreqs(self, freqs=None, unit='Hz'):
         """
+        ********NEED TO BE UPDATED begin************
         Set or replace the restfrequency specified and
         If the 'freqs' argument holds a scalar,
@@ -793 +920 @@
         E.g. 'freqs=[1e9, 2e9]'  would mean IF 0 gets restfreq 1e9 and
         IF 1 gets restfreq 2e9.
+        ********NEED TO BE UPDATED end************
         You can also specify the frequencies via a linecatalog/
 
@@ -800 +928 @@
 
         Example:
-            # set the given restfrequency for the whole table
+            # set the given restfrequency for the all currently selected IFs
             scan.set_restfreqs(freqs=1.4e9)
-            # If thee number of IFs in the data is >= 2 IF0 gets the first
-            # value IF1 the second...
-            scan.set_restfreqs(freqs=[1.4e9, 1.67e9])
+            # set multiple restfrequencies to all the selected data
+            scan.set_restfreqs(freqs=[1.4e9, 1.41e9, 1.42e9])
+            # If the number of IFs in the data is >= 2 the IF0 gets the first
+            # value IF1 the second... NOTE that freqs needs to be
+            # specified in list of list (e.g. [[],[],...] ).
+            scan.set_restfreqs(freqs=[[1.4e9],[1.67e9]])
             #set the given restfrequency for the whole table (by name)
             scan.set_restfreqs(freqs="OH1667")
@@ -824 +955 @@
         # simple  value
         if isinstance(freqs, int) or isinstance(freqs, float):
-            self._setrestfreqs(freqs, "",unit)
+            # TT mod
+            #self._setrestfreqs(freqs, "",unit)
+            self._setrestfreqs([freqs], [""],unit)
         # list of values
         elif isinstance(freqs, list) or isinstance(freqs, tuple):
             # list values are scalars
             if isinstance(freqs[-1], int) or isinstance(freqs[-1], float):
+                self._setrestfreqs(freqs, [""],unit)
+            # list values are tuples, (value, name)
+            elif isinstance(freqs[-1], dict):
+                #sel = selector()
+                #savesel = self._getselection()
+                #iflist = self.getifnos()
+                #for i in xrange(len(freqs)):
+                #    sel.set_ifs(iflist[i])
+                #    self._setselection(sel)
+                #    self._setrestfreqs(freqs[i], "",unit)
+                #self._setselection(savesel)
+                self._setrestfreqs(freqs["value"],
+                                   freqs["name"], "MHz")
+            elif isinstance(freqs[-1], list) or isinstance(freqs[-1], tuple):
                 sel = selector()
                 savesel = self._getselection()
                 iflist = self.getifnos()
-                for i in xrange(len(freqs)):
-                    sel.set_ifs(iflist[i])
-                    self._setselection(sel)
-                    self._setrestfreqs(freqs[i], "",unit)
-                self._setselection(savesel)
-            # list values are tuples, (value, name)
-            elif isinstance(freqs[-1], dict):
-                sel = selector()
-                savesel = self._getselection()
-                iflist = self.getifnos()
+                if len(freqs)>len(iflist):
+                    raise ValueError("number of elements in list of list exeeds the current IF selections")
                 for i in xrange(len(freqs)):
                     sel.set_ifs(iflist[i])
@@ -852 +991 @@
             sel = selector()
             savesel = self._getselection()
-            iflist = self.getifnos()
             for i in xrange(freqs.nrow()):
                 sel.set_ifs(iflist[i])
@@ -1254 +1392 @@
             f = fitter()
             f.set_scan(self, mask)
-            #f.set_function(poly=order)
             if uselin:
                 f.set_function(lpoly=order)
@@ -1260 +1397 @@
                 f.set_function(poly=order)
             s = f.auto_fit(insitu, plot=plot)
+            # Save parameters of baseline fits as a class attribute.
+            # NOTICE: It does not reflect changes in scantable!
+            self.blpars = f.blpars
             s._add_history("poly_baseline", varlist)
             print_log()
@@ -1355 +1495 @@
 
         rows = range(workscan.nrow())
+        # Save parameters of baseline fits & masklists as a class attribute.
+        # NOTICE: It does not reflect changes in scantable!
+        if len(rows) > 0:
+            self.blpars=[]
+            self.masklists=[]
         asaplog.push("Processing:")
         for r in rows:
@@ -1371 +1516 @@
             # setup line finder
             fl.find_lines(r, mask, curedge)
+            outmask=fl.get_mask()
             f.set_scan(workscan, fl.get_mask())
             f.x = workscan._getabcissa(r)
@@ -1376 +1522 @@
             f.data = None
             f.fit()
-            x = f.get_parameters()
+            
+            # Show mask list
+            masklist=workscan.get_masklist(fl.get_mask(),row=r)
+            msg = "mask range: "+str(masklist)
+            asaplog.push(msg, False)
+
+            fpar = f.get_parameters()
             if plot:
                 f.plot(residual=True)
                 x = raw_input("Accept fit ( [y]/n ): ")
                 if x.upper() == 'N':
+                    self.blpars.append(None)
+                    self.masklists.append(None)
                     continue
             workscan._setspectrum(f.fitter.getresidual(), r)
+            self.blpars.append(fpar)
+            self.masklists.append(masklist)
         if plot:
             f._p.unmap()
@@ -1773 +1929 @@
         if unit is not None:
             self.set_fluxunit(unit)
-        self.set_freqframe(rcParams['scantable.freqframe'])
-
+        #self.set_freqframe(rcParams['scantable.freqframe'])
+