Changeset 881

Timestamp:

03/08/06 11:58:43 (19 years ago)

Author:

mar637

Message:

added linefinder

Location:

trunk/src

Files:

• SDLineFinder.cc (modified) (53 diffs)
• SDLineFinder.h (modified) (15 diffs)
• python_SDLineFinder.cc (modified) (3 diffs)
• python_asap.cpp (modified) (1 diff)
• python_asap.h (modified) (1 diff)

trunk/src/SDLineFinder.cc

@@ -1 +1 @@
 //#---------------------------------------------------------------------------
-//# SDLineFinder.cc: A class for automated spectral line search
+//# STLineFinder.cc: A class for automated spectral line search
 //#--------------------------------------------------------------------------
 //# Copyright (C) 2004
@@ -27 +27 @@
 //#                        AUSTRALIA
 //#
-//# $Id:
+//# $Id:$
 //#---------------------------------------------------------------------------
 
@@ -50 +50 @@
 ///////////////////////////////////////////////////////////////////////////////
 //
-// RunningBox -    a running box calculator. This class implements 
+// RunningBox -    a running box calculator. This class implements
 //                 interations over the specified spectrum and calculates
 //                 running box filter statistics.
@@ -57 +57 @@
 class RunningBox {
    // The input data to work with. Use reference symantics to avoid
-   // an unnecessary copying   
+   // an unnecessary copying
    const casa::Vector<casa::Float>  &spectrum; // a buffer for the spectrum
    const casa::Vector<casa::Bool>   &mask; // associated mask
    const std::pair<int,int>         &edge; // start and stop+1 channels
                                            // to work with
-   
+
    // statistics for running box filtering
    casa::Float sumf;       // sum of fluxes
@@ -69 +69 @@
    casa::Float sumch2;     // sum of squares of channel numbers (for linear fit)
    casa::Float sumfch;     // sum of flux*(channel number) (for linear fit)
-   
+
    int box_chan_cntr;     // actual number of channels in the box
    int max_box_nchan;     // maximum allowed number of channels in the box
@@ -90 +90 @@
                  const std::pair<int,int>         &in_edge,
                  int in_max_box_nchan) throw(AipsError);
-                 
+
    // access to the statistics
    const casa::Float& getLinMean() const throw(AipsError);
@@ -96 +96 @@
    const casa::Float aboveMean() const throw(AipsError);
    int getChannel() const throw();
-   
+
    // actual number of channels in the box (max_box_nchan, if no channels
    // are masked)
@@ -109 +109 @@
    // go to start
    void rewind() throw(AipsError);
- 
+
 protected:
    // supplementary function to control running mean calculations.
@@ -142 +142 @@
                                            // the detection criterion, to be
                                            // a detection
-   casa::Float threshold;                  // detection threshold - the 
+   casa::Float threshold;                  // detection threshold - the
                                            // minimal signal to noise ratio
    std::list<pair<int,int> > &lines;       // list where detections are saved
@@ -157 +157 @@
                     casa::Float in_threshold = 5) throw();
    virtual ~LFAboveThreshold() throw();
-   
+
    // replace the detection criterion
    void setCriterion(int in_min_nchan, casa::Float in_threshold) throw();
@@ -198 +198 @@
 ///////////////////////////////////////////////////////////////////////////////
 //
-// RunningBox -    a running box calculator. This class implements 
+// RunningBox -    a running box calculator. This class implements
 //                 interations over the specified spectrum and calculates
 //                 running box filter statistics.
@@ -227 +227 @@
         ++initial_box_ch)
        advanceRunningBox(initial_box_ch);
-  
-  if (initial_box_ch==edge.second)       
+
+  if (initial_box_ch==edge.second)
       throw AipsError("RunningBox::rewind - too much channels are masked");
 
   cur_channel=edge.first;
-  start_advance=initial_box_ch-max_box_nchan/2;  
+  start_advance=initial_box_ch-max_box_nchan/2;
 }
 
@@ -291 +291 @@
           --box_chan_cntr;
           sumf-=spectrum[ch2remove];
