source: trunk/src/SDContainer.h @ 465

Last change on this file since 465 was 465, checked in by mar637, 19 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.