Changeset 2593 for trunk/python

Timestamp:

07/09/12 16:54:10 (12 years ago)

Author:

Takeshi Nakazato

Message:

New Development: No

JIRA Issue: No

Ready for Test: Yes

Interface Changes: Yes/No

What Interface Changed: Please list interface changes

Test Programs: List test programs

Put in Release Notes: Yes/No

Module(s): Module Names change impacts.

Description: Describe your changes here...

New class asapgrid2 is defined. Difference from asapgrid class is
that input and output is a scantable instance, not a table name.

Location:

trunk/python

Files:

• __init__.py (modified) (1 diff)
• asapgrid.py (modified) (2 diffs)

trunk/python/__init__.py

@@ -52 +52 @@
 from opacity import skydip
 from opacity import model as opacity_model
-from asapgrid import asapgrid
+from asapgrid import asapgrid, asapgrid2
 #from plotter2 import plotter2
 from _asap import srctype

trunk/python/asapgrid.py

@@ -3 +3 @@
 from asap.scantable import scantable
 from asap.selector import selector
-from asap._asap import stgrid
+from asap._asap import stgrid, stgrid2
 import pylab as pl
 from logging import asaplog
@@ -224 +224 @@
         asaplog.post('DEBUG','asapgrid.plot')
         
+class asapgrid2:
+    """
+    The asapgrid class is defined to convolve data onto regular
+    spatial grid. Typical usage is as follows:
+
+       # create asapgrid instance with input scantable
+       s = scantable( 'testimage1.asap', average=False )
+       g = asapgrid( s )
+       # set IFNO if necessary
+       g.setIF( 0 )
+       # set POLNOs if necessary
+       g.setPolList( [0,1] )
+       # set SCANNOs if necessary
+       g.setScanList( [22,23,24] )
+       # define image with full specification
+       # you can skip some parameters (see help for defineImage)
+       g.defineImage( nx=12, ny=12, cellx='10arcsec', celly='10arcsec',
+                      center='J2000 10h10m10s -5d05m05s' )
+       # set convolution function
+       g.setFunc( func='sf', width=3 )
+       # enable min/max clipping
+       g.enableClip()
+       # or, disable min/max clipping
+       #g.disableClip()
+       # actual gridding
+       g.grid()
+       # get result as scantable
+       sg = g.getResult()
+    """
+    def __init__( self, scantab ):
+        """
+        Create asapgrid instance.
+
+        scantab -- input data as a scantable or a list of scantables
+                   to grid more than one data at once.  
+        """
+        self.outfile = None
+        self.ifno = None
+        self.gridder = stgrid2()
+        self.setData( scantab )
+
+    def setData( self, scantab ):
+        """
+        Set data to be processed.
+
+        scantab -- input data as a scantable or a list of scantables
+                   to grid more than one data at once.  
+        """
+        if isinstance( scantab, scantable ):
+            self.gridder._setin( scantab )
+        else:
+            self.gridder._setfiles( scantab )
+        self.scantab = scantab
+
+    def setIF( self, ifno ):
+        """
+        Set IFNO to be processed. Currently, asapgrid allows to process
+        only one IFNO for one gridding run even if the data contains
+        multiple IFs. If you didn't specify IFNO, default value, which
+        is IFNO in the first spectrum, will be processed.
+
+        ifno -- IFNO to be processed.
+        """
+        self.ifno = ifno
+        self.gridder._setif( self.ifno )
+
+    def setPolList( self, pollist ):
+        """
+        Set list of polarization components you want to process.
+        If not specified, all POLNOs will be processed.
+
+        pollist -- list of POLNOs.
+        """
+        self.gridder._setpollist( pollist )
+
+    def setScanList( self, scanlist ):
+        """
+        Set list of scans you want to process. If not specified, all
+        scans will be processed.
+
+        scanlist -- list of SCANNOs.
+        """
+        self.gridder._setscanlist( scanlist )
+
+    def defineImage( self, nx=-1, ny=-1, cellx='', celly='', center='' ):
+        """
+        Define spatial grid.
+
+        First two parameters, nx and ny, define number of pixels of
+        the grid. If which of those is not specified, it will be set
+        to the same value as the other. If none of them are specified,
+        it will be determined from map extent and cell size.
+
+        Next two parameters, cellx and celly, define size of pixel.
+        You should set those parameters as string, which is constructed
+        numerical value and unit, e.g. '0.5arcmin', or numerical value.
+        If those values are specified as numerical value, their units
+        will be assumed to 'arcsec'. If which of those is not specified,
+        it will be set to the same value as the other. If none of them
+        are specified, it will be determined from map extent and number
+        of pixels, or set to '1arcmin' if neither nx nor ny is set.
+
+        The last parameter, center, define the central coordinate of
+        the grid. You should specify its value as a string, like,
+
+           'J2000 05h08m50s -16d23m30s'
+
+        or 
+
+           'J2000 05:08:50 -16.23.30'
+
+        You can omit equinox when you specify center coordinate. In that
+        case, J2000 is assumed. If center is not specified, it will be
+        determined from the observed positions of input data.
+
+        nx -- number of pixels along x (R.A.) direction.
+        ny -- number of pixels along y (Dec.) direction.
+        cellx -- size of pixel in x (R.A.) direction.
+        celly -- size of pixel in y (Dec.) direction.
+        center -- central position of the grid.
+        """
+        if not isinstance( cellx, str ):
+            cellx = '%sarcsec'%(cellx)
+        if not isinstance( celly, str ):
+            celly = '%sarcsec'%(celly)
+        self.gridder._defineimage( nx, ny, cellx, celly, center )
+
+    def setFunc( self, func='box', width=-1 ):
+        """
+        Set convolution function. Possible options are 'box' (Box-car,
+        default), 'sf' (prolate spheroidal), and 'gauss' (Gaussian).
+        Width of convolution function can be set using width parameter.
+        By default (-1), width is automatically set depending on each
+        convolution function. Default values for width are:
+
+           'box': 1 pixel
+           'sf': 3 pixels
+           'gauss': 1 pixel (width is used as HWHM)
+
+        func -- Function type ('box', 'sf', 'gauss').
+        width -- Width of convolution function. Default (-1) is to
+                 choose pre-defined value for each convolution function.
+        """
+        self.gridder._setfunc( func, width )
+
+    def setWeight( self, weightType='uniform' ):
+        """
+        Set weight type. Possible options are 'uniform' (default),
+        'tint' (weight by integration time), 'tsys' (weight by
+        Tsys: 1/Tsys**2), and 'tintsys' (weight by integration time
+        as well as Tsys: tint/Tsys**2).
+
+        weightType -- weight type ('uniform', 'tint', 'tsys', 'tintsys')
+        """
+        self.gridder._setweight( weightType )
+
+    def enableClip( self ):
+        """
+        Enable min/max clipping.
+
+        By default, min/max clipping is disabled so that you should
+        call this method before actual gridding if you want to do
+        clipping.
+        """
+        self.gridder._enableclip()
+
+    def disableClip( self ):
+        """
+        Disable min/max clipping.
+        """
+        self.gridder._disableclip()
+
+    def grid( self ):
+        """
+        Actual gridding which will be done based on several user inputs. 
+        """
+        self.gridder._grid()
+
+    def getResult( self ):
+        """
+        Return gridded data as a scantable.
+        """
+        return scantable( self.gridder._get(), average=False )
+
 class _SDGridPlotter:
     def __init__( self, infile, outfile=None, ifno=-1 ):