-          sumf2-=square(spectrum[ch2remove]);  
+          sumf2-=square(spectrum[ch2remove]);
           sumch-=Float(ch2remove);
           sumch2-=square(Float(ch2remove));
@@ -319 +319 @@
 {
   AlwaysAssert(box_chan_cntr, AipsError);
-  
+
   Float mean=sumf/Float(box_chan_cntr);
 
@@ -385 +385 @@
                cur_line.second=running_box->getChannel()+1;
            }
-       } else processCurLine(mask);   
+       } else processCurLine(mask);
   }
   catch (const AipsError &ae) {
       throw;
-  }  
+  }
   catch (const exception &ex) {
       throw AipsError(String("LFAboveThreshold::processChannel - STL error: ")+ex.what());
@@ -401 +401 @@
 {
   try {
-       if (is_detected_before) {                      
+       if (is_detected_before) {
            if (cur_line.second-cur_line.first>min_nchan) {
                // it was a detection. We need to change the list
                Bool add_new_line=False;
-               if (lines.size()) { 
+               if (lines.size()) {
                    for (int i=lines.back().second;i<cur_line.first;++i)
                         if (mask[i]) { // one valid channel in between
@@ -412 +412 @@
                             break;
                         }
-               } else add_new_line=True; 
-               if (add_new_line) 
+               } else add_new_line=True;
+               if (add_new_line)
                    lines.push_back(cur_line);
-               else lines.back().second=cur_line.second;                   
+               else lines.back().second=cur_line.second;
            }
            is_detected_before=False;
-       }      
+       }
   }
   catch (const AipsError &ae) {
       throw;
-  }  
+  }
   catch (const exception &ex) {
       throw AipsError(String("LFAboveThreshold::processCurLine - STL error: ")+ex.what());
@@ -450 +450 @@
       running_box=new RunningBox(spectrum,mask,edge,max_box_nchan);
 
-      
+
       // determine the off-line variance first
       // an assumption made: lines occupy a small part of the spectrum
-       
+
       std::vector<float> variances(edge.second-edge.first);
       DebugAssert(variances.size(),AipsError);
-      
-      for (;running_box->haveMore();running_box->next()) 
+
+      for (;running_box->haveMore();running_box->next())
            variances[running_box->getChannel()-edge.first]=
                                 running_box->getLinVariance();
-        
+
       // in the future we probably should do a proper Chi^2 estimation
       // now a simple 80% of smaller values will be used.
@@ -466 +466 @@
       // due to a bias of the Chi^2 distribution.
       stable_sort(variances.begin(),variances.end());
-      
+
       Float offline_variance=0;
-      uInt offline_cnt=uInt(0.8*variances.size());      
+      uInt offline_cnt=uInt(0.8*variances.size());
       if (!offline_cnt) offline_cnt=variances.size(); // no much else left,
                                     // although it is very inaccurate
-      for (uInt n=0;n<offline_cnt;++n) 
-           offline_variance+=variances[n];         
-      offline_variance/=Float(offline_cnt);        
-           
+      for (uInt n=0;n<offline_cnt;++n)
+           offline_variance+=variances[n];
+      offline_variance/=Float(offline_cnt);
+
       // actual search algorithm
       is_detected_before=False;
@@ -502 +502 @@
   catch (const AipsError &ae) {
       throw;
-  }  
+  }
   catch (const exception &ex) {
       throw AipsError(String("LFAboveThreshold::findLines - STL error: ")+ex.what());
@@ -583 +583 @@
   if (line2.second<line1.first) return false; // line2 is at lower channels
   if (line2.first>line1.second) return true; // line2 is at upper channels
-  
+
   // line2 intersects with line1. We should have no such situation in
   // practice
@@ -595 +595 @@
 ///////////////////////////////////////////////////////////////////////////////
 //
-// SDLineFinder  -  a class for automated spectral line search
-//
-//
-
-SDLineFinder::SDLineFinder() throw() : edge(0,0)
+// STLineFinder  -  a class for automated spectral line search
+//
+//
+
+STLineFinder::STLineFinder() throw() : edge(0,0)
 {
   setOptions();
@@ -614 +614 @@
 // in_avg_limit perform the averaging of no more than in_avg_limit
 //              adjacent channels to search for broad lines
-//              Default is 8, but for a bad baseline shape this 
+//              Default is 8, but for a bad baseline shape this
 //              parameter should be decreased (may be even down to a
 //              minimum of 1 to disable this option) to avoid
 //              confusing of baseline undulations with a real line.
-//              Setting a very large value doesn't usually provide 
-//              valid detections. 
+//              Setting a very large value doesn't usually provide
+//              valid detections.
 // in_box_size  the box size for running mean calculation. Default is
 //              1./5. of the whole spectrum size
-void SDLineFinder::setOptions(const casa::Float &in_threshold,
+void STLineFinder::setOptions(const casa::Float &in_threshold,
                               const casa::Int &in_min_nchan,
                               const casa::Int &in_avg_limit,
@@ -633 +633 @@
 }
 
-SDLineFinder::~SDLineFinder() throw(AipsError) {}
+STLineFinder::~STLineFinder() throw(AipsError) {}
 
 // set scan to work with (in_scan parameter), associated mask (in_mask
@@ -641 +641 @@
 //      channels to drop from both sides of the spectrum
 //   in_edge is introduced for convinience, although all functionality
-//   can be achieved using a spectrum mask only   
-void SDLineFinder::setScan(const SDMemTableWrapper &in_scan,
+//   can be achieved using a spectrum mask only
+void STLineFinder::setScan(const ScantableWrapper &in_scan,
                const std::vector<bool> &in_mask,
                const boost::python::tuple &in_edge) throw(AipsError)
@@ -651 +651 @@
 
        mask=in_mask;
-       if (mask.nelements()!=scan->nChan())
-           throw AipsError("SDLineFinder::setScan - in_scan and in_mask have different"
+       if (mask.nelements()!=scan->nchan())
+           throw AipsError("STLineFinder::setScan - in_scan and in_mask have different"
                            "number of spectral channels.");
 
@@ -658 +658 @@
        int n=extract<int>(in_edge.attr("__len__")());
        if (n>2 || n<0)
-           throw AipsError("SDLineFinder::setScan - the length of the in_edge parameter"
+           throw AipsError("STLineFinder::setScan - the length of the in_edge parameter"
                            "should not exceed 2");
        if (!n) {
-           // all spectrum, no rejection
+           // all spectra, no rejection
            edge.first=0;
-           edge.second=scan->nChan();
+           edge.second=scan->nchan();
        } else {
            edge.first=extract<int>(in_edge.attr("__getitem__")(0));
            if (edge.first<0)
-               throw AipsError("SDLineFinder::setScan - the in_edge parameter has a negative"
+               throw AipsError("STLineFinder::setScan - the in_edge parameter has a negative"
                                 "number of channels to drop");
-           if (edge.first>=scan->nChan())
-               throw AipsError("SDLineFinder::setScan - all channels are rejected by the in_edge parameter");
+           if (edge.first>=scan->nchan())
+               throw AipsError("STLineFinder::setScan - all channels are rejected by the in_edge parameter");
            if (n==2) {
                edge.second=extract<int>(in_edge.attr("__getitem__")(1));
                if (edge.second<0)
-                   throw AipsError("SDLineFinder::setScan - the in_edge parameter has a negative"
+                   throw AipsError("STLineFinder::setScan - the in_edge parameter has a negative"
                                    "number of channels to drop");
-               edge.second=scan->nChan()-edge.second;
-           } else edge.second=scan->nChan()-edge.first;
+               edge.second=scan->nchan()-edge.second;
+           } else edge.second=scan->nchan()-edge.first;
            if (edge.second<0 || (edge.first>=edge.second))
-               throw AipsError("SDLineFinder::setScan - all channels are rejected by the in_edge parameter");
-       }       
+               throw AipsError("STLineFinder::setScan - all channels are rejected by the in_edge parameter");
+       }
   }
   catch(const AipsError &ae) {
        // setScan is unsuccessfull, reset scan/mask/edge
-       scan=CountedConstPtr<SDMemTable>(); // null pointer
+       scan=CountedConstPtr<Scantable>(); // null pointer
        mask.resize(0);
        edge=pair<int,int>(0,0);
@@ -692 +692 @@
 
 // search for spectral lines. Number of lines found is returned
-int SDLineFinder::findLines(const casa::uInt &whichRow) throw(casa::AipsError)
-{ 
+int STLineFinder::findLines(const casa::uInt &whichRow) throw(casa::AipsError)
+{
   const int minboxnchan=4;
   if (scan.null())
-      throw AipsError("SDLineFinder::findLines - a scan should be set first,"
+      throw AipsError("STLineFinder::findLines - a scan should be set first,"
                       " use set_scan");
-  DebugAssert(mask.nelements()==scan->nChan(), AipsError);
-  int max_box_nchan=int(scan->nChan()*box_size); // number of channels in running
+  DebugAssert(mask.nelements()==scan->nchan(), AipsError);
+  int max_box_nchan=int(scan->nchan()*box_size); // number of channels in running
                                                  // box
   if (max_box_nchan<2)
-      throw AipsError("SDLineFinder::findLines - box_size is too small");
-
-  scan->getSpectrum(spectrum, whichRow);
+      throw AipsError("STLineFinder::findLines - box_size is too small");
+
+  spectrum.resize();
+  spectrum = Vector<Float>(scan->getSpectrum(whichRow));
 
   lines.resize(0); // search from the scratch
@@ -722 +723 @@
   while (true) {
      // a buffer for new lines found at this iteration
-     std::list<pair<int,int> > new_lines;     
+     std::list<pair<int,int> > new_lines;
 
      try {
@@ -745 +746 @@
          subtractBaseline(temp_mask,9);
          averageAdjacentChannels(temp_mask,avg_factor);
-         continue; 
+         continue;
      }
      keepStrongestOnly(temp_mask,new_lines,max_box_nchan);
@@ -751 +752 @@
      addNewSearchResult(new_lines,lines);
      // get a new mask
-     temp_mask=getMask();     
-  }
-  
+     temp_mask=getMask();
+  }
+
   // an additional search for wings because in the presence of very strong
   // lines temporary mean used at each iteration will be higher than
   // the true mean
-  
+
   if (lines.size())
       LFLineListOperations::searchForWings(lines,signs,mask,edge);
-      
+
   return int(lines.size());
 }
@@ -767 +768 @@
 // spectrum. It uses the SDFitter class. This action is required before
 // reducing the spectral resolution if the baseline shape is bad
-void SDLineFinder::subtractBaseline(const casa::Vector<casa::Bool> &temp_mask,
+void STLineFinder::subtractBaseline(const casa::Vector<casa::Bool> &temp_mask,
                       const casa::Int &order) throw(casa::AipsError)
 {
@@ -783 +784 @@
   sdf.setExpression("poly",order);
   if (!sdf.fit()) return; // fit failed, use old spectrum
-  spectrum=casa::Vector<casa::Float>(sdf.getResidual());    
+  spectrum=casa::Vector<casa::Float>(sdf.getResidual());
 }
 
@@ -792 +793 @@
 // array specified, rather than the field of this class
 // boxsize - a number of adjacent channels to average
-void SDLineFinder::averageAdjacentChannels(casa::Vector<casa::Bool> &mask2update,
+void STLineFinder::averageAdjacentChannels(casa::Vector<casa::Bool> &mask2update,
                                    const casa::Int &boxsize)
                             throw(casa::AipsError)
@@ -798 +799 @@
   DebugAssert(mask2update.nelements()==spectrum.nelements(), AipsError);
   DebugAssert(boxsize!=0,AipsError);
-  
+
   for (int n=edge.first;n<edge.second;n+=boxsize) {
        DebugAssert(n<spectrum.nelements(),AipsError);
@@ -807 +808 @@
                 mean+=spectrum[k];
                 ++nboxch;
-            }      
+            }
        if (nboxch<boxsize) // mask these channels
            for (int k=n;k<n+boxsize && k<edge.second;++k)
@@ -825 +826 @@
 //       in setScan) or dropped out by the edge parameter (in_edge
 //       in setScan) are still excluded regardless on the invert option
-std::vector<bool> SDLineFinder::getMask(bool invert)
+std::vector<bool> STLineFinder::getMask(bool invert)
                                         const throw(casa::AipsError)
 {
   try {
        if (scan.null())
-           throw AipsError("SDLineFinder::getMask - a scan should be set first,"
+           throw AipsError("STLineFinder::getMask - a scan should be set first,"
                       " use set_scan followed by find_lines");
-       DebugAssert(mask.nelements()==scan->nChan(), AipsError);
+       DebugAssert(mask.nelements()==scan->nchan(), AipsError);
        /*
        if (!lines.size())
-           throw AipsError("SDLineFinder::getMask - one have to search for "
+           throw AipsError("STLineFinder::getMask - one have to search for "
                            "lines first, use find_lines");
-       */                          
+       */
        std::vector<bool> res_mask(mask.nelements());
        // iterator through lines
        std::list<std::pair<int,int> >::const_iterator cli=lines.begin();
-       for (int ch=0;ch<res_mask.size();++ch) 
+       for (int ch=0;ch<res_mask.size();++ch)
             if (ch<edge.first || ch>=edge.second) res_mask[ch]=false;
             else if (!mask[ch]) res_mask[ch]=false;
-            else {            
+            else {
                     res_mask[ch]=!invert; // no line by default
                     if (cli==lines.end()) continue;
@@ -852 +853 @@
                         ++cli; // next line in the list
                  }
-       
+
        return res_mask;
   }
   catch (const AipsError &ae) {
       throw;
-  }  
+  }
   catch (const exception &ex) {
-      throw AipsError(String("SDLineFinder::getMask - STL error: ")+ex.what());
+      throw AipsError(String("STLineFinder::getMask - STL error: ")+ex.what());
   }
 }
@@ -865 +866 @@
 // get range for all lines found. The same units as used in the scan
 // will be returned (e.g. velocity instead of channels).
-std::vector<double> SDLineFinder::getLineRanges()
+std::vector<double> STLineFinder::getLineRanges()
                              const throw(casa::AipsError)
 {
@@ -877 +878 @@
   for (;cri!=ranges.end() && outi!=res.end();++cri,++outi)
        if (uInt(*cri)>=vel.size())
-          throw AipsError("SDLineFinder::getLineRanges - getAbcissa provided less channels than reqired");
+          throw AipsError("STLineFinder::getLineRanges - getAbcissa provided less channels than reqired");
        else *outi=vel[*cri];
   return res;
@@ -884 +885 @@
 // The same as getLineRanges, but channels are always used to specify
 // the range
-std::vector<int> SDLineFinder::getLineRangesInChannels()
+std::vector<int> STLineFinder::getLineRangesInChannels()
                                    const throw(casa::AipsError)
 {
   try {
        if (scan.null())
-           throw AipsError("SDLineFinder::getLineRangesInChannels - a scan should be set first,"
+           throw AipsError("STLineFinder::getLineRangesInChannels - a scan should be set first,"
                       " use set_scan followed by find_lines");
-       DebugAssert(mask.nelements()==scan->nChan(), AipsError);
-       
+       DebugAssert(mask.nelements()==scan->nchan(), AipsError);
+
        if (!lines.size())
-           throw AipsError("SDLineFinder::getLineRangesInChannels - one have to search for "
+           throw AipsError("STLineFinder::getLineRangesInChannels - one have to search for "
                            "lines first, use find_lines");
-                           
+
        std::vector<int> res(2*lines.size());
        // iterator through lines & result
        std::list<std::pair<int,int> >::const_iterator cli=lines.begin();
        std::vector<int>::iterator ri=res.begin();
-       for (;cli!=lines.end() && ri!=res.end();++cli,++ri) {            
+       for (;cli!=lines.end() && ri!=res.end();++cli,++ri) {
             *ri=cli->first;
-            if (++ri!=res.end()) 
-                *ri=cli->second-1;          
-       }       
+            if (++ri!=res.end())
+                *ri=cli->second-1;
+       }
        return res;
   }
   catch (const AipsError &ae) {
       throw;
-  }  
+  }
   catch (const exception &ex) {
-      throw AipsError(String("SDLineFinder::getLineRanges - STL error: ")+ex.what());
+      throw AipsError(String("STLineFinder::getLineRanges - STL error: ")+ex.what());
   }
 }
@@ -920 +921 @@
 // an auxiliary function to remove all lines from the list, except the
 // strongest one (by absolute value). If the lines removed are real,
-// they will be find again at the next iteration. This approach  
-// increases the number of iterations required, but is able to remove 
+// they will be find again at the next iteration. This approach
+// increases the number of iterations required, but is able to remove
 // the sidelobes likely to occur near strong lines.
 // Later a better criterion may be implemented, e.g.
 // taking into consideration the brightness of different lines. Now
-// use the simplest solution     
+// use the simplest solution
 // temp_mask - mask to work with (may be different from original mask as
 // the lines previously found may be masked)
@@ -931 +932 @@
 //                 nothing will be done if it is empty
 // max_box_nchan - channels in the running box for baseline filtering
-void SDLineFinder::keepStrongestOnly(const casa::Vector<casa::Bool> &temp_mask,
+void STLineFinder::keepStrongestOnly(const casa::Vector<casa::Bool> &temp_mask,
                   std::list<std::pair<int, int> > &lines2update,
                   int max_box_nchan)
@@ -952 +953 @@
 
            if (li==lines2update.end()) break; // no more lines
-           const int ch=running_box.getChannel();          
+           const int ch=running_box.getChannel();
            if (ch>=li->first && ch<li->second)
                if (temp_mask[ch] && tmp_flux<fabs(running_box.aboveMean()))
@@ -964 +965 @@
                tmp_flux=-1;
            }
-      }      
+      }
       std::list<std::pair<int,int> > res;
       res.splice(res.end(),lines2update,strongli);
@@ -972 +973 @@
   catch (const AipsError &ae) {
       throw;
-  }  
+  }
   catch (const exception &ex) {
-      throw AipsError(String("SDLineFinder::keepStrongestOnly - STL error: ")+ex.what());
+      throw AipsError(String("STLineFinder::keepStrongestOnly - STL error: ")+ex.what());
   }
 
@@ -992 +993 @@
 // be adjacent, they are joined into the new one
 void LFLineListOperations::addNewSearchResult(const std::list<pair<int, int> > &newlines,
-                         std::list<std::pair<int, int> > &lines_list) 
+                         std::list<std::pair<int, int> > &lines_list)
                         throw(AipsError)
 {
@@ -998 +999 @@
       for (std::list<pair<int,int> >::const_iterator cli=newlines.begin();
            cli!=newlines.end();++cli) {
-           
+
            // the first item, which has a non-void intersection or touches
            // the new line
            std::list<pair<int,int> >::iterator pos_beg=find_if(lines_list.begin(),
-                          lines_list.end(), IntersectsWith(*cli));           
-           // the last such item          
+                          lines_list.end(), IntersectsWith(*cli));
+           // the last such item
            std::list<pair<int,int> >::iterator pos_end=find_if(pos_beg,
                           lines_list.end(), not1(IntersectsWith(*cli)));
@@ -1014 +1015 @@
            lines_buffer.splice(lines_buffer.end(),lines_list, pos_beg, pos_end);
 
-           // build a union of all intersecting lines 
+           // build a union of all intersecting lines
            pair<int,int> union_line=for_each(lines_buffer.begin(),
                    lines_buffer.end(),BuildUnion(*cli)).result();
-           
+
            // search for a right place for the new line (union_line) and add
            std::list<pair<int,int> >::iterator pos2insert=find_if(lines_list.begin(),
@@ -1026 +1027 @@
   catch (const AipsError &ae) {
       throw;
-  }  
+  }
   catch (const exception &ex) {
       throw AipsError(String("LFLineListOperations::addNewSearchResult - STL error: ")+ex.what());
@@ -1050 +1051 @@
                 if (signs[n]==signs[li->first] && signs[li->first])
                     li->first=n;
-                else break;    
+                else break;
            }
            // update the right hand side
@@ -1057 +1058 @@
                 if (signs[n]==signs[li->second-1] && signs[li->second-1])
                     li->second=n;
-                else break;    
+                else break;
            }
       }
@@ -1068 +1069 @@
   catch (const AipsError &ae) {
       throw;
-  }  
+  }
   catch (const exception &ex) {
       throw AipsError(String("LFLineListOperations::extendLines - STL error: ")+ex.what());

trunk/src/SDLineFinder.h

@@ -1 +1 @@
 //#---------------------------------------------------------------------------
-//# SDLineFinder.h: A class for automated spectral line search
+//# STLineFinder.h: A class for automated spectral line search
 //#---------------------------------------------------------------------------
 //# Copyright (C) 2004
@@ -27 +27 @@
 //#                        AUSTRALIA
 //#
-//# $Id:
+//# $Id:$
 //#---------------------------------------------------------------------------
-#ifndef SDLINEFINDER_H
-#define SDLINEFINDER_H
+#ifndef STLINEFINDER_H
+#define STLINEFINDER_H
 
 // STL
@@ -49 +49 @@
 
 // ASAP
-#include "SDMemTableWrapper.h"
-#include "SDMemTable.h"
+#include "ScantableWrapper.h"
+#include "Scantable.h"
 
 namespace asap {
@@ -60 +60 @@
 //
 
-struct  LFLineListOperations {
+struct LFLineListOperations {
    // concatenate two lists preserving the order. If two lines appear to
-   // be adjacent or have a non-void intersection, they are joined into 
+   // be adjacent or have a non-void intersection, they are joined into
    // the new line
    static void addNewSearchResult(const std::list<std::pair<int, int> >
@@ -79 +79 @@
                            throw(casa::AipsError);
 protected:
-           
+
    // An auxiliary object function to test whether two lines have a non-void
    // intersection
@@ -105 +105 @@
         const std::pair<int,int>& result() const throw();
    };
-   
+
    // An auxiliary object function to test whether a specified line
    // is at lower spectral channels (to preserve the order in the line list)
@@ -117 +117 @@
         // in the ordered list (so, it is at greater channel numbers)
         bool operator()(const std::pair<int,int> &line2) const throw();
-   }; 
-   
-   
+   };
+
+
 };
 
@@ -127 +127 @@
 ///////////////////////////////////////////////////////////////////////////////
 //
-// SDLineFinder  -  a class for automated spectral line search
-//
-//
-
-struct SDLineFinder : protected LFLineListOperations {
-   SDLineFinder() throw();
-   virtual ~SDLineFinder() throw(casa::AipsError);
+// STLineFinder  -  a class for automated spectral line search
+//
+//
+
+struct STLineFinder : protected LFLineListOperations {
+   STLineFinder() throw();
+   virtual ~STLineFinder() throw(casa::AipsError);
 
    // set the parameters controlling algorithm
@@ -145 +145 @@
    // in_avg_limit perform the averaging of no more than in_avg_limit
    //              adjacent channels to search for broad lines
-   //              Default is 8, but for a bad baseline shape this 
+   //              Default is 8, but for a bad baseline shape this
    //              parameter should be decreased (may be even down to a
    //              minimum of 1 to disable this option) to avoid
    //              confusing of baseline undulations with a real line.
-   //              Setting a very large value doesn't usually provide 
-   //              valid detections. 
+   //              Setting a very large value doesn't usually provide
+   //              valid detections.
    // in_box_size  the box size for running mean calculation. Default is
    //              1./5. of the whole spectrum size
@@ -164 +164 @@
    //      channels to drop from both sides of the spectrum
    //   in_edge is introduced for convinience, although all functionality
-   //   can be achieved using a spectrum mask only   
-   void setScan(const SDMemTableWrapper &in_scan,
+   //   can be achieved using a spectrum mask only
+   void setScan(const ScantableWrapper &in_scan,
                 const std::vector<bool> &in_mask,
                 const boost::python::tuple &in_edge) throw(casa::AipsError);
@@ -171 +171 @@
    // search for spectral lines for a row specified by whichRow and
    // Beam/IF/Pol specified by current cursor set for the scantable
-   // Number of lines found is returned   
+   // Number of lines found is returned
    int findLines(const casa::uInt &whichRow = 0) throw(casa::AipsError);
 
@@ -182 +182 @@
 
    // get range for all lines found. The same units as used in the scan
-   // will be returned (e.g. velocity instead of channels).   
+   // will be returned (e.g. velocity instead of channels).
    std::vector<double>   getLineRanges() const throw(casa::AipsError);
    // The same as getLineRanges, but channels are always used to specify
@@ -203 +203 @@
    void subtractBaseline(const casa::Vector<casa::Bool> &temp_mask,
                          const casa::Int &order) throw(casa::AipsError);
-   
+
    // an auxiliary function to remove all lines from the list, except the
    // strongest one (by absolute value). If the lines removed are real,
-   // they will be find again at the next iteration. This approach  
-   // increases the number of iterations required, but is able to remove 
+   // they will be find again at the next iteration. This approach
+   // increases the number of iterations required, but is able to remove
    // the sidelobes likely to occur near strong lines.
    // Later a better criterion may be implemented, e.g.
    // taking into consideration the brightness of different lines. Now
-   // use the simplest solution     
+   // use the simplest solution
    // temp_mask - mask to work with (may be different from original mask as
    // the lines previously found may be masked)
@@ -222 +222 @@
                                       throw (casa::AipsError);
 private:
-   casa::CountedConstPtr<SDMemTable> scan; // the scan to work with
+   casa::CountedConstPtr<Scantable> scan; // the scan to work with
    casa::Vector<casa::Bool> mask;          // associated mask
    std::pair<int,int> edge;                // start and stop+1 channels
                                            // to work with
-   casa::Float threshold;                  // detection threshold - the 
+   casa::Float threshold;                  // detection threshold - the
                                            // minimal signal to noise ratio
    casa::Double box_size;                  // size of the box for running
@@ -251 +251 @@
 
 } // namespace asap
-#endif // #ifndef SDLINEFINDER_H
+#endif // #ifndef STLINEFINDER_H

trunk/src/python_SDLineFinder.cc

@@ -1 +1 @@
 //#---------------------------------------------------------------------------
-//# python_SDLineFinder.cc: python exposure of C++ SDLineFinder class
+//# python_STLineFinder.cc: python exposure of C++ STLineFinder class
 //#---------------------------------------------------------------------------
 //# Copyright (C) 2004
@@ -27 +27 @@
 //#                        AUSTRALIA
 //#
-//# $Id:
+//# $Id:$
 //#---------------------------------------------------------------------------
 #include <boost/python.hpp>
@@ -37 +37 @@
 namespace asap {
   namespace python {
-     void python_SDLineFinder() {
-       class_<SDLineFinder>("linefinder")
+     void python_STLineFinder() {
+       class_<STLineFinder>("linefinder")
          .def( init <> () )
-         .def("setoptions",&SDLineFinder::setOptions)
-         .def("setscan",&SDLineFinder::setScan)
-         .def("findlines",&SDLineFinder::findLines)
-         .def("getmask",&SDLineFinder::getMask)
-         .def("getlineranges",&SDLineFinder::getLineRanges)
-         .def("getlinerangesinchannels",&SDLineFinder::getLineRangesInChannels)
+         .def("setoptions",&STLineFinder::setOptions)
+         .def("setscan",&STLineFinder::setScan)
+         .def("findlines",&STLineFinder::findLines)
+         .def("getmask",&STLineFinder::getMask)
+         .def("getlineranges",&STLineFinder::getLineRanges)
+         .def("getlinerangesinchannels",&STLineFinder::getLineRangesInChannels)
        ;
      };

trunk/src/python_asap.cpp

@@ -61 +61 @@
   asap::python::python_STMath();
   asap::python::python_SDFitter();
+  asap::python::python_STLineFinder();
   /*
   asap::python::python_SDWriter();
   asap::python::python_SDFitTable();
-  asap::python::python_SDLineFinder();
   */
   asap::python::python_SDLog();

trunk/src/python_asap.h

@@ -42 +42 @@
     void python_STMath();
     void python_SDFitter();
+    void python_STLineFinder();
     /*
     void python_SDWriter();
-    void python_SDMath();
     void python_SDFitTable();
-    void python_SDLineFinder();
     */
     void python_SDLog();