Changeset 872


Ignore:
Timestamp:
03/06/06 11:24:02 (19 years ago)
Author:
mar637
Message:

SDMemTable -> Scnatable handling (asap2)

Location:
trunk/src
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/STFillerWrapper.h

    r871 r872  
    11//#---------------------------------------------------------------------------
    2 //# SDReaderWrapper.h: Wrapper classes to use CountedPtr
     2//# STFillerWrapper.h: Wrapper classes to use CountedPtr
    33//#---------------------------------------------------------------------------
    44//# Copyright (C) 2004
    … …  
    2727//#                        AUSTRALIA
    2828//#
    29 //# $Id:
     29//# $Id:$
    3030//#---------------------------------------------------------------------------
    31 #ifndef SDREADERWRAPPER_H
    32 #define SDREADERWRAPPER_H
     31#ifndef STFILLERWRAPPER_H
     32#define STFILLERWRAPPER_H
    3333
    34 #include <vector>
    3534#include <string>
    3635
    37 #include "SDMemTableWrapper.h"
    38 #include "SDReader.h"
     36#include "ScantableWrapper.h"
     37#include "STFiller.h"
    3938
    4039namespace asap {
    4140
    42 class SDReaderWrapper : public SDReader {
     41class STFillerWrapper : public STFiller {
    4342public:
    44   SDReaderWrapper() {;}
    45   SDReaderWrapper(const std::string& filename, int ifSel=-1, int beamSel=-1) :
    46      SDReader(filename,ifSel,beamSel) {;}
    47   SDReaderWrapper(SDMemTableWrapper tbl) :
    48     SDReader(tbl.getCP()){;}
    49   SDMemTableWrapper getSDMemTable() const {
    50     return SDMemTableWrapper(getTable());
     43  STFillerWrapper() {;}
     44  STFillerWrapper(const std::string& filename, int ifSel=-1, int beamSel=-1) :
     45     STFiller(filename, ifSel, beamSel) {;}
     46  STFillerWrapper(ScantableWrapper tbl) :
     47    STFiller(tbl.getCP()){;}
     48  ScantableWrapper getScantable() const {
     49    return ScantableWrapper(getTable());
    5150  }
    5251};

  • trunk/src/STMathWrapper.h

    r871 r872  
    1 //#---------------------------------------------------------------------------
    2 //# SDMathWrapper.h: Wrapper classes to use CountedPtr
    3 //#---------------------------------------------------------------------------
    4 //# Copyright (C) 2004
    5 //# ATNF
    6 //#
    7 //# This program is free software; you can redistribute it and/or modify it
    8 //# under the terms of the GNU General Public License as published by the Free
    9 //# Software Foundation; either version 2 of the License, or (at your option)
    10 //# any later version.
    11 //#
    12 //# This program is distributed in the hope that it will be useful, but
    13 //# WITHOUT ANY WARRANTY; without even the implied warranty of
    14 //# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
    15 //# Public License for more details.
    16 //#
    17 //# You should have received a copy of the GNU General Public License along
    18 //# with this program; if not, write to the Free Software Foundation, Inc.,
    19 //# 675 Massachusetts Ave, Cambridge, MA 02139, USA.
    20 //#
    21 //# Correspondence concerning this software should be addressed as follows:
    22 //#        Internet email: Malte.Marquarding@csiro.au
    23 //#        Postal address: Malte Marquarding,
    24 //#                        Australia Telescope National Facility,
    25 //#                        P.O. Box 76,
    26 //#                        Epping, NSW, 2121,
    27 //#                        AUSTRALIA
    28 //#
    29 //# $Id:
    30 //#---------------------------------------------------------------------------
    31 #ifndef SDMATHWRAPPER_H
    32 #define SDMATHWRAPPER_H
     1//
     2// C++ Interface: STMathWrapper
     3//
     4// Description:
     5//
     6//
     7// Author: Malte Marquarding <Malte.Marquarding@csiro.au>, (C) 2006
     8//
     9// Copyright: See COPYING file that comes with this distribution
     10//
     11//
     12#ifndef ASAPSTMATHWRAPPER_H
     13#define ASAPSTMATHWRAPPER_H
    3314
    3415#include <vector>
    3516#include <string>
    3617
    37 #include <boost/python/tuple.hpp>
     18#include <casa/Utilities/CountedPtr.h>
    3819
    39 #include "SDMemTableWrapper.h"
    40 #include "SDMath.h"
     20#include "STMath.h"
     21#include "Scantable.h"
     22#include "ScantableWrapper.h"
    4123
    4224namespace asap {
    4325
    44 namespace SDMathWrapper {
     26/**
     27Wrapper class to handle ScantableWrapper
    4528
     29@author Malte Marquarding
     30*/
     31class STMathWrapper : public STMath {
     32public:
     33  STMathWrapper() {;}
     34  STMathWrapper(bool insitu) : STMath(insitu) {;}
    4635
    47   static SDMath sdmath;
    48   // Quotient
    49   SDMemTableWrapper quotient(const SDMemTableWrapper& on,
    50                              const SDMemTableWrapper& off,
    51                              casa::Bool preserveContinuum);
     36  virtual ~STMathWrapper() {;}
    5237
    53   // Simple binary operations
    54   SDMemTableWrapper binaryOperate(const SDMemTableWrapper& left,
    55                                   const SDMemTableWrapper& right,
    56                                   const std::string& op, bool doTSys);
    57  
    58   // Multiply
    59   void scaleInSitu(SDMemTableWrapper& in, float factor, bool doAll,
    60                    bool doTSys);
    61   SDMemTableWrapper scale(const SDMemTableWrapper& in, float factor,
    62                           bool all, bool doTSys);
    63  
    64   // Add
    65   void addInSitu(SDMemTableWrapper& in, float offset, bool doAall);
    66   SDMemTableWrapper add(const SDMemTableWrapper& in, float offset, bool all);
     38  ScantableWrapper
     39    average( const std::vector<ScantableWrapper>& in,
     40             const std::vector<bool>& mask,
     41             const std::string& weight,
     42             const std::string& avmode,
     43             bool alignfreq)
     44  {
     45    std::vector<casa::CountedPtr<Scantable> > sts;
     46    for (int i=0; i<in.size(); ++i) sts.push_back(in[i].getCP());
     47    return ScantableWrapper(STMath::average(sts, mask, weight, avmode, alignfreq));
     48  }
    6749
    68 // Smooth
    69   void smoothInSitu(SDMemTableWrapper& in, const std::string& kernel,
    70                      float width, bool doAll);
    71   SDMemTableWrapper smooth(const SDMemTableWrapper& in,
    72                            const std::string& kernel, float width, bool doAll);
     50  ScantableWrapper
     51    unaryOperate( const ScantableWrapper& in, float val,
     52                  const std::string& mode, bool tsys=false )
     53  { return ScantableWrapper(STMath::unaryOperate(in.getCP(), val, mode, tsys)); }
    7354
    74 // Bin up
    75   void binInSitu(SDMemTableWrapper& in, int width);
    76   SDMemTableWrapper bin(const SDMemTableWrapper& in, int width);
     55  ScantableWrapper quotient( const ScantableWrapper& in,
     56                             const std::string& mode = "NEAREST",
     57                             bool preserve = true )
     58  { return ScantableWrapper(STMath::quotient(in.getCP(), mode, preserve)); }
    7759
    78 // Resample
    79   void resampleInSitu(SDMemTableWrapper& in, const std::string& method,
    80                       float width);
    81   SDMemTableWrapper resample(const SDMemTableWrapper& in,
    82                              const std::string& method,
    83                              float width);
     60  ScantableWrapper
     61    freqSwitch( const ScantableWrapper& in )
     62  { return ScantableWrapper(STMath::freqSwitch(in.getCP())); }
    8463
    85 // Convert brightness between Jy and K
    86   void convertFluxInSitu(SDMemTableWrapper& in, float D, float eta,
    87                          float JyPerK, bool doAll);
    88   SDMemTableWrapper convertFlux(const SDMemTableWrapper& in, float D,
    89                                 float eta, float JyPerK, bool doAll);
     64  std::vector<float> statistic(const ScantableWrapper& in,
     65                               const std::vector<bool>& mask,
     66                               const std::string& which)
     67  { return STMath::statistic(in.getCP(), mask, which); }
    9068
    91 // Apply gain elevation correction
    92   void gainElevationInSitu (SDMemTableWrapper& in, const std::vector<float>& coeffs,
    93                             const std::string& fileName,
    94                             const std::string& method, bool doAll);
    95   SDMemTableWrapper gainElevation(const SDMemTableWrapper& in, const std::vector<float>& coeffs,
    96                                   const std::string& fileName,
    97                                   const std::string& method, bool doAll);
     69  ScantableWrapper bin( const ScantableWrapper& in, int width=5)
     70  { return ScantableWrapper(STMath::bin(in.getCP(), width)); }
    9871
    99 // Apply frequency alignment
    100   void frequencyAlignmentInSitu (SDMemTableWrapper& in, const std::string& refTime,
    101                                  const std::string& method, bool perFreqID);
    102   SDMemTableWrapper frequencyAlignment(const SDMemTableWrapper& in, const std::string& refTime,
    103                                        const std::string& method, bool perFreqID);
     72  ScantableWrapper
     73    resample(const ScantableWrapper& in,
     74             const std::string& method, float width)
     75  { return ScantableWrapper(STMath::resample(in.getCP(), method, width)); }
    10476
    105 // XY Phase rotation
    106   void rotateXYPhaseInSitu(SDMemTableWrapper& in, float angle, bool doAll);
     77  ScantableWrapper
     78    smooth(const ScantableWrapper& in, const std::string& kernel, float width)
     79  { return ScantableWrapper(STMath::smooth(in.getCP(), kernel, width)); }
    10780
    108 // LinPol Phase rotation
    109   void rotateLinPolPhaseInSitu(SDMemTableWrapper& in, float angle, bool doAll);
     81  ScantableWrapper
     82    gainElevation(const ScantableWrapper& in,
     83                  const std::vector<float>& coeff,
     84                  const std::string& filename,
     85                  const std::string& method)
    11086
    111 // Apply opacity correction
    112   void opacityInSitu(SDMemTableWrapper& in, float tau, bool doAll);
    113   SDMemTableWrapper opacity(const SDMemTableWrapper& in, float tau,
    114                             bool doAll);
     87  { return
     88      ScantableWrapper(STMath::gainElevation(in.getCP(), coeff, filename, method)); }
    11589
    116 // Average in time
    117   SDMemTableWrapper average(boost::python::tuple tpl,
    118                             const std::vector<bool>& mask,
    119                             bool scanAv, const std::string& wt);
     90  ScantableWrapper
     91    convertFlux(const ScantableWrapper& in, float d,
     92                float etaap, float jyperk)
     93  { return ScantableWrapper(STMath::convertFlux(in.getCP(), d, etaap, jyperk)); }
    12094
    121 // Average polarizations
    122   void averagePolInSitu(SDMemTableWrapper& in,  const std::vector<bool>& mask,
    123                         const std::string& weightStr);
    124   SDMemTableWrapper averagePol(const SDMemTableWrapper& in,
    125                                const std::vector<bool>& mask,
    126                                const std::string& weightStr);
     95  ScantableWrapper opacity(const ScantableWrapper& in,
     96                                      float tau)
     97  { return ScantableWrapper(STMath::opacity(in.getCP(), tau)); }
    12798
    128   // Frequency Switching
    129   void SDMathWrapper::frequencySwitchInSitu(SDMemTableWrapper& in);
     99  ScantableWrapper
     100    merge(const std::vector<ScantableWrapper >& in)
    130101
    131   SDMemTableWrapper
    132   SDMathWrapper::frequencySwitch(const SDMemTableWrapper& in);
    133 
    134   // Statistics
    135   std::vector<float> statistic(const SDMemTableWrapper& in,
    136                                const std::vector<bool>& mask,
    137                                const std::string& which, int row);
     102  {
     103    std::vector<casa::CountedPtr<Scantable> > sts;
     104    for (int i=0; i<in.size(); ++i) sts.push_back(in[i].getCP());
     105    return ScantableWrapper(STMath::merge(sts)); }
    138106
    139107};
    140108
    141 } // namespace
     109}
     110
    142111#endif

  • trunk/src/python_STFiller.cpp

    r871 r872  
    11//#---------------------------------------------------------------------------
    2 //# python_SDReader.cc: python exposure of c++ SDReader class
     2//# python_STFiller.cc: python exposure of c++ STFiller class
    33//#---------------------------------------------------------------------------
    44//# Copyright (C) 2004
    … …  
    3131#include <boost/python.hpp>
    3232
    33 #include "SDReaderWrapper.h"
     33#include "STFillerWrapper.h"
    3434
    3535using namespace boost::python;
    … …  
    3838  namespace python {
    3939
    40     void python_SDReader() {
    41       class_<SDReaderWrapper>("sdreader")
     40    void python_STFiller() {
     41      class_<STFillerWrapper>("stfiller")
    4242        .def( init < std::string, int, int > () )
    43         .def("_open", &SDReaderWrapper::open)
    44         .def("_read", &SDReaderWrapper::read)
    45         .def("_reset", &SDReaderWrapper::reset)
    46         .def("_getdata", &SDReaderWrapper::getSDMemTable)
    47         .def("_header",  &SDReaderWrapper::pseudoHeader)
     43        .def("_open", &STFillerWrapper::open)
     44        .def("_read", &STFillerWrapper::read)
     45        .def("_getdata", &STFillerWrapper::getScantable)
    4846      ;
    4947    };

  • trunk/src/python_STMath.cpp

    r871 r872  
    11//#---------------------------------------------------------------------------
    2 //# python_SDMath.cc: python exposure of c++ SDMath class
     2//# python_STMathWrapper.cc: python exposure of c++ STMath class
    33//#---------------------------------------------------------------------------
    44//# Copyright (C) 2004
    … …  
    2727//#                        AUSTRALIA
    2828//#
    29 //# $Id:
     29//# $Id:$
    3030//#---------------------------------------------------------------------------
     31#include <vector>
    3132#include <boost/python.hpp>
    32 #include <vector>
    3333
    34 #include <casa/aips.h>
    35 #include <casa/Containers/Block.h>
    36 #include <casa/Utilities/CountedPtr.cc>
     34#include "STMathWrapper.h"
    3735
    38 #include "SDMathWrapper.h"
    39 #include "SDMath.h"
    40 
    41 using namespace casa;
    4236using namespace boost::python;
    4337
    4438namespace asap {
    45   namespace SDMathWrapper {
    46     SDMemTableWrapper SDMathWrapper::average(boost::python::tuple tp,
    47                                              const std::vector<bool>& mask,
    48                                              bool scanAv,
    49                                              const std::string& weightStr) {
    50       int n;
    51       n = extract<int>(tp.attr("__len__")());
    52       std::vector<CountedPtr<asap::SDMemTable> > b(n);
    53       //Block<CountedPtr<asap::SDMemTable> > b(n);
    54       for (int i=0;i< n;++i) {
    55         SDMemTableWrapper sdmw =
    56           extract<SDMemTableWrapper>( tp.attr("__getitem__")(i) );
    57         b[i] = sdmw.getCP();
    58       }
    59       Vector<Bool> msk(mask);
    60 
    61       return SDMemTableWrapper(sdmath.average(b, msk, Bool(scanAv), weightStr));
    62     };
    63   } // namespace SDMathWrapper
    64 
    6539  namespace python {
    66     void python_SDMath() {
    67       def("b_operate", &SDMathWrapper::binaryOperate);
    68 
    69       def("quotient", &SDMathWrapper::quotient);
    70 
    71       def("scale", &SDMathWrapper::scale);
    72       def("scale_insitu", &SDMathWrapper::scaleInSitu);
    73 
    74       def("add", &SDMathWrapper::add);
    75       def("add_insitu", &SDMathWrapper::addInSitu);
    76 
    77       def("smooth", &SDMathWrapper::smooth);
    78       def("smooth_insitu", &SDMathWrapper::smoothInSitu);
    79 
    80       def("convertflux", &SDMathWrapper::convertFlux);
    81       def("convertflux_insitu", &SDMathWrapper::convertFluxInSitu);
    82 
    83       def("gainel", &SDMathWrapper::gainElevation);
    84       def("gainel_insitu", &SDMathWrapper::gainElevationInSitu);
    85 
    86       def("freq_align", &SDMathWrapper::frequencyAlignment);
    87       def("freq_align_insitu", &SDMathWrapper::frequencyAlignmentInSitu);
    88 
    89       def("opacity", &SDMathWrapper::opacity);
    90       def("opacity_insitu", &SDMathWrapper::opacityInSitu);
    91 
    92       def("average", &SDMathWrapper::average);
    93 
    94       def("averagepol", &SDMathWrapper::averagePol);
    95       def("averagepol_insitu", &SDMathWrapper::averagePolInSitu);
    96 
    97       def("bin", &SDMathWrapper::bin);
    98       def("bin_insitu", &SDMathWrapper::binInSitu);
    99 
    100       def("resample", &SDMathWrapper::resample);
    101       def("resample_insitu", &SDMathWrapper::resampleInSitu);
    102 
    103       def("stats", &SDMathWrapper::statistic);
    104 
    105       def("_rotate_xyphase", &SDMathWrapper::rotateXYPhaseInSitu);
    106       def("_rotate_linpolphase", &SDMathWrapper::rotateLinPolPhaseInSitu);
    107 
    108       def("_frequency_switch", &SDMathWrapper::frequencySwitch);
    109       def("_frequency_switch_insitu", &SDMathWrapper::frequencySwitchInSitu);
     40    void python_STMath() {
     41      class_<STMathWrapper>("stmath")
     42        .def( init < > () )
     43        .def( init < bool > () )
     44        .def("_insitu", &STMathWrapper::insitu)
     45        .def("_setinsitu", &STMathWrapper::setInsitu)
     46        .def("_average", &STMathWrapper::average)
     47        .def("_unaryop", &STMathWrapper::unaryOperate)
     48        .def("_quotient", &STMathWrapper::quotient)
     49        .def("_stats", &STMathWrapper::statistic)
     50        .def("_freqswitch", &STMathWrapper::freqSwitch)
     51        .def("_bin", &STMathWrapper::bin)
     52        .def("_resample", &STMathWrapper::resample)
     53        .def("_smooth", &STMathWrapper::smooth)
     54        .def("_gainel", &STMathWrapper::gainElevation)
     55        .def("_convertflux", &STMathWrapper::convertFlux)
     56        .def("_opacity", &STMathWrapper::opacity)
     57        .def("_merge", &STMathWrapper::merge)
     58      ;
    11059    };
    11160
    112   } // python
    113 } // asap
     61  } //namespace python
     62} // namespace asap
    11463

  • trunk/src/python_Scantable.cpp

    r871 r872  
    11//#---------------------------------------------------------------------------
    2 //# python_SDMemTable.cc: python exposure of c++ SDMemTable class
     2//# python_Scantable.cc: python exposure of c++ Scantable class
    33//#---------------------------------------------------------------------------
    44//# Copyright (C) 2004
    … …  
    3434#include <boost/python/args.hpp>
    3535
    36 #include "SDMemTableWrapper.h"
     36#include "ScantableWrapper.h"
    3737
    3838using namespace boost::python;
    … …  
    4141  namespace python {
    4242
    43 void python_SDMemTable() {
    44   class_<SDMemTableWrapper>("sdtable")
     43void python_Scantable() {
     44  class_<ScantableWrapper>("Scantable")
    4545    //.def( init <> () )
    46     .def( init < std::string > () )
    47     .def( init < const SDMemTableWrapper& > () )
    48     .def( init < const SDMemTableWrapper&, std::string > () )
    49     .def("_copy", &SDMemTableWrapper::copy)
    50     .def("getif", &SDMemTableWrapper::getIF)
    51     .def("getbeam", &SDMemTableWrapper::getBeam)
    52     .def("getpol", &SDMemTableWrapper::getPol)
    53     .def("_lines", &SDMemTableWrapper::spectralLines)
    54     .def("nif", &SDMemTableWrapper::nIF)
    55     .def("nbeam", &SDMemTableWrapper::nBeam)
    56     .def("npol", &SDMemTableWrapper::nPol)
    57     .def("nchan", &SDMemTableWrapper::nChan)
    58     .def("nscan", &SDMemTableWrapper::nScan)
    59     .def("nrow", &SDMemTableWrapper::nRow)
    60     .def("setif", &SDMemTableWrapper::setIF,
    61          (boost::python::arg("whichIF")=0) )
    62     .def("setbeam", &SDMemTableWrapper::setBeam)
    63     .def("setpol", &SDMemTableWrapper::setPol)
    64     .def("get_fluxunit", &SDMemTableWrapper::getFluxUnit)
    65     .def("set_fluxunit", &SDMemTableWrapper::setFluxUnit)
    66     .def("_setInstrument", &SDMemTableWrapper::setInstrument)
    67     .def("_getscan", &SDMemTableWrapper::getScan)
    68     .def("_getsource", &SDMemTableWrapper::getSource)
    69     .def("_getspectrum", &SDMemTableWrapper::getSpectrum,
     46    .def( init < const std::string&, const std::string& > () )
     47    .def( init < const ScantableWrapper& > () )
     48    .def("_copy", &ScantableWrapper::copy)
     49    .def("_assign", &ScantableWrapper::assign)
     50    .def("getif", &ScantableWrapper::getIF)
     51    .def("getbeam", &ScantableWrapper::getBeam)
     52    .def("getpol", &ScantableWrapper::getPol)
     53    .def("getscan", &ScantableWrapper::getScan)
     54    .def("getcycle", &ScantableWrapper::getCycle)
     55    .def("nif", &ScantableWrapper::nif)
     56    .def("nbeam", &ScantableWrapper::nbeam)
     57    .def("npol", &ScantableWrapper::npol)
     58    .def("nchan", &ScantableWrapper::nchan)
     59    .def("nscan", &ScantableWrapper::nscan)
     60    .def("nrow", &ScantableWrapper::nrow)
     61    .def("get_fluxunit", &ScantableWrapper::getFluxUnit)
     62    .def("set_fluxunit", &ScantableWrapper::setFluxUnit)
     63    .def("_setInstrument", &ScantableWrapper::setInstrument)
     64    .def("_getspectrum", &ScantableWrapper::getSpectrum,
    7065         (boost::python::arg("whichRow")=0))
    71     .def("nstokes", &SDMemTableWrapper::nStokes)
    72     .def("_getstokesspectrum", &SDMemTableWrapper::getStokesSpectrum,
     66    /*
     67    .def("nstokes", &ScantableWrapper::nStokes)
     68    .def("_getstokesspectrum", &ScantableWrapper::getStokesSpectrum,
    7369         (boost::python::arg("whichRow")=0),
    7470         (boost::python::arg("linpol")=false) )
    75     .def("_stokestopolspectrum", &SDMemTableWrapper::stokesToPolSpectrum,
     71    .def("_stokestopolspectrum", &ScantableWrapper::stokesToPolSpectrum,
    7672         (boost::python::arg("whichRow")=0),
    7773         (boost::python::arg("linear")=false),
    7874         (boost::python::arg("thepol")=-1) )
    79     .def("_getpolarizationlabel", &SDMemTableWrapper::getPolarizationLabel,
     75    */
     76    .def("_getpolarizationlabel", &ScantableWrapper::getPolarizationLabel,
    8077         (boost::python::arg("linear")=false),
    8178         (boost::python::arg("stokes")=false),
    8279         (boost::python::arg("linpol")=false) )
    8380//         (boost::python::arg("thepol")=0) )        // Boost fails with 4 arguments
    84     .def("_setspectrum",&SDMemTableWrapper::setSpectrum,
     81/*    .def("_setspectrum",&ScantableWrapper::setSpectrum,
     82         (boost::python::arg("whichRow")=0) )*/
     83    .def("_getabcissa", &ScantableWrapper::getAbcissa,
    8584         (boost::python::arg("whichRow")=0) )
    86     .def("_getabcissa", &SDMemTableWrapper::getAbcissa,
     85    .def("_getabcissalabel", &ScantableWrapper::getAbcissaLabel,
    8786         (boost::python::arg("whichRow")=0) )
    88     .def("_getabcissalabel", &SDMemTableWrapper::getAbcissaString,
     87    .def("_getmask", &ScantableWrapper::getMask,
    8988         (boost::python::arg("whichRow")=0) )
    90     .def("_getmask", &SDMemTableWrapper::getMask,
     89    .def("_gettsys", &ScantableWrapper::getTsys)
     90    .def("_getsourcename", &ScantableWrapper::getSourceName,
    9191         (boost::python::arg("whichRow")=0) )
    92     .def("_gettsys", &SDMemTableWrapper::getTsys)
    93     .def("_getsourcename", &SDMemTableWrapper::getSourceName,
     92    .def("_getelevation", &ScantableWrapper::getElevation,
    9493         (boost::python::arg("whichRow")=0) )
    95     .def("_getelevation", &SDMemTableWrapper::getElevation,
     94    .def("_getazimuth", &ScantableWrapper::getAzimuth,
    9695         (boost::python::arg("whichRow")=0) )
    97     .def("_getazimuth", &SDMemTableWrapper::getAzimuth,
     96    .def("_getparangle", &ScantableWrapper::getParAngle,
    9897         (boost::python::arg("whichRow")=0) )
    99     .def("_getparangle", &SDMemTableWrapper::getParAngle,
     98    .def("_gettime", &ScantableWrapper::getTime,
    10099         (boost::python::arg("whichRow")=0) )
    101     .def("_gettime", &SDMemTableWrapper::getTime,
    102          (boost::python::arg("whichRow")=0) )
    103     .def("_flag", &SDMemTableWrapper::flag,
    104          (boost::python::arg("whichRow")=-1) )
    105     .def("_save",  &SDMemTableWrapper::makePersistent)
    106     .def("_summary",  &SDMemTableWrapper::summary,
     100    .def("_flag", &ScantableWrapper::flag)
     101    .def("_save",  &ScantableWrapper::makePersistent)
     102    .def("_summary",  &ScantableWrapper::summary,
    107103         (boost::python::arg("verbose")=true) )
    108     .def("_getrestfreqs",  &SDMemTableWrapper::getRestFreqs)
    109     .def("_setrestfreqs",  &SDMemTableWrapper::setRestFreqs)
    110     .def("_setcoordinfo", &SDMemTableWrapper::setCoordInfo)
    111     .def("_getcoordinfo", &SDMemTableWrapper::getCoordInfo)
    112     .def("_gethistory", &SDMemTableWrapper::getHistory)
    113     .def("_addhistory", &SDMemTableWrapper::addHistory)
    114     .def("_addfit", &SDMemTableWrapper::addFit)
    115     .def("_getfit", &SDMemTableWrapper::getSDFitTable)
    116     .def("_recalc_azel", &SDMemTableWrapper::calculateAZEL)
     104    .def("_getrestfreqs",  &ScantableWrapper::getRestFrequencies)
     105    //.def("_setrestfreqs",  &ScantableWrapper::setRestFrequencies)
     106    .def("_setcoordinfo", &ScantableWrapper::setCoordInfo)
     107    .def("_getcoordinfo", &ScantableWrapper::getCoordInfo)
     108    .def("_gethistory", &ScantableWrapper::getHistory)
     109    .def("_addhistory", &ScantableWrapper::addHistory)
     110    .def("_getselection", &ScantableWrapper::getSelection)
     111    .def("_setselection", &ScantableWrapper::setSelection)
     112    /*
     113    .def("_addfit", &ScantableWrapper::addFit)
     114    .def("_getfit", &ScantableWrapper::getSDFitTable)
     115    */
     116    .def("_recalcazel", &ScantableWrapper::calculateAZEL)
    117117  ;
    118118};
Note: See TracChangeset for help on using the changeset viewer.