Changeset 2593

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

Files:

• python/__init__.py (modified) (1 diff)
• python/asapgrid.py (modified) (2 diffs)
• src/STGrid.cpp (modified) (6 diffs)
• src/STGrid.h (modified) (4 diffs)
• src/python_STGrid.cpp (modified) (3 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 ):

trunk/src/STGrid.cpp

@@ -1185 +1185 @@
 }
 
+void STGrid::table( Table &tab, uInt i )
+{
+  if ( i >= 0 && i < nfile_ )
+    tab = Table( infileList_[i] ) ;
+}
+
 void STGrid::selectData()
 {
@@ -1191 +1197 @@
   tableList_.resize( nfile_ ) ;
   if ( ifno_ == -1 ) {
-    Table taborg( infileList_[0] ) ;
+    //Table taborg( infileList_[0] ) ;
+    Table taborg ;
+    table( taborg, 0 ) ;
     ROScalarColumn<uInt> ifnoCol( taborg, "IFNO" ) ;
     ifno_ = ifnoCol( 0 ) ;
@@ -1198 +1206 @@
   }
   for ( uInt i = 0 ; i < nfile_ ; i++ ) {
-    Table taborg( infileList_[i] ) ;
+    //Table taborg( infileList_[i] ) ;
+    Table taborg ;
+    table( taborg, i ) ;
     TableExprNode node ;
     if ( ifno != -1 || isMultiIF( taborg ) ) {
@@ -1639 +1649 @@
   Table tab ;
   prepareTable( tab, outfile_ ) ;
+  fillTable( tab ) ;
+
+  t1 = mathutil::gettimeofday_sec() ;
+  os << LogIO::DEBUGGING << "saveData: elapsed time is " << t1-t0 << " sec." << LogIO::POST ; 
+
+  return outfile_ ;
+}
+
+void STGrid::prepareTable( Table &tab, String &name ) 
+{
+  Table t( infileList_[0], Table::Old ) ;
+  t.deepCopy( name, Table::New, False, t.endianFormat(), True ) ;
+  tab = Table( name, Table::Update ) ;
+  // 2012/02/13 TN
+  // explicitly copy subtables since no rows including subtables are 
+  // copied by Table::deepCopy with noRows=True
+  TableCopy::copySubTables( tab, t ) ;
+}
+
+void STGrid::fillTable( Table &tab )
+{
   IPosition dshape = data_.shape() ;
   Int nrow = nx_ * ny_ * npol_ ;
@@ -1687 +1718 @@
   data_.freeStorage( data_p, bdata ) ;
 
-  t1 = mathutil::gettimeofday_sec() ;
-  os << LogIO::DEBUGGING << "saveData: elapsed time is " << t1-t0 << " sec." << LogIO::POST ; 
-
   fillMainColumns( tab ) ;
-
-  return outfile_ ;
-}
-
-void STGrid::prepareTable( Table &tab, String &name ) 
-{
-  Table t( infileList_[0], Table::Old ) ;
-  t.deepCopy( name, Table::New, False, t.endianFormat(), True ) ;
-  tab = Table( name, Table::Update ) ;
-  // 2012/02/13 TN
-  // explicitly copy subtables since no rows including subtables are 
-  // copied by Table::deepCopy with noRows=True
-  TableCopy::copySubTables( tab, t ) ;
 }
 
@@ -1779 +1794 @@
 }
 
-}
+// STGrid2
+STGrid2::STGrid2()
+  : STGrid()
+{
+}
+
+STGrid2::STGrid2( const ScantableWrapper &s )
+  : STGrid()
+{
+  setScantable( s ) ;
+}
+
+STGrid2::STGrid2( const vector<ScantableWrapper> &v )
+  : STGrid()
+{
+  setScantableList( v ) ;
+}
+
+void STGrid2::setScantable( const ScantableWrapper &s )
+{
+  nfile_ = 1 ;
+  dataList_.resize( nfile_ ) ;
+  dataList_[0] = s ;
+  infileList_.resize( nfile_ ) ;
+  infileList_[0] = s.getCP()->table().tableName() ;
+}
+
+void STGrid2::setScantableList( const vector<ScantableWrapper> &v )
+{
+  nfile_ = v.size() ;
+  dataList_.resize( nfile_ ) ;
+  infileList_.resize( nfile_ ) ;
+  for ( uInt i = 0 ; i < nfile_ ; i++ ) {
+    dataList_[i] = v[i] ;
+    infileList_[i] = v[i].getCP()->table().tableName() ;
+  }
+}
+
+ScantableWrapper STGrid2::getResultAsScantable()
+{
+  CountedPtr<Scantable> s = new Scantable( Table::Plain ) ;
+  s->setHeader( dataList_[0].getCP()->getHeader() ) ;
+  Table tout, tin ;
+  String subt[] = { "FREQUENCIES", "FOCUS", "WEATHER", 
+                    "TCAL", "MOLECULES", "HISTORY", "FIT" } ;
+  for ( uInt i = 0 ; i < 7 ; i++ ) {
+    tout = s->table().rwKeywordSet().asTable(subt[i]) ;
+    tin = dataList_[0].getCP()->table().rwKeywordSet().asTable(subt[i]) ;
+    TableCopy::copyRows( tout, tin ) ;
+  }
+  fillTable( s->table() ) ;
+  ScantableWrapper sw( s ) ;
+  return sw ;
+}
+
+void STGrid2::table( Table &tab, uInt i ) 
+{
+  if ( i < nfile_ )
+    tab = dataList_[i].getCP()->table() ;
+}
+
+}

