Line data Source code
1 : //# CalIntpMatch.cc: Implementation of CalIntpMatch.h
2 : //# Copyright (C) 1996,1997,1998,2001,2002,2003
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 : //----------------------------------------------------------------------------
28 :
29 : #include <synthesis/CalTables/CalIntpMatch.h>
30 : #include <msvis/MSVis/MSCalEnums.h>
31 :
32 : using namespace casacore;
33 : namespace casa { //# NAMESPACE CASA - BEGIN
34 :
35 : //----------------------------------------------------------------------------
36 :
37 0 : CalIntpMatch::CalIntpMatch (const MatchType& matchType, const uInt& indexDim):
38 0 : type_p(matchType),
39 0 : indexDim_p(indexDim),
40 0 : vbIndex_p(0,0),
41 0 : cbIndex_p(0),
42 0 : matchKeys_p(0),
43 0 : vb_p(NULL),
44 0 : cb_p(NULL)
45 : {
46 : // Construct from an interpolation match and index dimentsion
47 : // Input:
48 : // matchType const MatchType& Interpolation match type
49 : // indexDim const uInt& Index dimension
50 : // (1=baseline-based,
51 : // 2=antenna-based)
52 : // Output to private data:
53 : // type_p MatchType Interpolation match type
54 : // indexDim_p Int Index dimension
55 : // vbIndex_p Matrix<Int> Vis. buffer index
56 : // cbIndex_p Block<Vector<Int>> Cal. buffer index
57 : // matchKeys_p PtrBlock<Record*> Match keys
58 : // vb_p VisBuffer* Ptr. to current vis. buffer
59 : // cb_p CalMainBuffer* Ptr. to current cal. buffer
60 0 : };
61 :
62 : //----------------------------------------------------------------------------
63 :
64 0 : void CalIntpMatch::copy (const CalIntpMatch& other)
65 : {
66 : // Private utility function to copy member variables
67 : // Input:
68 : // other const CalIntpMatch& Other CalIntpMatch object
69 : // Output to private data:
70 : // type_p MatchType Interpolation match type
71 : // indexDim_p Int Index dimension
72 : // vbIndex_p Matrix<Int> Vis. buffer index
73 : // cbIndex_p Block<Vector<Int>> Cal. buffer index
74 : // matchKeys_p PtrBlock<Record*> Match keys
75 : // vb_p VisBuffer* Ptr. to current vis. buffer
76 : // cb_p CalMainBuffer* Ptr. to current cal. buffer
77 :
78 : // Member-wise copy
79 0 : type_p = other.type_p;
80 0 : indexDim_p = other.indexDim_p;
81 0 : vbIndex_p = other.vbIndex_p;
82 0 : cbIndex_p = other.cbIndex_p;
83 0 : matchKeys_p = other.matchKeys_p;
84 0 : vb_p = other.vb_p;
85 0 : cb_p = other.cb_p;
86 0 : };
87 :
88 : //----------------------------------------------------------------------------
89 :
90 0 : void CalIntpMatch::free()
91 : {
92 : // Private function to free the lvalue in assignment or copy construction
93 : // A null operation for this class as pointers are to shared objects.
94 0 : };
95 :
96 : //----------------------------------------------------------------------------
97 :
98 0 : CalIntpMatch::~CalIntpMatch()
99 : {
100 : // Destructor (null)
101 : //
102 0 : free();
103 0 : };
104 :
105 : //----------------------------------------------------------------------------
106 :
107 0 : CalIntpMatch::CalIntpMatch (const CalIntpMatch& other)
108 : {
109 : // Copy constructor
110 : // Input:
111 : // other const CalIntpMatch& rvalue CalIntpMatch object
112 : // Output to private data:
113 : // type_p MatchType Interpolation match type
114 : // indexDim_p Int Index dimension
115 : // vbIndex_p Matrix<Int> Vis. buffer index
116 : // cbIndex_p Block<Vector<Int>> Cal. buffer index
117 : // matchKeys_p PtrBlock<Record*> Match keys
118 : // vb_p VisBuffer* Ptr. to current vis. buffer
119 : // cb_p CalMainBuffer* Ptr. to current cal. buffer
120 : //
121 0 : copy (other);
122 0 : };
123 :
124 : //----------------------------------------------------------------------------
125 :
126 0 : CalIntpMatch& CalIntpMatch::operator= (const CalIntpMatch& other)
127 : {
128 : // Assignment operator
129 : // Input:
130 : // other const CalIntpMatch& rvalue CalIntpMatch object
131 : // Output to private data:
132 : // type_p MatchType Interpolation match type
133 : // indexDim_p Int Index dimension
134 : // vbIndex_p Matrix<Int> Vis. buffer index
135 : // cbIndex_p Block<Vector<Int>> Cal. buffer index
136 : // matchKeys_p PtrBlock<Record*> Match keys
137 : // vb_p VisBuffer* Ptr. to current vis. buffer
138 : // cb_p CalMainBuffer* Ptr. to current cal. buffer
139 : //
140 : // Check for identity
141 0 : if (this != &other) {
142 : // Free the lvalue and assign the rvalue
143 0 : free();
144 0 : copy (other);
145 : };
146 0 : return *this;
147 : };
148 :
149 : //----------------------------------------------------------------------------
150 :
151 0 : void CalIntpMatch::setType (const MatchType& matchType, const uInt& indexDim)
152 : {
153 : // Reset the interpolation match type
154 : // Input:
155 : // matchType const MatchType& Interpolation match type
156 : // indexDim const uInt& Index dimension
157 : // (1=baseline-based,
158 : // 2=antenna-based)
159 : // Output to private data:
160 : // type_p MatchType Interpolation match type
161 : // indexDim_p Int Index dimension
162 : //
163 : // Reset the interpolation match type and index dimension
164 0 : type_p = matchType;
165 0 : indexDim_p = indexDim;
166 :
167 : // Reset the index cache
168 0 : reset();
169 0 : return;
170 : };
171 :
172 : //----------------------------------------------------------------------------
173 :
174 0 : void CalIntpMatch::reset()
175 : {
176 : // Reset all local index mappings
177 : // Output to private data:
178 : // vbIndex_p Matrix<Int> Vis. buffer index
179 : // cbIndex_p Block<Vector<Int>> Cal. buffer index
180 : // matchKeys_p PtrBlock<Record*> Match keys
181 : //
182 : // Reset all index mappings
183 0 : resetCalIndex();
184 0 : resetVisIndex();
185 0 : matchKeys_p.resize(0);
186 :
187 0 : return;
188 : };
189 :
190 : //----------------------------------------------------------------------------
191 :
192 0 : void CalIntpMatch::resetVisIndex()
193 : {
194 : // Reset the local visibility index mapping
195 : // Output to private data:
196 : // vbIndex_p Matrix<Int> Vis. buffer index
197 : //
198 : // Reset the visibility index mapping
199 0 : if (vb_p) {
200 0 : vbIndex_p.resize(vb_p->nRow(), indexDim_p);
201 0 : vbIndex_p = 0;
202 : } else {
203 0 : vbIndex_p.resize();
204 : };
205 :
206 0 : return;
207 : };
208 :
209 : //----------------------------------------------------------------------------
210 :
211 0 : void CalIntpMatch::resetCalIndex()
212 : {
213 : // Reset the local calibration index mapping
214 : // Output to private data:
215 : // cbIndex_p Block<Vector<Int>> Cal. buffer index
216 : //
217 : // Reset the calibration index mapping
218 0 : if (cb_p) {
219 0 : cbIndex_p.resize(cb_p->nRow());
220 0 : for (Int i=0; i < static_cast<Int>(cbIndex_p.nelements()); i++) {
221 0 : cbIndex_p[i] = 0;
222 : };
223 : } else {
224 0 : cbIndex_p.resize(0);
225 : };
226 :
227 0 : return;
228 : };
229 :
230 : //----------------------------------------------------------------------------
231 :
232 0 : void CalIntpMatch::setVisBuffer (VisBuffer& vb)
233 : {
234 : // Set the current visibility buffer to be used in interpolation matches
235 : // Input:
236 : // vb VisBuffer& Visibility buffer
237 : // Output to private data:
238 : // vbIndex_p Matrix<Int> Vis. buffer index
239 : // vb_p VisBuffer* Ptr. to current vis. buffer
240 : //
241 : // Update the visibility buffer pointer
242 0 : vb_p = &vb;
243 :
244 : // Reset the visibility buffer index
245 0 : resetVisIndex();
246 :
247 : // Refill the visibility buffer index; loop over all vis. buffer rows
248 0 : for (Int row=0; row < vb_p->nRow(); row++) {
249 : // Define the keys for this row
250 0 : PtrBlock<Record* > keys(indexDim_p);
251 :
252 0 : switch (type_p) {
253 0 : case MATCHING_ANT_SPW:
254 0 : keys[0] = new Record();
255 0 : keys[0]->define(MSC::fieldName(MSC::ANTENNA1), vb.antenna1()(row));
256 0 : keys[0]->define(MSC::fieldName(MSC::SPECTRAL_WINDOW_ID),
257 0 : vb.spectralWindow());
258 0 : keys[1] = new Record();
259 0 : keys[1]->define(MSC::fieldName(MSC::ANTENNA1), vb.antenna2()(row));
260 0 : keys[1]->define(MSC::fieldName(MSC::SPECTRAL_WINDOW_ID),
261 0 : vb.spectralWindow());
262 0 : break;
263 :
264 0 : default:
265 0 : break;
266 : };
267 :
268 : // Match the row keys in the key index and set the
269 : // visibility index accordingly
270 0 : for (Int i=0; i < indexDim_p; i++) {
271 0 : vbIndex_p(row,i) = matchOrAddKey (*keys[i]);
272 : };
273 0 : };
274 :
275 0 : return;
276 : };
277 :
278 : //----------------------------------------------------------------------------
279 :
280 0 : void CalIntpMatch::setCalBuffer (CalMainBuffer& cb)
281 : {
282 : // Set the current calibration buffer to be used in interpolation matches
283 : // Input:
284 : // cb CalMainBuffer& Calibration buffer
285 : // Output to private data:
286 : // cbIndex_p Block<Vector<Int>> Cal. buffer index
287 : // matchKeys_p PtrBlock<Record*> Match keys
288 : // cb_p CalMainBuffer* Ptr. to current cal. buffer
289 : //
290 : // Update the calibration buffer pointer
291 0 : cb_p = &cb;
292 :
293 : // Reset the calibration buffer index
294 0 : resetCalIndex();
295 :
296 : // Refill the calibration buffer index; loop over all cal. buffer rows
297 0 : for (Int row=0; row < cb_p->nRow(); row++) {
298 : // Define the keys for this row
299 0 : PtrBlock<Record* > keys;
300 :
301 : // Extract cal_desc buffer reference and cal_desc id.
302 0 : CalDescBuffer& cdb = cb.calDescBuffer();
303 0 : Int calDescId = cb.calDescId()(row);
304 :
305 0 : switch (type_p) {
306 0 : case MATCHING_ANT_SPW: {
307 0 : Int numSpw = cdb.numSpw()(calDescId);
308 0 : keys.resize(numSpw, true, true);
309 0 : for (Int iSpw=0; iSpw < numSpw; iSpw++) {
310 0 : keys[iSpw] = new Record();
311 0 : keys[iSpw]->define(MSC::fieldName(MSC::ANTENNA1), cb.antenna1()(row));
312 0 : keys[iSpw]->define(MSC::fieldName(MSC::SPECTRAL_WINDOW_ID),
313 0 : cdb.spwId()(calDescId,iSpw));
314 : };
315 0 : break;
316 : }
317 :
318 0 : default: {
319 0 : break;
320 : };
321 : };
322 :
323 : // Match the row keys in the key index and set the
324 : // calibration index accordingly
325 0 : Int nKeys = keys.nelements();
326 0 : cbIndex_p[row].resize(nKeys, true);
327 0 : for (Int i=0; i < nKeys; i++) {
328 0 : cbIndex_p[row](i) = matchOrAddKey (*keys[i]);
329 : };
330 0 : };
331 0 : return;
332 : };
333 :
334 : //----------------------------------------------------------------------------
335 :
336 0 : Int CalIntpMatch::matchOrAddKey (const Record& key)
337 : {
338 : // Match or add index keys
339 : // Input:
340 : // key const Record& Index key
341 : // Output:
342 : // matchOrAddKey Int Index key id.
343 : //
344 : // Search existing keys
345 0 : Int nKeys = matchKeys_p.nelements();
346 :
347 0 : for (Int i=0; i < nKeys; i++) {
348 : // Match the key entry
349 0 : Bool match = true;
350 0 : for (uInt j=0; j < key.nfields(); j++) {
351 0 : if (matchKeys_p[i]->asInt(j) != key.asInt(j)) {
352 0 : match = false;
353 : };
354 : };
355 0 : if (match) return i;
356 : };
357 :
358 : // Add a new key entry
359 0 : matchKeys_p.resize(nKeys+1, true, true);
360 0 : matchKeys_p[nKeys] = new Record(key);
361 :
362 0 : return nKeys;
363 : };
364 :
365 : //----------------------------------------------------------------------------
366 :
367 0 : Vector<Int> CalIntpMatch::calRows (const Int& matchIndex,
368 : LogicalArray& calRowMask)
369 : {
370 : // Return the calibration buffer rows (and equivalent row mask)
371 : // for a given match index value
372 : // Input:
373 : // matchIndex const Int& Key index value to match
374 : // Output:
375 : // calRowMask LogicalArray& Matching calibration buffer
376 : // rows (as Boolean mask)
377 : // calRows Vector<Int> Matching calibration buffer
378 : // row numbers
379 : //
380 : // Initialization
381 0 : calRowMask.resize(IPosition(1,cb_p->nRow()));
382 0 : calRowMask = false;
383 0 : Vector<Int> retval(cb_p->nRow());
384 0 : Int nMatch = 0;
385 :
386 : // Iterate through the calibration buffer key index
387 0 : for (uInt row=0; row < cbIndex_p.nelements(); row++) {
388 0 : for (uInt col=0; col < cbIndex_p[row].nelements(); col++) {
389 0 : if (cbIndex_p[row](col) == matchIndex) {
390 0 : retval(nMatch) = row;
391 0 : calRowMask(IPosition(1,nMatch)) = true;
392 0 : nMatch++;
393 : };
394 : };
395 : };
396 :
397 0 : retval.resize(nMatch, true);
398 0 : return retval;
399 0 : };
400 :
401 : //----------------------------------------------------------------------------
402 :
403 :
404 :
405 :
406 : } //# NAMESPACE CASA - END
407 :
|
