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/RFFloatLattice.h>
29 : #include <flagging/Flagging/RFCommon.h>
30 :
31 : using namespace casacore;
32 : namespace casa { //# NAMESPACE CASA - BEGIN
33 :
34 0 : RFFloatLatticeIterator::RFFloatLatticeIterator ()
35 0 : : n_chan(0), n_ifr(0), /* n_time(0),*/ n_bit(0), n_corr(0)
36 : {
37 0 : iter_pos = 0;
38 0 : curs = Matrix<Float>();
39 0 : lattice = NULL;
40 0 : }
41 :
42 0 : RFFloatLatticeIterator::RFFloatLatticeIterator(std::vector<std::vector<bool> > *lat,
43 : unsigned nchan, unsigned nifr,
44 : unsigned /* ntime */, unsigned nbit,
45 0 : unsigned ncorr)
46 0 : : n_chan(nchan), n_ifr(nifr), /* n_time(ntime),*/ n_bit(nbit), n_corr(ncorr)
47 :
48 : {
49 0 : iter_pos = 0;
50 0 : lattice = lat;
51 0 : update_curs();
52 0 : }
53 :
54 0 : RFFloatLatticeIterator::~RFFloatLatticeIterator()
55 : {
56 0 : flush_curs();
57 0 : }
58 :
59 : /* Update cursor from buffer, convert from bitset to Matrix<uInt> */
60 :
61 : /*
62 : The format is like this:
63 :
64 : [ ... | agent1 | agent0 | corrN | ... | corr1 | corr0 ]
65 :
66 : i.e. the length is number of agents + number of correlations.
67 :
68 : Except (don't ask why) if nCorr = 1, the format is
69 :
70 : [ ... | agent1 | agent0 | notUsed | corr0 ]
71 :
72 : */
73 :
74 0 : void RFFloatLatticeIterator::update_curs()
75 : {
76 0 : if (lattice != NULL && iter_pos < lattice->size()) {
77 0 : curs.resize(IPosition(2, n_chan, n_ifr));
78 :
79 : //curs = (*lattice)[iter_pos];
80 :
81 0 : std::vector<bool> &l = (*lattice)[iter_pos];
82 :
83 0 : std::vector<bool> val(n_bit);
84 0 : if (n_corr == 1) {
85 0 : val.resize(n_bit+1);
86 : }
87 :
88 0 : for (unsigned ifr = 0; ifr < n_ifr; ifr++) {
89 0 : for (unsigned chan = 0; chan < n_chan; chan++) {
90 0 : if (n_corr <= 1) {
91 : /* write corr0 */
92 0 : unsigned indx = 0 + n_bit*(chan + n_chan*ifr);
93 0 : val[0] = l[indx];
94 :
95 : /* write agents starting from b[2] */
96 0 : for (unsigned b = 1; b < n_bit; b++) {
97 0 : indx = b + n_bit*(chan + n_chan*ifr);
98 0 : val[b+1] = l[indx];
99 : }
100 : }
101 : else {
102 : unsigned indx;
103 0 : for (unsigned b = 0; b < n_bit; b++) {
104 0 : indx = b + n_bit*(chan + n_chan*ifr);
105 :
106 0 : val[b] = l[indx];
107 : }
108 : }
109 :
110 0 : curs(chan, ifr) = bitvec_to_ulong(val);
111 : }
112 : }
113 0 : }
114 0 : }
115 :
116 : /* Write cursor back to buffer, convert from Matrix<uInt> to bitset.
117 : See above for an explanation of the format.
118 : */
119 0 : void RFFloatLatticeIterator::flush_curs()
120 : {
121 0 : if (lattice != NULL && iter_pos < lattice->size()) {
122 :
123 : //(*lattice)[iter_pos] = curs;
124 0 : std::vector<bool> &l = (*lattice)[iter_pos];
125 :
126 0 : std::vector<bool> val(n_bit+1);
127 :
128 0 : for (unsigned ifr = 0; ifr < n_ifr; ifr++) {
129 0 : for (unsigned chan = 0; chan < n_chan; chan++) {
130 :
131 0 : unsigned c = (unsigned) curs(chan, ifr);
132 0 : for (unsigned i = 0; i < n_bit+1; i++) {
133 0 : val[i] = (c & 1);
134 0 : c = c >> 1;
135 : }
136 :
137 0 : if (n_corr <= 1) {
138 0 : unsigned indx = 0 + n_bit*(chan + n_chan*ifr);
139 0 : l[indx] = val[0];
140 :
141 0 : for (unsigned b = 1; b < n_bit; b++) {
142 0 : indx = b + n_bit*(chan + n_chan*ifr);
143 0 : l[indx] = val[b+1];
144 : }
145 : }
146 : else {
147 : unsigned indx;
148 0 : for (unsigned b = 0; b < n_bit; b++) {
149 0 : indx = b + n_bit*(chan + n_chan*ifr);
150 :
151 0 : l[indx] = val[b];
152 : }
153 : }
154 : }
155 : }
156 0 : }
157 0 : }
158 :
159 0 : Matrix<Float> * RFFloatLatticeIterator::reset()
160 : {
161 0 : if (iter_pos != 0) flush_curs();
162 0 : iter_pos = 0;
163 0 : update_curs();
164 0 : return cursor();
165 : }
166 :
167 0 : Matrix<Float> * RFFloatLatticeIterator::advance(uInt t1)
168 : {
169 0 : if (iter_pos != t1) flush_curs();
170 0 : iter_pos = t1;
171 0 : update_curs();
172 0 : return cursor();
173 : }
174 :
175 0 : Matrix<Float> * RFFloatLatticeIterator::cursor()
176 : {
177 0 : return &curs;
178 : //return &((*lattice)[iter_pos]);
179 : }
180 :
181 0 : Float & RFFloatLatticeIterator::operator()(uInt i,uInt j)
182 : {
183 0 : return curs(i, j);
184 : //return (*lattice)[iter_pos](i, j);
185 : }
186 :
187 :
188 :
189 :
190 0 : RFFloatLattice::RFFloatLattice ()
191 : {
192 0 : }
193 :
194 0 : RFFloatLattice::RFFloatLattice ( uInt nchan,
195 : uInt nifr,
196 : uInt ntime,
197 : uInt ncorr,
198 : uInt nAgent,
199 0 : Int maxmem )
200 : {
201 0 : init(nchan, nifr, ntime, ncorr, nAgent, maxmem);
202 0 : }
203 0 : RFFloatLattice::RFFloatLattice ( uInt nchan,
204 : uInt nifr,
205 : uInt ntime,
206 : uInt ncorr,
207 : uInt nAgent,
208 : const Float &init_val,
209 0 : Int maxmem )
210 : {
211 0 : init(nchan, nifr, ntime, ncorr, nAgent, init_val, maxmem);
212 0 : }
213 0 : RFFloatLattice::~RFFloatLattice ()
214 : {
215 0 : cleanup();
216 0 : }
217 :
218 : void
219 0 : RFFloatLattice::init(uInt nchan,
220 : uInt nifr,
221 : uInt ntime,
222 : uInt ncorr,
223 : uInt nAgent,
224 : Int /*maxmem*/,
225 : Int /*tile_mb*/)
226 : {
227 0 : n_bit = ncorr + nAgent;
228 :
229 0 : if (n_bit > 32) {
230 0 : stringstream ss;
231 : ss <<
232 0 : "Sorry, too many polarizations (" << ncorr <<
233 0 : ") and agents (" << nAgent << "). Max supported number is 32 in total.";
234 0 : cerr << ss.str();
235 0 : abort();
236 : throw AipsError(ss.str());
237 0 : }
238 :
239 0 : lat_shape = IPosition(3,nchan,nifr,ntime);
240 :
241 0 : lat = std::vector<std::vector<bool> >(ntime);
242 0 : for (unsigned i = 0; i < ntime; i++) {
243 : //lat[i] = Matrix<Float>(IPosition(2, nchan, nifr));
244 0 : lat[i] = std::vector<bool>(nchan * nifr * (ncorr+nAgent));
245 : }
246 :
247 0 : iter = RFFloatLatticeIterator(&lat, nchan, nifr, ntime, ncorr+nAgent, ncorr);
248 0 : }
249 :
250 0 : RFFloatLatticeIterator RFFloatLattice::newIter()
251 : {
252 0 : return RFFloatLatticeIterator(&lat, n_chan, n_ifr, n_time, n_bit, n_corr);
253 : }
254 :
255 0 : void RFFloatLattice::init(uInt nchan,
256 : uInt nifr,
257 : uInt ntime,
258 : uInt ncorr,
259 : uInt nAgent,
260 : const Float &init_val,
261 : Int maxmem,
262 : Int tile_mb)
263 : {
264 0 : n_chan = nchan;
265 0 : n_ifr = nifr;
266 0 : n_time = ntime;
267 0 : n_bit = ncorr + nAgent;
268 0 : n_corr = ncorr;
269 0 : init(nchan, nifr, ntime, ncorr, nAgent, maxmem, tile_mb);
270 : // lat.set(init_val);
271 :
272 0 : uInt nbits = ncorr + nAgent;
273 :
274 : /* Write init_val to every matrix element.
275 : See above for description of format */
276 0 : std::vector<bool> val = bitvec_from_ulong(reinterpret_cast<const unsigned &>(init_val),nbits+1);
277 0 : for (unsigned i = 0; i < ntime; i++) {
278 0 : for (unsigned chan = 0; chan < nchan; chan++) {
279 0 : for (unsigned ifr = 0; ifr < nifr; ifr++) {
280 0 : if (n_corr <= 1) {
281 0 : unsigned indx = 0 + n_bit*(chan + n_chan*ifr);
282 0 : lat[i][indx] = val[0];
283 :
284 0 : for (unsigned b = 1; b < n_bit; b++) {
285 0 : indx = b + n_bit*(chan + n_chan*ifr);
286 0 : lat[i][indx] = val[b+1];
287 : }
288 : }
289 : else {
290 : unsigned indx;
291 0 : for (unsigned b = 0; b < n_bit; b++) {
292 0 : indx = b + n_bit*(chan + n_chan*ifr);
293 :
294 0 : lat[i][indx] = val[b];
295 : }
296 : }
297 : }
298 : }
299 : }
300 0 : }
301 :
302 0 : void RFFloatLattice::cleanup ()
303 : {
304 0 : iter.flush_curs();
305 0 : iter.cursor()->resize(IPosition(2, 0, 0));
306 0 : iter = RFFloatLatticeIterator();
307 0 : lat.resize(0);
308 0 : lat_shape.resize(0);
309 0 : }
310 :
311 0 : Matrix<Float> * RFFloatLattice::reset ( Bool /*r*/,Bool /*w*/ )
312 : {
313 0 : return iter.reset();
314 : }
315 :
316 :
317 : } //# NAMESPACE CASA - END
318 :
|
