source: trunk/src/SDContainer.h@ 479

Last change on this file since 479 was 465, checked in by mar637, 20 years ago

Added SDFitTable to handle fits and expose them to python vi the sdfit class.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 8.6 KB
Line 
1//#---------------------------------------------------------------------------
2//# SDContainer.h: A container class for single dish integrations
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 SDCONTAINER_H
32#define SDCONTAINER_H
33
34#include <vector>
35
36#include <casa/aips.h>
37#include <casa/BasicSL/String.h>
38#include <casa/Arrays/Array.h>
39#include <casa/Arrays/Vector.h>
40#include <casa/Containers/Block.h>
41#include <measures/Measures/MDirection.h>
42
43template<class T> class casa::Matrix;
44
45namespace asap {
46
47
48struct SDHeader {
49 casa::Int nchan;
50 casa::Int npol;
51 casa::Int nif;
52 casa::Int nbeam;
53 casa::String observer;
54 casa::String project;
55 casa::String obstype;
56 casa::String antennaname;
57 casa::Vector<casa::Double> antennaposition;
58 casa::Float equinox;
59 casa::String freqref;
60 casa::Double reffreq;
61 casa::Double bandwidth;
62 casa::Double utc;
63 casa::String fluxunit;
64 casa::String epoch;
65 void print() const ;
66};
67
68class SDFrequencyTable {
69
70public:
71
72 SDFrequencyTable() : nFreq_(0) {;}
73 virtual ~SDFrequencyTable() {;}
74
75 // Add a new entry or match an existing one. Returns the index into
76 // the table
77 casa::uInt addFrequency(casa::Double refPix, casa::Double refVal,
78 casa::Double inc);
79
80 casa::Int length() const { return nFreq_;} // # of stored Frequencies
81 void setLength(casa::uInt length) {nFreq_ = length;}
82
83 // Get attributes
84 casa::Double referencePixel(casa::uInt which) const { return refPix_[which];}
85 casa::Double referenceValue(casa::uInt which) const { return refVal_[which];}
86 casa::Double increment(casa::uInt which) const { return increment_[which];}
87 casa::Float equinox() const { return equinox_; }
88 casa::String refFrame() const { return refFrame_; }
89
90 void restFrequencies(casa::Vector<casa::Double>& rfs,
91 casa::String& rfunit ) const ;
92
93 // Set attributes
94 void setEquinox(casa::Float eq) { equinox_ = eq; }
95 void setRefFrame(const casa::String& reff) { refFrame_ = reff; }
96
97 void deleteRestFrequencies() {restFreqs_.resize(0);}
98 casa::uInt addRestFrequency(casa::Double);
99 void setRestFrequencyUnit(const casa::String& theunit)
100 { restFreqUnit_ = theunit;}
101
102private:
103 casa::uInt nFreq_;
104 casa::Vector<casa::Double> refPix_;
105 casa::Vector<casa::Double> refVal_; // Hz
106 casa::Vector<casa::Double> increment_; // Hz
107 casa::Float equinox_;
108 casa::String refFrame_;
109 casa::Vector<casa::Double> restFreqs_; // Hz
110 casa::String restFreqUnit_;
111};
112
113
114class SDContainer {
115
116public:
117 SDContainer(casa::uInt nBeam, casa::uInt nIF, casa::uInt nPol,
118 casa::uInt nChan);
119 SDContainer(casa::IPosition shp);
120
121 virtual ~SDContainer();
122
123 casa::Bool resize(casa::IPosition shp);
124
125 casa::Bool setSpectrum(const casa::Matrix<casa::Float>& spec,
126 casa::uInt whichBeam, casa::uInt whichIF);
127 casa::Bool setSpectrum(const casa::Matrix<casa::Float>& spec,
128 const casa::Vector<casa::Complex>& cSpec,
129 casa::uInt whichBeam, casa::uInt whichIF);
130 casa::Bool putSpectrum(const casa::Array<casa::Float>& spec);
131
132 casa::Bool setFlags(const casa::Matrix<casa::uChar>& flgs,
133 casa::uInt whichBeam, casa::uInt whichIF,
134 casa::Bool hasXPol=casa::False);
135 casa::Bool putFlags(const casa::Array<casa::uChar>& spec);
136
137 casa::Bool setTsys(const casa::Vector<casa::Float>& ts,
138 casa::uInt whichBeam, casa::uInt whichIF,
139 casa::Bool hasXpol);
140 casa::Bool putTsys(const casa::Array<casa::Float>& spec);
141
142 casa::Bool setDirection(const casa::Vector<casa::Double>& point,
143 casa::uInt whichBeam);
144 casa::Bool putDirection(const casa::Array<casa::Double>& dir);
145
146 casa::Bool setFrequencyMap(casa::uInt freqslot, casa::uInt whichIF);
147 casa::Bool putFreqMap(const casa::Vector<casa::uInt>& freqs);
148
149 casa::Bool setRestFrequencyMap(casa::uInt freqslot, casa::uInt whichIF);
150 casa::Bool putRestFreqMap(const casa::Vector<casa::uInt>& freqs);
151
152 casa::Array<casa::Float> getSpectrum(casa::uInt whichBeam,
153 casa::uInt whichIF);
154 casa::Array<casa::uChar> getFlags(casa::uInt whichBeam,
155 casa::uInt whichIF);
156 casa::Array<casa::Float> getTsys(casa::uInt whichBeam,
157 casa::uInt whichIF);
158 casa::Array<casa::Double> getDirection(casa::uInt whichBeam) const;
159
160 const casa::Array<casa::Float>& getSpectrum() const { return spectrum_; }
161 const casa::Array<casa::uChar>& getFlags() const { return flags_; }
162 const casa::Array<casa::Float>& getTsys() const { return tsys_; }
163 const casa::Array<casa::Double>& getDirection() const { return direction_; }
164
165 const casa::Vector<casa::uInt>& getFreqMap() const { return freqidx_; }
166 const casa::Vector<casa::uInt>& getRestFreqMap() const
167 { return restfreqidx_; }
168
169 const casa::Vector<casa::String>& getHistory() const { return history_; }
170 casa::Bool putHistory(const casa::Vector<casa::String>& hist);
171 casa::Bool appendHistory(const casa::String& hist);
172
173 casa::Bool putFitMap(const casa::Array<casa::Int>& arr);
174
175 const casa::Array<casa::Int>& getFitMap() const { return fitIDMap_; }
176
177
178 casa::Double timestamp;
179 //Double bandwidth;
180 casa::String sourcename;
181 casa::String fieldname;
182 casa::Double interval;
183 casa::Int scanid;
184 casa::Vector<casa::Float> tcal;
185 casa::String tcaltime;
186 casa::Float azimuth;
187 casa::Float elevation;
188 casa::Float parangle;
189 casa::Int refbeam;
190
191private:
192 casa::uInt nBeam_,nIF_,nPol_,nChan_;
193
194 // (nBeam,nIF,nPol,nChannel)
195 casa::Array<casa::Float> spectrum_;
196 casa::Array<casa::uChar> flags_;
197
198 // (nBeam,nIF,nPol,[nChannel]) Tsys is not really a function of
199 // channel, but this makes it easier to work with at the expense of
200 // a little memory
201 casa::Array<casa::Float> tsys_;
202 casa::Array<casa::Float> tcal_;
203
204 //(nIF) indx into "global" frequency table
205 casa::Vector<casa::uInt> freqidx_;
206
207 // (nIF) indx into "global" rest frequency table
208 casa::Vector<casa::uInt> restfreqidx_;
209
210 //(nBeam,2) maybe use Measures here...
211 casa::Array<casa::Double> direction_;
212 casa::Vector<casa::String> history_;
213 casa::Array<casa::Int> fitIDMap_;
214
215 void setSlice(casa::IPosition& start, casa::IPosition& end,
216 const casa::IPosition& shpIn, const casa::IPosition& shpOut,
217 casa::uInt whichBeam, casa::uInt whichIF, casa::Bool checkPol,
218 casa::Bool xPol) const;
219 void setSlice(casa::IPosition& start, casa::IPosition& end,
220 const casa::IPosition& shape,
221 casa::uInt whichBeam, casa::uInt whichIF) const;
222};
223
224
225
226class SDDataDesc {
227
228public:
229
230 // Constructor
231 SDDataDesc() : n_(0) {;}
232 ~SDDataDesc() {;}
233
234 // Add an entry if source name and Integer ID (can be anything you
235 // like, such as FreqID) are unique. You can add secondary entries
236 // direction and another integer index which are just stored along
237 // with the the primary entries
238 casa::uInt addEntry(const casa::String& source, casa::uInt ID,
239 const casa::MDirection& secDir, casa::uInt secID);
240
241 // Number of entries
242 casa::Int length() const { return n_;}
243
244 // Get attributes
245 casa::String source(casa::uInt which) const {return source_[which];}
246 casa::uInt ID(casa::uInt which) const {return ID_[which];}
247 casa::uInt secID(casa::uInt which) const {return secID_[which];}
248 casa::MDirection secDir(casa::uInt which) const {return secDir_[which];}
249
250 // Summary
251 void summary() const;
252
253private:
254 casa::uInt n_;
255 casa::Vector<casa::String> source_;
256 casa::Vector<casa::uInt> ID_, secID_;
257 casa::Block<casa::MDirection> secDir_;
258
259 SDDataDesc(const SDDataDesc& other);
260
261};
262
263
264} // namespace
265#endif
Note: See TracBrowser for help on using the repository browser.