Line data Source code
1 : //# SolvableVJMBuf.cc: Implementation of SolvableVJMBuf.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/SolvableVJMBuf.h>
30 : #include <casacore/casa/Arrays/ArrayMath.h>
31 : #include <casacore/tables/Tables/RefRows.h>
32 :
33 : using namespace casacore;
34 : namespace casa { //# NAMESPACE CASA - BEGIN
35 :
36 : //----------------------------------------------------------------------------
37 :
38 0 : SolvableVisJonesMBuf::SolvableVisJonesMBuf() : TimeVarVisJonesMBuf()
39 : {
40 : // Null constructor
41 : // Output to private data:
42 : // totalSolnOk_p Vector<Bool> Validity of total solution
43 : // totalFit_p Vector<Float> Total fit
44 : // totalFitWgt_p Vector<Float> Total fit weight
45 : // solnOk_p Array<Bool> Solution validity mask
46 : // fitOK_p Array<Float> Fit array
47 : // fitWgt_p Array<Float> Fit weight array
48 : // totalSolnOkOK_p Bool Total solution vailidity cache ok
49 : // totalFitOK_p Bool Total fit cache ok
50 : // totalFitWgtOK_p Bool Total fit weight cache ok
51 : // solnOkOK_p Bool Solution validity mask cache ok
52 : // fitOK_p Bool Fit array cache ok
53 : // fitWgtOK_p Bool Fit weight array cache ok
54 : // flagOK_p Bool flag array cache ok
55 : // snrOK_p Bool snr array cache ok
56 : //
57 : // Invalidate cache
58 0 : invalidate();
59 0 : };
60 :
61 : //----------------------------------------------------------------------------
62 :
63 1 : SolvableVisJonesMBuf::SolvableVisJonesMBuf (const Vector<Int>& calIndices,
64 : const Block<Vector<Int> >&
65 1 : indexValues) :
66 1 : TimeVarVisJonesMBuf (calIndices, indexValues)
67 : {
68 : // Construct from a set of cal buffer indices and specified index values
69 : // Output to private data:
70 : // TimeVarVisJonesMBuf TimeVarVisJonesMBuf Parent class cal main
71 : // table buffer
72 : // Set local non-index columns to default values
73 1 : fillAttributes (calIndices);
74 1 : };
75 :
76 : //----------------------------------------------------------------------------
77 :
78 0 : SolvableVisJonesMBuf::SolvableVisJonesMBuf (CalIterBase& calIter)
79 0 : : TimeVarVisJonesMBuf (calIter)
80 : {
81 : // Construct from a calibration table iterator
82 : // Input:
83 : // calIter CalIterBase& Calibration table iterator
84 : // Output to private data:
85 : // totalSolnOk_p Vector<Bool> Validity of total solution
86 : // totalFit_p Vector<Float> Total fit
87 : // totalFitWgt_p Vector<Float> Total fit weight
88 : // solnOk_p Array<Bool> Solution validity mask
89 : // fitOK_p Array<Float> Fit array
90 : // fitWgt_p Array<Float> Fit weight array
91 : // totalSolnOkOK_p Bool Total solution vailidity cache ok
92 : // totalFitOK_p Bool Total fit cache ok
93 : // totalFitWgtOK_p Bool Total fit weight cache ok
94 : // solnOkOK_p Bool Solution validity mask cache ok
95 : // fitOK_p Bool Fit array cache ok
96 : // fitWgtOK_p Bool Fit weight array cache ok
97 : // flagOK_p Bool flag array cache ok
98 : // snrOK_p Bool snr array cache ok
99 : //
100 : // Invalidate cache
101 0 : invalidate();
102 0 : };
103 :
104 : //----------------------------------------------------------------------------
105 :
106 1 : Int SolvableVisJonesMBuf::append (CalTable& calTable)
107 : {
108 : // Append the current calibration buffer to a calibration table
109 : // Input:
110 : // calTable CalTable& Calibration table
111 : // Output:
112 : // append Int No. of rows appended
113 : //
114 : // Extend the inherited parent method
115 1 : Int nAdded = CalMainBuffer::append(calTable);
116 :
117 : // Compute the rows added in the parent class
118 1 : Int endRow = calTable.nRowMain() - 1;
119 1 : Int startRow = endRow - nAdded + 1;
120 :
121 : // Attach a cal table columns accessor
122 : SolvableVisJonesMCol svjMainCol
123 1 : (dynamic_cast<SolvableVisJonesTable&>(calTable));
124 :
125 : // Append the current cal buffer cal_main columns
126 1 : RefRows refRows(startRow, endRow);
127 1 : svjMainCol.totalSolnOk().putColumnCells(refRows, totalSolnOk());
128 1 : svjMainCol.totalFit().putColumnCells(refRows, totalFit());
129 1 : svjMainCol.totalFitWgt().putColumnCells(refRows, totalFitWgt());
130 1 : svjMainCol.solnOk().putColumnCells(refRows, solnOk());
131 1 : svjMainCol.fit().putColumnCells(refRows, fit());
132 1 : svjMainCol.fitWgt().putColumnCells(refRows, fitWgt());
133 1 : svjMainCol.flag().putColumnCells(refRows, flag());
134 1 : svjMainCol.snr().putColumnCells(refRows, snr());
135 :
136 1 : return nAdded;
137 1 : };
138 :
139 : //----------------------------------------------------------------------------
140 :
141 24 : Int SolvableVisJonesMBuf::nRow()
142 : {
143 : // Return the maximum number of rows in the cal buffer
144 : // Input from private data:
145 : // totalSolnOk_p Vector<Bool> Validity of total solution
146 : // totalFit_p Vector<Float> Total fit
147 : // totalFitWgt_p Vector<Float> Total fit weight
148 : // solnOk_p Array<Bool> Solution validity mask
149 : // fitOK_p Array<Float> Fit array
150 : // fitWgt_p Array<Float> Fit weight array
151 : // totalSolnOkOK_p Bool Total solution vailidity cache ok
152 : // totalFitOK_p Bool Total fit cache ok
153 : // totalFitWgtOK_p Bool Total fit weight cache ok
154 : // solnOkOK_p Bool Solution validity mask cache ok
155 : // fitOK_p Bool Fit array cache ok
156 : // fitWgtOK_p Bool Fit weight array cache ok
157 : // Output:
158 : // nRow Int Max. no. of rows in the buffer
159 : //
160 : // Extend the inherited parent method
161 24 : Int nRowParent = CalMainBuffer::nRow();
162 :
163 : // Process each local column individually
164 24 : Vector<Int> colLength(9);
165 24 : Int n = 0;
166 24 : colLength(n++) = nRowParent;
167 24 : colLength(n++) = totalSolnOk().nelements();
168 24 : colLength(n++) = totalFit().nelements();
169 24 : colLength(n++) = totalFitWgt().nelements();
170 47 : colLength(n++) = solnOk().shape().nelements() > 0 ?
171 47 : solnOk().shape().getLast(1)(0) : 0;
172 47 : colLength(n++) = fit().shape().nelements() > 0 ?
173 47 : fit().shape().getLast(1)(0) : 0;
174 47 : colLength(n++) = fitWgt().shape().nelements() > 0 ?
175 47 : fitWgt().shape().getLast(1)(0) : 0;
176 47 : colLength(n++) = flag().shape().nelements() > 0 ?
177 47 : flag().shape().getLast(1)(0) : 0;
178 47 : colLength(n++) = snr().shape().nelements() > 0 ?
179 47 : snr().shape().getLast(1)(0) : 0;
180 :
181 48 : return max(colLength);
182 24 : };
183 :
184 : //----------------------------------------------------------------------------
185 :
186 27 : Vector<Bool>& SolvableVisJonesMBuf::totalSolnOk()
187 : {
188 : // TOTAL_SOLUTION_OK data field accessor
189 : // Input from private data:
190 : // totalSolnOk_p Vector<Bool> Validity of total solution
191 : //
192 : // Fill local cache for this column if cache not valid
193 27 : if (connectedToIter()) {
194 0 : if (!totalSolnOkOK_p) {
195 0 : calMainCol()->totalSolnOk().getColumn (totalSolnOk_p);
196 0 : totalSolnOkOK_p = true;
197 : };
198 : };
199 27 : return totalSolnOk_p;
200 : };
201 :
202 : //----------------------------------------------------------------------------
203 :
204 27 : Vector<Float>& SolvableVisJonesMBuf::totalFit()
205 : {
206 : // TOTAL_FIT data field accessor
207 : // Input from private data:
208 : // totalFit_p Vector<Float> Total fit
209 : //
210 : // Fill local cache for this column if cache not valid
211 27 : if (connectedToIter()) {
212 0 : if (!totalFitOK_p) {
213 0 : calMainCol()->totalFit().getColumn (totalFit_p);
214 0 : totalFitOK_p = true;
215 : };
216 : };
217 27 : return totalFit_p;
218 : };
219 :
220 : //----------------------------------------------------------------------------
221 :
222 27 : Vector<Float>& SolvableVisJonesMBuf::totalFitWgt()
223 : {
224 : // TOTAL_FIT_WEIGHT data field accessor
225 : // Input from private data:
226 : // totalFitWgt_p Vector<Float> Total fit weight
227 : //
228 : // Fill local cache for this column if cache not valid
229 27 : if (connectedToIter()) {
230 0 : if (!totalFitWgtOK_p) {
231 0 : calMainCol()->totalFitWgt().getColumn (totalFitWgt_p);
232 0 : totalFitWgtOK_p = true;
233 : };
234 : };
235 27 : return totalFitWgt_p;
236 : };
237 :
238 : //----------------------------------------------------------------------------
239 :
240 50 : Array<Bool>& SolvableVisJonesMBuf::solnOk()
241 : {
242 : // SOLUTION_OK data field accessor
243 : // Input from private data:
244 : // solnOk_p Array<Bool> Solution validity mask
245 : //
246 : // Fill local cache for this column if cache not valid
247 50 : if (connectedToIter()) {
248 0 : if (!solnOkOK_p) {
249 0 : calMainCol()->solnOk().getColumn (solnOk_p);
250 0 : solnOkOK_p = true;
251 : };
252 : };
253 50 : return solnOk_p;
254 : };
255 :
256 : //----------------------------------------------------------------------------
257 :
258 50 : Array<Float>& SolvableVisJonesMBuf::fit()
259 : {
260 : // FIT data field accessor
261 : // Input from private data:
262 : // fit_p Array<Float> Fit array
263 : //
264 : // Fill local cache for this column if cache not valid
265 50 : if (connectedToIter()) {
266 0 : if (!fitOK_p) {
267 0 : calMainCol()->fit().getColumn (fit_p);
268 0 : fitOK_p = true;
269 : };
270 : };
271 50 : return fit_p;
272 : };
273 :
274 : //----------------------------------------------------------------------------
275 :
276 50 : Array<Float>& SolvableVisJonesMBuf::fitWgt()
277 : {
278 : // FIT_WGT data field accessor
279 : // Input from private data:
280 : // fitWgt_p Array<Float> Fit weight array
281 : //
282 : // Fill local cache for this column if cache not valid
283 50 : if (connectedToIter()) {
284 0 : if (!fitWgtOK_p) {
285 0 : calMainCol()->fitWgt().getColumn (fitWgt_p);
286 0 : fitWgtOK_p = true;
287 : };
288 : };
289 50 : return fitWgt_p;
290 : };
291 :
292 : //----------------------------------------------------------------------------
293 :
294 50 : Array<Bool>& SolvableVisJonesMBuf::flag()
295 : {
296 : // FLAG data field accessor
297 : // Input from private data:
298 : // flag_p Array<Bool> Solution flags mask
299 : //
300 : // Fill local cache for this column if cache not valid
301 50 : if (connectedToIter()) {
302 0 : if (!flagOK_p) {
303 0 : calMainCol()->flag().getColumn (flag_p);
304 0 : flagOK_p = true;
305 : };
306 : };
307 50 : return flag_p;
308 : };
309 :
310 : //----------------------------------------------------------------------------
311 :
312 50 : Array<Float>& SolvableVisJonesMBuf::snr()
313 : {
314 : // SNR data field accessor
315 : // Input from private data:
316 : // snr_p Array<Float> Snr array
317 : //
318 : // Fill local cache for this column if cache not valid
319 50 : if (connectedToIter()) {
320 0 : if (!snrOK_p) {
321 0 : calMainCol()->snr().getColumn (snr_p);
322 0 : snrOK_p = true;
323 : };
324 : };
325 50 : return snr_p;
326 : };
327 :
328 : //----------------------------------------------------------------------------
329 :
330 0 : void SolvableVisJonesMBuf::invalidate()
331 : {
332 : // Invalidate the current cache
333 : // Output to private data:
334 : // totalSolnOkOK_p Bool Total solution vailidity cache ok
335 : // totalFitOK_p Bool Total fit cache ok
336 : // totalFitWgtOK_p Bool Total fit weight cache ok
337 : // solnOkOK_p Bool Solution validity mask cache ok
338 : // fitOK_p Bool Fit array cache ok
339 : // fitWgtOK_p Bool Fit weight array cache ok
340 : // flagOK_p Bool Flag array cache ok
341 : // snrOK_p Bool Snr array cache ok
342 : //
343 : // Invalidate parent class cache
344 0 : CalMainBuffer::invalidate();
345 :
346 : // Set all cache flags to false
347 0 : totalSolnOkOK_p = false;
348 0 : totalFitOK_p = false;
349 0 : totalFitWgtOK_p = false;
350 0 : solnOkOK_p = false;
351 0 : fitOK_p = false;
352 0 : fitWgtOK_p = false;
353 0 : flagOK_p = false;
354 0 : snrOK_p = false;
355 0 : };
356 :
357 : //----------------------------------------------------------------------------
358 :
359 1 : void SolvableVisJonesMBuf::fillAttributes (const Vector<Int>& /*calIndices*/)
360 : {
361 : // Resize all attribute columns and set to their default values
362 : // Input:
363 : // calIndices const Vector<Int.& Vector of cal indices, specified
364 : // as enums from class MSCalEnums,
365 : // to exclude
366 : // Output to private data:
367 : // totalSolnOk_p Vector<Bool> Validity of total solution
368 : // totalFit_p Vector<Float> Total fit
369 : // totalFitWgt_p Vector<Float> Total fit weight
370 : // solnOk_p Array<Bool> Solution validity mask
371 : // fitOK_p Array<Float> Fit array
372 : // fitWgt_p Array<Float> Fit weight array
373 : //
374 : // Use the maximum number of rows currently defined in the cal buffer
375 1 : uInt nrow = nRow();
376 :
377 : // Process each local column separately
378 : //
379 : // TOTAL_SOLUTION_OK
380 1 : totalSolnOk().resize(nrow);
381 1 : totalSolnOk() = false;
382 :
383 : // TOTAL_FIT
384 1 : totalFit().resize(nrow);
385 1 : totalFit() = 0;
386 :
387 : // TOTAL_FIT_WEIGHT
388 1 : totalFitWgt().resize(nrow);
389 1 : totalFitWgt() = 0;
390 :
391 : // Array-based columns; set to default unit dimensions
392 1 : uInt numSpw = 1;
393 1 : uInt numChan = 1;
394 1 : uInt nJones = 1;
395 1 : IPosition sizeA(5, nJones, nJones, numSpw, numChan, nrow);
396 :
397 : // SOLUTION_OK
398 1 : solnOk().resize(sizeA);
399 1 : solnOk() = false;
400 :
401 : // FIT
402 1 : fit().resize(sizeA);
403 1 : fit() = 0;
404 :
405 : // FIT_WEIGHT
406 1 : fitWgt().resize(sizeA);
407 1 : fitWgt() = 0;
408 :
409 : // FLAG
410 1 : flag().resize(sizeA);
411 1 : flag() = true;
412 :
413 : // SNR
414 1 : snr().resize(sizeA);
415 1 : snr() = 0;
416 :
417 :
418 2 : return;
419 1 : };
420 :
421 : //----------------------------------------------------------------------------
422 :
423 0 : GJonesMBuf::GJonesMBuf() : SolvableVisJonesMBuf()
424 : {
425 : // Null constructor
426 0 : };
427 :
428 : //----------------------------------------------------------------------------
429 :
430 1 : GJonesMBuf::GJonesMBuf (const Vector<Int>& calIndices,
431 1 : const Block<Vector<Int> >& indexValues) :
432 1 : SolvableVisJonesMBuf (calIndices, indexValues)
433 : {
434 : // Construct from a set of cal buffer indices and specified index values
435 : // Output to private data:
436 : // SolvableVisJonesMBuf SolvableVisJonesMBuf Parent class cal main
437 : // table buffer
438 1 : };
439 :
440 : //----------------------------------------------------------------------------
441 :
442 0 : GJonesMBuf::GJonesMBuf (CalIterBase& calIter)
443 0 : : SolvableVisJonesMBuf (calIter)
444 : {
445 : // Construct from a calibration table iterator
446 : // Input:
447 : // calIter CalIterBase& Calibration table iterator
448 0 : };
449 :
450 : //----------------------------------------------------------------------------
451 :
452 0 : Bool GJonesMBuf::fillMatchingRows (const Vector<Int>& matchingRows,
453 : const String& sFreqGrpName,
454 : const Complex& sGain,
455 : const MFrequency& sRefFreq,
456 : const Int& sRefAnt)
457 : {
458 : // Update the calibration solution in each of a set of buffer rows
459 : // Input:
460 : // matchingRows const Vec<Int>& Buffer rows to update
461 : // sFreqGrpName const String& Freq. group name
462 : // sGain const Complex& Correction factor
463 : // sRefFreq const MFrequency& Reference frequency
464 : // sRefAnt const Int & Reference antenna id.
465 : //
466 : // Initialization
467 0 : Bool retval = false;
468 0 : Int nMatch = matchingRows.nelements();
469 :
470 0 : if (nMatch > 0) {
471 0 : retval = true;
472 : // Update each matched row
473 0 : for (Int i=0; i < nMatch; i++) {
474 0 : uInt row = matchingRows(i);
475 0 : freqGrpName()(row) = sFreqGrpName;
476 :
477 : // Update all array elements
478 0 : IPosition gainShape = gain().shape();
479 :
480 0 : for (Int recep=0; recep < gainShape(0); recep++) {
481 0 : for (Int spw=0; spw < gainShape(1); spw++) {
482 0 : IPosition ipos3(3, recep, spw, row);
483 : // Reference frequency and antenna
484 0 : refFreqMeas()(ipos3) = sRefFreq;
485 0 : refAnt()(ipos3) = sRefAnt;
486 :
487 : // Gain factor
488 0 : IPosition ipos4(4, recep, recep, spw, row);
489 0 : gain()(ipos4) = sGain;
490 0 : };
491 : };
492 0 : };
493 : };
494 0 : return retval;
495 : };
496 : //----------------------------------------------------------------------------
497 :
498 0 : DJonesMBuf::DJonesMBuf() : SolvableVisJonesMBuf()
499 : {
500 : // Null constructor
501 0 : };
502 :
503 : //----------------------------------------------------------------------------
504 :
505 0 : DJonesMBuf::DJonesMBuf (const Vector<Int>& calIndices,
506 0 : const Block<Vector<Int> >& indexValues) :
507 0 : SolvableVisJonesMBuf (calIndices, indexValues)
508 : {
509 : // Construct from a set of cal buffer indices and specified index values
510 : // Output to private data:
511 : // SolvableVisJonesMBuf SolvableVisJonesMBuf Parent class cal main
512 : // table buffer
513 0 : };
514 :
515 : //----------------------------------------------------------------------------
516 :
517 0 : DJonesMBuf::DJonesMBuf (CalIterBase& calIter)
518 0 : : SolvableVisJonesMBuf (calIter)
519 : {
520 : // Construct from a calibration table iterator
521 : // Input:
522 : // calIter CalIterBase& Calibration table iterator
523 0 : };
524 :
525 : //----------------------------------------------------------------------------
526 :
527 0 : TJonesMBuf::TJonesMBuf() : SolvableVisJonesMBuf()
528 : {
529 : // Null constructor
530 0 : };
531 :
532 : //----------------------------------------------------------------------------
533 :
534 0 : TJonesMBuf::TJonesMBuf (const Vector<Int>& calIndices,
535 0 : const Block<Vector<Int> >& indexValues) :
536 0 : SolvableVisJonesMBuf (calIndices, indexValues)
537 : {
538 : // Construct from a set of cal buffer indices and specified index values
539 : // Output to private data:
540 : // SolvableVisJonesMBuf SolvableVisJonesMBuf Parent class cal main
541 : // table buffer
542 0 : };
543 :
544 : //----------------------------------------------------------------------------
545 :
546 0 : TJonesMBuf::TJonesMBuf (CalIterBase& calIter)
547 0 : : SolvableVisJonesMBuf (calIter)
548 : {
549 : // Construct from a calibration table iterator
550 : // Input:
551 : // calIter CalIterBase& Calibration table iterator
552 0 : };
553 :
554 : //----------------------------------------------------------------------------
555 :
556 :
557 :
558 : } //# NAMESPACE CASA - END
559 :
|
