source: trunk/src/SDMemTableWrapper.h@ 402

Last change on this file since 402 was 401, checked in by kil064, 20 years ago

add rest freq specification by line name
add function spectraLines to list known lines

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 5.9 KB
RevLine 
[2]1//#---------------------------------------------------------------------------
2//# SDMemTableWrapper.h: Wrapper classes to use CountedPtr
3//#---------------------------------------------------------------------------
4//# Copyright (C) 2004
[125]5//# ATNF
[2]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//#---------------------------------------------------------------------------
[125]31#ifndef SDMEMTABLEWRAPPER_H
32#define SDMEMTABLEWRAPPER_H
[2]33
34#include <vector>
35#include <string>
[380]36#include <casa/Arrays/Vector.h>
[2]37
38#include "SDMemTable.h"
39
[83]40namespace asap {
[2]41
42class SDMemTableWrapper {
43
44public:
[90]45 SDMemTableWrapper(const std::string& name) :
[2]46 table_(new SDMemTable(name)) {;}
[90]47 SDMemTableWrapper() :
[18]48 table_(new SDMemTable()) {;}
[90]49
[125]50 SDMemTableWrapper(casa::CountedPtr<SDMemTable> cp) : table_(cp) {;}
[90]51 //SDMemTableWrapper(SDMemTable* sdmt) : table_(sdmt) {;}
52 SDMemTableWrapper(const SDMemTableWrapper& mt) :
53 table_(mt.getCP()) {;}
54
[80]55 SDMemTableWrapper(const SDMemTableWrapper& mt, const std::string& expr) :
56 table_(new SDMemTable(mt.getCP()->table(), expr)) {;}
[90]57
58 SDMemTableWrapper copy() {
59 //CountedPtr<SDMemTable> cp = new SDMemTable(*this, False);
[125]60 return SDMemTableWrapper(new SDMemTable(*(this->getCP()), casa::False));
[90]61 }
62
[380]63 //SDMemTableWrapper getScan(int scan) {
64 SDMemTableWrapper getScan(std::vector<int> scan) {
65 casa::String cond("SELECT FROM $1 WHERE SCANID IN ");
66 casa::Vector<casa::Int> v(scan);
67 casa::ostringstream oss;
68 oss << v;
69 cond += casa::String(oss);
[80]70 return SDMemTableWrapper(*this, cond);
[2]71 }
[80]72
73 SDMemTableWrapper getSource(const std::string& source) {
[186]74 casa::String cond("SELECT * from $1 WHERE SRCNAME == pattern('");
75 cond += source;cond += "')";
[80]76 return SDMemTableWrapper(*this, cond);
77 }
78
[51]79 std::vector<float> getSpectrum(int whichRow=0) const {
[2]80 return table_->getSpectrum(whichRow);
81 }
[41]82
[158]83 std::vector<double> getAbcissa(int whichRow=0) const {
84 return table_->getAbcissa(whichRow);
[41]85 }
[158]86 std::string getAbcissaString(int whichRow=0) const {
87 return table_->getAbcissaString(whichRow);
[105]88 }
[41]89
[157]90 std::vector<float> getTsys() {
91 int nRow = table_->nRow();
92 std::vector<float> result(nRow);
93 for (uint i=0; i<nRow; i++) {
94 result[i] = table_->getTsys(i);
95 }
96 return result;
97 }
98
[51]99 std::string getTime(int whichRow=0) {return table_->getTime(whichRow);}
[2]100
[207]101 std::string getFluxUnit() const {return table_->getFluxUnit();}
[220]102 void setFluxUnit(const std::string& unit) {table_->setFluxUnit(unit);}
[207]103
[238]104 void setInstrument(const std::string& name) {table_->setInstrument(name);}
105
[90]106 std::vector<bool> getMask(int whichRow=0) const {
107 return table_->getMask(whichRow);
[16]108 }
[90]109 bool setMask(const std::vector<int> mvals) const {
110 return table_->setMask(mvals);
111 }
[2]112
[90]113 void flag(int whichRow=-1) {
114 table_->flag(whichRow);
115 }
[51]116 std::string getSourceName(int whichRow=0) {
[2]117 return table_->getSourceName(whichRow);
118 }
119
[90]120 void setSpectrum(std::vector<float> spectrum, int whichRow=0) {
121 table_->setSpectrum(spectrum, whichRow);
122 }
123
[2]124 bool setIF(int whichIF=0) {return table_->setIF(whichIF);}
125 bool setBeam(int whichBeam=0) {return table_->setBeam(whichBeam);}
[90]126 bool setPol(int whichPol=0) {return table_->setPol(whichPol);}
[2]127
128 int getIF() {return table_->getIF();}
129 int getBeam() {return table_->getBeam();}
[90]130 int getPol() {return table_->getPol();}
[2]131
[18]132 int nIF() {return table_->nIF();}
133 int nBeam() {return table_->nBeam();}
[90]134 int nPol() {return table_->nPol();}
135 int nChan() {return table_->nChan();}
136 int nScan() {return table_->nScan();}
137 int nRow() {return table_->nRow();}
[2]138
139 //sets the mask
140 bool setChannels(const std::vector<int>& whichChans) {
[90]141 return setChannels(whichChans);
[2]142 }
143 void makePersistent(const std::string& fname) {
144 table_->makePersistent(fname);
145 }
[90]146
[401]147 bool setRestFreqs(const std::vector<double>& restfreqs,
148 const std::string& unit,
149 const std::vector<std::string>& lines,
150 const std::string& source, int whichIF) {
[392]151 casa::Vector<casa::Double> restFreqs2(restfreqs);
152 return table_->setRestFreqs(restFreqs2, casa::String(unit),
[401]153 lines, casa::String(source),
[392]154 casa::Int(whichIF));
[90]155 }
[251]156
[401]157 void spectralLines() const {table_->spectralLines();}
158
[251]159 std::vector<double> getRestFreqs() {
160 return table_->getRestFreqs();
161 }
162
[105]163 void setCoordInfo(std::vector<string> theinfo) {
164 table_->setCoordInfo(theinfo);
165 }
166 std::vector<string> getCoordInfo() const {
167 return table_->getCoordInfo();
168 }
[90]169
[125]170 casa::CountedPtr<SDMemTable> getCP() const {return table_;}
[138]171 SDMemTable* getPtr() {return &(*table_);}
[380]172
173 std::string summary(bool verbose=false) const {
174 return table_->summary(verbose);
175 }
[186]176
[207]177 std::vector<std::string> history(int whichRow=0) {
178 return table_->history(whichRow);
179 }
180
[2]181private:
[125]182 casa::CountedPtr<SDMemTable> table_;
[2]183};
184
185} // namespace
186#endif
Note: See TracBrowser for help on using the repository browser.