Line data Source code
1 : //# RFCubeLattice.cc: this defines RFCubeLattice
2 : //# Copyright (C) 2000,2001
3 : //# Associated Universities, Inc. Washington DC, USA.
4 : //#
5 : //# This library is free software; you can redistribute it and/or modify it
6 : //# under the terms of the GNU Library General Public License as published by
7 : //# the Free Software Foundation; either version 2 of the License, or (at your
8 : //# option) any later version.
9 : //#
10 : //# This library is distributed in the hope that it will be useful, but WITHOUT
11 : //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 : //# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
13 : //# License for more details.
14 : //#
15 : //# You should have received a copy of the GNU Library General Public License
16 : //# along with this library; if not, write to the Free Software Foundation,
17 : //# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
18 : //#
19 : //# Correspondence concerning AIPS++ should be addressed as follows:
20 : //# Internet email: casa-feedback@nrao.edu.
21 : //# Postal address: AIPS++ Project Office
22 : //# National Radio Astronomy Observatory
23 : //# 520 Edgemont Road
24 : //# Charlottesville, VA 22903-2475 USA
25 : //#
26 : //# $Id$
27 : #include <casacore/lattices/Lattices/LatticeStepper.h>
28 : #include <flagging/Flagging/RFCubeLattice.h>
29 : #include <flagging/Flagging/RFCommon.h>
30 :
31 : namespace casa { //# NAMESPACE CASA - BEGIN
32 :
33 4 : template<class T> RFCubeLatticeIterator<T>::RFCubeLatticeIterator ()
34 4 : : n_chan(0), n_ifr(0), n_time(0), n_bit(0), n_corr(0)
35 : {
36 4 : iter_pos = 0;
37 : //curs = casacore::Matrix<T>();
38 4 : lattice = NULL;
39 4 : }
40 :
41 0 : template<class T> RFCubeLatticeIterator<T>::RFCubeLatticeIterator(std::vector<std::vector<bool> > *lat,
42 : unsigned nchan, unsigned nifr,
43 : unsigned ntime, unsigned nbit,
44 : unsigned ncorr)
45 0 : : n_chan(nchan), n_ifr(nifr), n_time(ntime), n_bit(nbit), n_corr(ncorr)
46 :
47 : {
48 0 : iter_pos = 0;
49 0 : lattice = lat;
50 0 : }
51 :
52 4 : template<class T> RFCubeLatticeIterator<T>::~RFCubeLatticeIterator()
53 : {
54 4 : }
55 :
56 : /*
57 : The format is like this:
58 :
59 : [ ... | agent1 | agent0 | corrN | ... | corr1 | corr0 ]
60 :
61 : i.e. the length is number of agents + number of correlations.
62 :
63 : Except (don't ask why) if nCorr = 1, the format is
64 :
65 : [ ... | agent1 | agent0 | notUsed | corr0 ]
66 :
67 : */
68 :
69 :
70 0 : template<class T> void RFCubeLatticeIterator<T>::reset()
71 : {
72 0 : iter_pos = 0;
73 0 : return;
74 : }
75 :
76 0 : template<class T> void RFCubeLatticeIterator<T>::advance(casacore::uInt t1)
77 : {
78 0 : iter_pos = t1;
79 0 : return;
80 : }
81 :
82 : template<class T> T
83 0 : RFCubeLatticeIterator<T>::operator()(casacore::uInt chan, casacore::uInt ifr) const
84 : {
85 0 : T val = 0;
86 :
87 0 : std::vector<bool> &l = (*lattice)[iter_pos];
88 :
89 0 : if (n_bit == 2) {
90 0 : unsigned indx = n_bit*(chan + n_chan*ifr);
91 0 : val = l[indx] + 4*l[indx+1];
92 : }
93 0 : else if (n_corr <= 1) {
94 : /* write corr0 */
95 0 : unsigned indx = 0 + n_bit*(chan + n_chan*ifr);
96 0 : if (l[indx]) {
97 0 : val |= 1;
98 : }
99 :
100 : /* write agents starting from b[2] */
101 0 : for (unsigned b = 1; b < n_bit; b++) {
102 0 : indx++;
103 0 : if (l[indx]) {
104 0 : val |= 1 << (b+1);
105 : }
106 : }
107 : }
108 : else {
109 0 : unsigned indx = n_bit*(chan + n_chan*ifr);
110 0 : for (unsigned b = 0; b < n_bit; b++) {
111 0 : if (l[indx++]) {
112 0 : val |= 1 << b;
113 : }
114 : }
115 : }
116 :
117 0 : return val;
118 : }
119 :
120 : template<class T> void
121 0 : RFCubeLatticeIterator<T>::set( casacore::uInt chan, casacore::uInt ifr, const T &val )
122 : {
123 0 : std::vector<bool> &l = (*lattice)[iter_pos];
124 :
125 0 : if (n_bit == 2) {
126 0 : unsigned indx = n_bit*(chan + n_chan*ifr);
127 0 : l[indx] = val & 1;
128 0 : l[indx+1] = val & 4;
129 : }
130 0 : else if (n_corr <= 1) {
131 0 : unsigned indx = 0 + n_bit*(chan + n_chan*ifr);
132 0 : l[indx] = val & 1;
133 :
134 0 : for (unsigned b = 1; b < n_bit; b++) {
135 0 : indx++;
136 0 : l[indx] = val & (1<<(b+1));
137 : }
138 : }
139 : else {
140 0 : unsigned indx = n_bit*(chan + n_chan*ifr);
141 0 : for (unsigned b = 0; b < n_bit; b++) {
142 0 : l[indx++] = val & (1<<b);
143 : }
144 : }
145 :
146 0 : return;
147 : }
148 :
149 :
150 : template<class T> void
151 0 : RFCubeLatticeIterator<T>::set( casacore::uInt ichan,
152 : casacore::uInt ifr,
153 : casacore::uInt icorr,
154 : bool val)
155 : {
156 0 : std::vector<bool> &l = (*lattice)[iter_pos];
157 :
158 0 : unsigned indx = icorr + n_bit*(ichan + n_chan*ifr);
159 :
160 0 : l[indx] = val;
161 :
162 0 : return;
163 : }
164 :
165 :
166 :
167 2 : template<class T> RFCubeLattice<T>::RFCubeLattice ()
168 : {
169 2 : }
170 :
171 : template<class T> RFCubeLattice<T>::RFCubeLattice ( casacore::uInt nchan,
172 : casacore::uInt nifr,
173 : casacore::uInt ntime,
174 : casacore::uInt ncorr,
175 : casacore::uInt nAgent)
176 : {
177 : init(nchan, nifr, ntime, ncorr, nAgent);
178 : }
179 : template<class T> RFCubeLattice<T>::RFCubeLattice ( casacore::uInt nchan,
180 : casacore::uInt nifr,
181 : casacore::uInt ntime,
182 : casacore::uInt ncorr,
183 : casacore::uInt nAgent,
184 : const T &init_val)
185 : {
186 : init(nchan, nifr, ntime, ncorr, nAgent, init_val);
187 : }
188 :
189 2 : template<class T> RFCubeLattice<T>::~RFCubeLattice ()
190 : {
191 2 : cleanup();
192 2 : }
193 :
194 : template<class T> void
195 0 : RFCubeLattice<T>::init(casacore::uInt nchan,
196 : casacore::uInt nifr,
197 : casacore::uInt ntime,
198 : casacore::uInt ncorr,
199 : casacore::uInt nAgent)
200 : {
201 0 : n_bit = ncorr + nAgent;
202 :
203 0 : if (n_bit > 32) {
204 0 : std::ostringstream ss;
205 0 : ss <<
206 0 : "Sorry, too many polarizations (" << ncorr <<
207 0 : ") and agents (" << nAgent << "). Max supported number is 32 in total.";
208 0 : std::cerr << ss.str();
209 0 : throw casacore::AipsError(ss.str());
210 0 : }
211 :
212 0 : lat_shape = casacore::IPosition(3, nchan, nifr, ntime);
213 :
214 0 : lat = std::vector<std::vector<bool> >(ntime);
215 0 : for (unsigned i = 0; i < ntime; i++) {
216 0 : lat[i] = std::vector<bool>(nchan * nifr * (ncorr+nAgent));
217 : }
218 :
219 0 : iter = RFCubeLatticeIterator<T>(&lat, nchan, nifr, ntime, ncorr+nAgent, ncorr);
220 0 : }
221 :
222 0 : template<class T> RFCubeLatticeIterator<T> RFCubeLattice<T>::newIter()
223 : {
224 0 : return RFCubeLatticeIterator<T>(&lat, n_chan, n_ifr, n_time, n_bit, n_corr);
225 : }
226 :
227 0 : template<class T> void RFCubeLattice<T>::init(casacore::uInt nchan,
228 : casacore::uInt nifr,
229 : casacore::uInt ntime,
230 : casacore::uInt ncorr,
231 : casacore::uInt nAgent,
232 : const T &init_val)
233 : {
234 0 : n_chan = nchan;
235 0 : n_ifr = nifr;
236 0 : n_time = ntime;
237 0 : n_bit = ncorr + nAgent;
238 0 : n_corr = ncorr;
239 0 : init(nchan, nifr, ntime, ncorr, nAgent);
240 :
241 0 : casacore::uInt nbits = ncorr + nAgent;
242 :
243 : /* Write init_val to every matrix element.
244 : See above for description of format */
245 0 : std::vector<bool> val = bitvec_from_ulong( (unsigned) init_val, nbits+1 );
246 0 : for (unsigned i = 0; i < ntime; i++) {
247 0 : if (n_bit == 2) {
248 0 : unsigned indx = 0;
249 0 : bool v0 = val[0];
250 0 : bool v2 = val[2];
251 0 : while (indx < 2*n_chan*n_ifr) {
252 0 : lat[i][indx++] = v0;
253 0 : lat[i][indx++] = v2;
254 : }
255 : }
256 : else {
257 0 : for (unsigned ifr = 0; ifr < nifr; ifr++) {
258 0 : for (unsigned chan = 0; chan < nchan; chan++) {
259 0 : if (n_corr <= 1) {
260 0 : unsigned indx = 0 + n_bit*(chan + n_chan*ifr);
261 0 : lat[i][indx] = val[0];
262 :
263 0 : for (unsigned b = 1; b < n_bit; b++) {
264 0 : indx++;
265 0 : lat[i][indx] = val[b+1];
266 : }
267 : }
268 : else {
269 0 : unsigned indx = n_bit*(chan + n_chan*ifr);
270 0 : for (unsigned b = 0; b < n_bit; b++) {
271 0 : lat[i][indx++] = val[b];
272 : }
273 : }
274 : }
275 : }
276 : }
277 : }
278 0 : }
279 :
280 : template<class T> void
281 0 : RFCubeLattice<T>::set_column( casacore::uInt ifr, const T &val )
282 : {
283 0 : for (unsigned chan = 0; chan < n_chan; chan++) {
284 0 : set(chan, ifr, val);
285 : }
286 0 : return;
287 : }
288 :
289 2 : template<class T> void RFCubeLattice<T>::cleanup ()
290 : {
291 2 : iter = RFCubeLatticeIterator<T>();
292 2 : lat.resize(0);
293 2 : lat_shape.resize(0);
294 2 : }
295 :
296 0 : template<class T> void RFCubeLattice<T>::reset ()
297 : {
298 0 : iter.reset();
299 0 : }
300 :
301 :
302 : } //# NAMESPACE CASA - END
303 :
|