trunk/src/STGrid.h

@@ -27 +27 @@
 #include <tables/Tables/ArrayColumn.h>
 
+#include "ScantableWrapper.h"
+#include "Scantable.h"
 #include "concurrent.h"
 
@@ -67 +69 @@
   string saveData( string outfile="" ) ;
 
-private:
+//private:
+protected:
   void init() ;
 
@@ -196 +199 @@
   Bool isMultiIF( Table &tab ) ;
   void fillMainColumns( Table &tab ) ;
+  void fillTable( Table &tab ) ;
+  virtual void table( Table &tab, uInt i ) ;
   static bool produceChunk(void *ctx) throw(concurrent::PCException);
   static void consumeChunk(void *ctx) throw(concurrent::PCException);
@@ -257 +262 @@
   double eGGridSD_;
 };
+
+class STGrid2 : public STGrid
+{
+public:
+  STGrid2() ;
+  STGrid2( const ScantableWrapper &s ) ;
+  STGrid2( const vector<ScantableWrapper> &v ) ;
+  void setScantable( const ScantableWrapper &s ) ;
+  void setScantableList( const vector<ScantableWrapper> &v ) ;
+  void selectData() ;
+  virtual void table( Table &tab, uInt i ) ;
+  ScantableWrapper getResultAsScantable() ;
+
+private:
+  Block<ScantableWrapper> dataList_ ;
+};
 }
 #endif

trunk/src/python_STGrid.cpp

@@ -9 +9 @@
 
 #include "STGrid.h"
-//#include "STGridWrapper.h"
+#include "ScantableWrapper.h"
 
 using namespace boost::python;
@@ -17 +17 @@
 
 void python_STGrid() {
-  //class_<STGridWrapper>("stgrid")
   class_<STGrid>("stgrid")
     .def( init <> () )
@@ -35 +34 @@
     .def("_save", &STGrid::saveData)
     ;
+
+  class_<STGrid2>("stgrid2")
+    .def( init <> () )
+    .def( init < const ScantableWrapper & > () )
+    .def( init < const std::vector<ScantableWrapper> & > () )
+    .def("_setif", &STGrid2::setIF)
+    .def("_setpollist", &STGrid2::setPolList)
+    .def("_setscanlist", &STGrid2::setScanList)
+    .def("_defineimage", &STGrid2::defineImage)
+    .def("_setfunc", &STGrid2::setFunc)
+    .def("_grid", &STGrid2::grid)
+    .def("_setin", &STGrid2::setScantable)
+    .def("_setfiles", &STGrid2::setScantableList)
+    .def("_setweight", &STGrid2::setWeight)
+    .def("_enableclip", &STGrid2::enableClip) 
+    .def("_disableclip", &STGrid2::disableClip) 
+    .def("_get", &STGrid2::getResultAsScantable)
+    ;
+    
 };