- Timestamp:
- 03/06/06 11:24:02 (19 years ago)
- Location:
- trunk/src
- Files:
-
- 5 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/src/STFillerWrapper.h
r871 r872 1 1 //#--------------------------------------------------------------------------- 2 //# S DReaderWrapper.h: Wrapper classes to use CountedPtr2 //# STFillerWrapper.h: Wrapper classes to use CountedPtr 3 3 //#--------------------------------------------------------------------------- 4 4 //# Copyright (C) 2004 … … 27 27 //# AUSTRALIA 28 28 //# 29 //# $Id: 29 //# $Id:$ 30 30 //#--------------------------------------------------------------------------- 31 #ifndef S DREADERWRAPPER_H32 #define S DREADERWRAPPER_H31 #ifndef STFILLERWRAPPER_H 32 #define STFILLERWRAPPER_H 33 33 34 #include <vector>35 34 #include <string> 36 35 37 #include "S DMemTableWrapper.h"38 #include "S DReader.h"36 #include "ScantableWrapper.h" 37 #include "STFiller.h" 39 38 40 39 namespace asap { 41 40 42 class S DReaderWrapper : public SDReader {41 class STFillerWrapper : public STFiller { 43 42 public: 44 S DReaderWrapper() {;}45 S DReaderWrapper(const std::string& filename, int ifSel=-1, int beamSel=-1) :46 S DReader(filename,ifSel,beamSel) {;}47 S DReaderWrapper(SDMemTableWrapper tbl) :48 S DReader(tbl.getCP()){;}49 S DMemTableWrapper getSDMemTable() const {50 return S DMemTableWrapper(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()); 51 50 } 52 51 }; -
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 33 14 34 15 #include <vector> 35 16 #include <string> 36 17 37 #include < boost/python/tuple.hpp>18 #include <casa/Utilities/CountedPtr.h> 38 19 39 #include "SDMemTableWrapper.h" 40 #include "SDMath.h" 20 #include "STMath.h" 21 #include "Scantable.h" 22 #include "ScantableWrapper.h" 41 23 42 24 namespace asap { 43 25 44 namespace SDMathWrapper { 26 /** 27 Wrapper class to handle ScantableWrapper 45 28 29 @author Malte Marquarding 30 */ 31 class STMathWrapper : public STMath { 32 public: 33 STMathWrapper() {;} 34 STMathWrapper(bool insitu) : STMath(insitu) {;} 46 35 47 static SDMath sdmath; 48 // Quotient 49 SDMemTableWrapper quotient(const SDMemTableWrapper& on, 50 const SDMemTableWrapper& off, 51 casa::Bool preserveContinuum); 36 virtual ~STMathWrapper() {;} 52 37 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 } 67 49 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)); } 73 54 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)); } 77 59 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())); } 84 63 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); } 90 68 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)); } 98 71 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)); } 104 76 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)); } 107 80 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) 110 86 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)); } 115 89 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)); } 120 94 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)); } 127 98 128 // Frequency Switching129 void SDMathWrapper::frequencySwitchInSitu(SDMemTableWrapper& in);99 ScantableWrapper 100 merge(const std::vector<ScantableWrapper >& in) 130 101 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)); } 138 106 139 107 }; 140 108 141 } // namespace 109 } 110 142 111 #endif -
trunk/src/python_STFiller.cpp
r871 r872 1 1 //#--------------------------------------------------------------------------- 2 //# python_S DReader.cc: python exposure of c++ SDReader class2 //# python_STFiller.cc: python exposure of c++ STFiller class 3 3 //#--------------------------------------------------------------------------- 4 4 //# Copyright (C) 2004 … … 31 31 #include <boost/python.hpp> 32 32 33 #include "S DReaderWrapper.h"33 #include "STFillerWrapper.h" 34 34 35 35 using namespace boost::python; … … 38 38 namespace python { 39 39 40 void python_S DReader() {41 class_<S DReaderWrapper>("sdreader")40 void python_STFiller() { 41 class_<STFillerWrapper>("stfiller") 42 42 .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) 48 46 ; 49 47 }; -
trunk/src/python_STMath.cpp
r871 r872 1 1 //#--------------------------------------------------------------------------- 2 //# python_S DMath.cc: python exposure of c++ SDMath class2 //# python_STMathWrapper.cc: python exposure of c++ STMath class 3 3 //#--------------------------------------------------------------------------- 4 4 //# Copyright (C) 2004 … … 27 27 //# AUSTRALIA 28 28 //# 29 //# $Id: 29 //# $Id:$ 30 30 //#--------------------------------------------------------------------------- 31 #include <vector> 31 32 #include <boost/python.hpp> 32 #include <vector>33 33 34 #include <casa/aips.h> 35 #include <casa/Containers/Block.h> 36 #include <casa/Utilities/CountedPtr.cc> 34 #include "STMathWrapper.h" 37 35 38 #include "SDMathWrapper.h"39 #include "SDMath.h"40 41 using namespace casa;42 36 using namespace boost::python; 43 37 44 38 namespace 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 SDMathWrapper64 65 39 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 ; 110 59 }; 111 60 112 } // python113 } // asap61 } //namespace python 62 } // namespace asap 114 63 -
trunk/src/python_Scantable.cpp
r871 r872 1 1 //#--------------------------------------------------------------------------- 2 //# python_S DMemTable.cc: python exposure of c++ SDMemTable class2 //# python_Scantable.cc: python exposure of c++ Scantable class 3 3 //#--------------------------------------------------------------------------- 4 4 //# Copyright (C) 2004 … … 34 34 #include <boost/python/args.hpp> 35 35 36 #include "S DMemTableWrapper.h"36 #include "ScantableWrapper.h" 37 37 38 38 using namespace boost::python; … … 41 41 namespace python { 42 42 43 void python_S DMemTable() {44 class_<S DMemTableWrapper>("sdtable")43 void python_Scantable() { 44 class_<ScantableWrapper>("Scantable") 45 45 //.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, 70 65 (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, 73 69 (boost::python::arg("whichRow")=0), 74 70 (boost::python::arg("linpol")=false) ) 75 .def("_stokestopolspectrum", &S DMemTableWrapper::stokesToPolSpectrum,71 .def("_stokestopolspectrum", &ScantableWrapper::stokesToPolSpectrum, 76 72 (boost::python::arg("whichRow")=0), 77 73 (boost::python::arg("linear")=false), 78 74 (boost::python::arg("thepol")=-1) ) 79 .def("_getpolarizationlabel", &SDMemTableWrapper::getPolarizationLabel, 75 */ 76 .def("_getpolarizationlabel", &ScantableWrapper::getPolarizationLabel, 80 77 (boost::python::arg("linear")=false), 81 78 (boost::python::arg("stokes")=false), 82 79 (boost::python::arg("linpol")=false) ) 83 80 // (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, 85 84 (boost::python::arg("whichRow")=0) ) 86 .def("_getabcissa ", &SDMemTableWrapper::getAbcissa,85 .def("_getabcissalabel", &ScantableWrapper::getAbcissaLabel, 87 86 (boost::python::arg("whichRow")=0) ) 88 .def("_get abcissalabel", &SDMemTableWrapper::getAbcissaString,87 .def("_getmask", &ScantableWrapper::getMask, 89 88 (boost::python::arg("whichRow")=0) ) 90 .def("_getmask", &SDMemTableWrapper::getMask, 89 .def("_gettsys", &ScantableWrapper::getTsys) 90 .def("_getsourcename", &ScantableWrapper::getSourceName, 91 91 (boost::python::arg("whichRow")=0) ) 92 .def("_gettsys", &SDMemTableWrapper::getTsys) 93 .def("_getsourcename", &SDMemTableWrapper::getSourceName, 92 .def("_getelevation", &ScantableWrapper::getElevation, 94 93 (boost::python::arg("whichRow")=0) ) 95 .def("_get elevation", &SDMemTableWrapper::getElevation,94 .def("_getazimuth", &ScantableWrapper::getAzimuth, 96 95 (boost::python::arg("whichRow")=0) ) 97 .def("_get azimuth", &SDMemTableWrapper::getAzimuth,96 .def("_getparangle", &ScantableWrapper::getParAngle, 98 97 (boost::python::arg("whichRow")=0) ) 99 .def("_get parangle", &SDMemTableWrapper::getParAngle,98 .def("_gettime", &ScantableWrapper::getTime, 100 99 (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, 107 103 (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) 117 117 ; 118 118 };
Note:
See TracChangeset
for help on using the changeset viewer.