Changeset 2435

Timestamp:

03/15/12 15:25:45 (12 years ago)

Author:

Kana Sugimoto

Message:

New Development: Yes

JIRA Issue: Yes (CAS-2818)

Ready for Test: Yes

Interface Changes: Yes

What Interface Changed: Added methods and functions
scantable.regrid_channel, scantable._regrid_specchan (defined in python_Scantable.cpp),
Scantable::regridSpecChannel, and ScantableWrapper::regridSpecChannel

Test Programs: comming soon with sdsmooth

Put in Release Notes: No

Module(s): scantable

Description:

Enabled regridding of spectra in a scantable.

scantable.regrid_channel(width, insitu=True/False?)

will do this.
width can be either in channel, frequency, or velocity unit.
verification is not available yet.

Location:

trunk

Files:

• python/scantable.py (modified) (1 diff)
• src/Scantable.cpp (modified) (1 diff)
• src/Scantable.h (modified) (1 diff)
• src/ScantableWrapper.h (modified) (1 diff)
• src/python_Scantable.cpp (modified) (1 diff)

trunk/python/scantable.py

@@ -2309 +2309 @@
 
     @asaplog_post_dec
+    def regrid_channel(self, width=5, plot=False, insitu=None):
+        """\
+        Regrid the spectra by the specified channel width
+
+        Parameters:
+
+            width:      The channel width (float) of regridded spectra
+                        in the current spectral unit.
+
+            plot:       [NOT IMPLEMENTED YET]
+                        plot the original and the regridded spectra.
+                        In this each indivual fit has to be approved, by
+                        typing 'y' or 'n'
+
+            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']
+        varlist = vars()
+
+        if plot:
+           asaplog.post()
+           asaplog.push("Verification plot is not implemtnetd yet.")
+           asaplog.post("WARN")
+
+        s = self.copy()
+        s._regrid_specchan(width)
+
+        s._add_history("regrid_channel", varlist)
+
+#         if plot:
+#             from asap.asapplotter import new_asaplot
+#             theplot = new_asaplot(rcParams['plotter.gui'])
+#             theplot.set_panels()
+#             ylab=s._get_ordinate_label()
+#             #theplot.palette(0,["#777777","red"])
+#             for r in xrange(s.nrow()):
+#                 xsm=s._getabcissa(r)
+#                 ysm=s._getspectrum(r)
+#                 xorg=orgscan._getabcissa(r)
+#                 yorg=orgscan._getspectrum(r)
+#                 theplot.clear()
+#                 theplot.hold()
+#                 theplot.set_axes('ylabel',ylab)
+#                 theplot.set_axes('xlabel',s._getabcissalabel(r))
+#                 theplot.set_axes('title',s._getsourcename(r))
+#                 theplot.set_line(label='Original',color="#777777")
+#                 theplot.plot(xorg,yorg)
+#                 theplot.set_line(label='Smoothed',color="red")
+#                 theplot.plot(xsm,ysm)
+#                 ### Ugly part for legend
+#                 for i in [0,1]:
+#                     theplot.subplots[0]['lines'].append(
+#                         [theplot.subplots[0]['axes'].lines[i]]
+#                         )
+#                 theplot.release()
+#                 ### Ugly part for legend
+#                 theplot.subplots[0]['lines']=[]
+#                 res = raw_input("Accept smoothing ([y]/n): ")
+#                 if res.upper() == 'N':
+#                     s._setspectrum(yorg, r)
+#             theplot.quit()
+#             del theplot
+#             del orgscan
+
+        if insitu: self._assign(s)
+        else: return s
+
+    @asaplog_post_dec
     def _parse_wn(self, wn):
         if isinstance(wn, list) or isinstance(wn, tuple):

trunk/src/Scantable.cpp

@@ -1885 +1885 @@
 }
 
+void asap::Scantable::regridSpecChannel( double dnu, int nChan )
+{
+  LogIO os( LogOrigin( "Scantable", "regridChannel()", WHERE ) ) ;
+  os << "Regrid abcissa with spectral resoultion " << dnu << " " << freqTable_.getUnitString() << " with channel number " << ((nChan>0)? String(nChan) : "covering band width")<< LogIO::POST ;
+  int freqnrow = freqTable_.table().nrow() ;
+  Vector<bool> firstTime( freqnrow, true ) ;
+  double oldincr, factor;
+  uInt currId;
+  Double refpix ;
+  Double refval ;
+  Double increment ;
+  for ( int irow = 0 ; irow < nrow() ; irow++ ) {
+    currId = mfreqidCol_(irow);
+    vector<double> abcissa = getAbcissa( irow ) ;
+    if (nChan < 0) {
+      int oldsize = abcissa.size() ;
+      double bw = (abcissa[oldsize-1]-abcissa[0]) +                     \
+        0.5 * (abcissa[1]-abcissa[0] + abcissa[oldsize-1]-abcissa[oldsize-2]) ;
+      nChan = int( ceil( abs(bw/dnu) ) ) ;
+    }
+    // actual regridding
+    regridChannel( nChan, dnu, irow ) ;
+
+    // update FREQUENCIES subtable
+    if (firstTime[currId]) {
+      oldincr = abcissa[1]-abcissa[0] ;
+      factor = dnu/oldincr ;
+      firstTime[currId] = false ;
+      freqTable_.getEntry( refpix, refval, increment, currId ) ;
+      /***
+       * need to shift refpix to 0
+       ***/
+      refval = refval - ( refpix + 0.5 * (1 - factor) ) * increment ;
+      refpix = 0 ;
+      freqTable_.setEntry( refpix, refval, increment*factor, currId ) ;
+      os << "ID" << currId << ": channel width (Orig) = " << oldincr << " [" << freqTable_.getUnitString() << "], scale factor = " << factor << LogIO::POST ;
+      os << "     frequency increment (Orig) = " << increment << "-> (New) " << increment*factor << LogIO::POST ;
+    }
+  }
+}
 
 void asap::Scantable::regridChannel( int nChan, double dnu )

trunk/src/Scantable.h

@@ -501 +501 @@
   void regridChannel( int nchan, double dnu ) ;
   void regridChannel( int nchan, double dnu, int irow ) ;
+
+  void regridSpecChannel( double dnu, int nchan=-1 ) ;
 
   bool getFlagtraFast(casa::uInt whichrow);

trunk/src/ScantableWrapper.h

@@ -268 +268 @@
   { table_->reshapeSpectrum( nmin, nmax ); }
 
+  void regridSpecChannel( double dnu, int nchan )
+  { table_->regridSpecChannel( dnu, nchan ); }
+
   void polyBaseline(const std::vector<bool>& mask, int order, bool getresidual=true, const std::string& showprogress="true,1000", const bool outlog=false, const std::string& blfile="")
   { table_->polyBaseline(mask, order, getresidual, showprogress, outlog, blfile); }

trunk/src/python_Scantable.cpp

@@ -145 +145 @@
          (boost::python::arg("nmin")=-1, 
           boost::python::arg("nmax")=-1) )
+    .def("_regrid_specchan", &ScantableWrapper::regridSpecChannel, 
+         (boost::python::arg("nchan")=-1) )
     .def("_poly_baseline", &ScantableWrapper::polyBaseline)
     .def("_auto_poly_baseline", &ScantableWrapper::autoPolyBaseline)