Line data Source code
1 : //# CTMainColumns.cc: Implementation of CTMainColumns.h
2 : //# Copyright (C) 2011
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/CTMainColumns.h>
30 : #include <synthesis/CalTables/RIorAParray.h>
31 : #include <casacore/casa/Arrays/ArrayMath.h>
32 :
33 :
34 : using namespace casacore;
35 : namespace casa { //# NAMESPACE CASA - BEGIN
36 :
37 : //----------------------------------------------------------------------------
38 :
39 384 : CTMainColumns::CTMainColumns(NewCalTable& calTable)
40 : {
41 : // Construct from a new calibration table
42 : // Input:
43 : // Input:
44 : // calTable const NewCalTable& Calibration table
45 : // Output to private data:
46 : // time_p ScalarColumn<Double>& Time
47 : // timeMeas_p ScalarMeasColumn<MEpoch>& Time as a Measure
48 : // timeEP_p ScalarColumn<Double>& Extended precision time
49 : // timeEPQuant_p ScalarQuantColumn<Double>& EP time as Quantum
50 : // interval_p ScalarColumn<Double>& Time interval
51 : // intervalQuant_p ScalarQuantColumn<Double>& Time interval as Quantum
52 : // antenna1_p ScalarColumn<Int>& Antenna 1
53 : // antenna2_p ScalarColumn<Int>& Antenna 2
54 : // fieldId_p ScalarColumn<Int>& Field id.
55 : // spwId_p ScalarColumn<Int>& Spectral window id.
56 : // scanNo_p ScalarColumn<Int>& Scan no.
57 : // obsId_p ScalarColumn<Int>& Obs Id
58 : // param_p ArrayColumn<Complex>& Cal solution params.
59 : // paramerr_p ArrayColumn<Float>& Cal solution error
60 : // flag_p ArrayColumn<Bool>& Ref. dir. as Measure
61 : // snr_p ArrayColumn<Float>& Solution SNR
62 : // weight_p ArrayColumn<Float>& Solution weight
63 : //
64 : // Attach all the column accessors (including required and
65 : // optional columns)
66 384 : attach (calTable, time_p, NCT::TIME);
67 384 : attach (calTable, timeQuant_p, NCT::TIME);
68 384 : attach (calTable, timeMeas_p, NCT::TIME);
69 384 : attach (calTable, timeEP_p, NCT::TIME_EXTRA_PREC, true);
70 384 : attach (calTable, timeEPQuant_p, NCT::TIME_EXTRA_PREC, true);
71 384 : attach (calTable, interval_p, NCT::INTERVAL);
72 384 : attach (calTable, intervalQuant_p, NCT::INTERVAL);
73 384 : attach (calTable, fieldId_p, NCT::FIELD_ID);
74 384 : attach (calTable, spwId_p, NCT::SPECTRAL_WINDOW_ID);
75 384 : attach (calTable, antenna1_p, NCT::ANTENNA1);
76 384 : attach (calTable, antenna2_p, NCT::ANTENNA2);
77 384 : attach (calTable, scanNo_p, NCT::SCAN_NUMBER);
78 384 : attach (calTable, obsId_p, NCT::OBSERVATION_ID,true); // optional for now
79 :
80 : // {C,F}PARAM columns are optional, exactly one should
81 : // be present
82 384 : attach (calTable, cparam_p, NCT::CPARAM, true);
83 384 : attach (calTable, fparam_p, NCT::FPARAM, true);
84 :
85 384 : attach (calTable, paramerr_p, NCT::PARAMERR);
86 384 : attach (calTable, flag_p, NCT::FLAG);
87 384 : attach (calTable, snr_p, NCT::SNR);
88 384 : attach (calTable, weight_p, NCT::WEIGHT);
89 : //cerr<<"CTMainColumns instantiated"<<endl;
90 : //cerr<<"CTMainColumns ctor: caltable name="<<calTable.tableName()<<endl;
91 384 : };
92 :
93 : //----------------------------------------------------------------------------
94 :
95 : // Some additional methods to extract into Array<Float> generically
96 : // what can be: "","AP",...TBD
97 0 : Array<Float> ROCTMainColumns::fparamArray(String what,const Vector<uInt>& rows) {
98 : // Delegate to in-place method
99 0 : Array<Float> f;
100 0 : fparamArray(f,what,rows);
101 0 : return f;
102 0 : }
103 0 : void ROCTMainColumns::fparamArray(Array<Float>& arr,String what,const Vector<uInt>& rows) {
104 0 : Bool byrow=(rows.nelements()>0);
105 0 : if (what=="") {
106 : // Get out Float values however possible
107 0 : if (!fparam().isNull()) {
108 0 : if (byrow)
109 0 : fparam().getColumnCells(RefRows(rows),arr);
110 : else
111 0 : fparam().getColumn(arr);
112 : }
113 0 : else if (!cparam().isNull()) {
114 : // Get amp/phase (tracked) by default
115 0 : if (byrow) {
116 0 : RIorAPArray ap(cparam().getColumnCells(RefRows(rows)));
117 0 : arr=ap.f(true); // Tracks phase
118 0 : }
119 : else {
120 0 : RIorAPArray ap(cparam().getColumn());
121 0 : arr=ap.f(true); // Tracks phase
122 0 : }
123 : }
124 : else
125 0 : throw(AipsError("Someting wrong with the caltable!"));
126 :
127 0 : return;
128 : }
129 0 : if (what=="AP") {
130 : // Convert to Amp/Ph, with Ph tracked
131 0 : if (byrow) {
132 0 : RIorAPArray ap(cparam().getColumnCells(RefRows(rows)));
133 0 : arr=ap.f(true); // Tracks phase
134 0 : }
135 : else {
136 0 : RIorAPArray ap(cparam().getColumn());
137 0 : arr=ap.f(true); // Tracks phase
138 0 : }
139 0 : return;
140 : }
141 : }
142 :
143 0 : Array<Float> ROCTMainColumns::phase() {
144 0 : Array<Float> ph;
145 0 : this->phase(ph);
146 0 : return ph;
147 0 : }
148 :
149 0 : void ROCTMainColumns::phase(Array<Float>& ph) {
150 0 : if (!cparam().isNull())
151 0 : ph.assign(casacore::phase(cparam().getColumn()));
152 : else
153 0 : throw(AipsError("ROCTMainColumns cannot extract phase without CPARAM column."));
154 0 : }
155 :
156 0 : Array<Float> ROCTMainColumns::cycles() {
157 0 : Array<Float> c;
158 0 : this->cycles(c);
159 0 : return c;
160 0 : }
161 :
162 0 : void ROCTMainColumns::cycles(Array<Float>& cy) {
163 0 : this->phase(cy); // Extract phase
164 0 : cy+=Float(C::pi); // add a half-cycle
165 0 : cy/=Float(C::_2pi); // divide by rad/cycle
166 0 : cy=floor(cy); // integer part is cycles
167 0 : cy*=Float(C::_2pi); // in radians
168 0 : }
169 :
170 :
171 : //----------------------------------------------------------------------------
172 :
173 5760 : void CTMainColumns::attach (NewCalTable& calTable,
174 : TableColumn& tabCol,
175 : CTEnums::colDef colEnum,
176 : const Bool& optional)
177 : {
178 : // Attach a column accessor to the calibration table
179 : // Input:
180 : // calTable CalTable& Calibration table
181 : // tabCol TableColumn& Table column accessor
182 : // colEnum CTEnums::colDef Column enum
183 : // optional const Bool& true if optional column
184 : // Output to private data:
185 : //
186 : // Convert to column name
187 5760 : String colName = NCT::fieldName (colEnum);
188 :
189 : // Check if an optional column
190 5760 : if (optional) {
191 1536 : if (calTable.tableDesc().isColumn(colName)) {
192 768 : tabCol.attach (calTable, colName);
193 : };
194 : } else {
195 4224 : tabCol.attach (calTable, colName);
196 : };
197 5760 : };
198 :
199 : //----------------------------------------------------------------------------
200 :
201 0 : void CTMainColumns::attach (NewCalTable& calTable,
202 : ArrayMeasColumn<MEpoch>& tabCol,
203 : CTEnums::colDef colEnum,
204 : const Bool& optional)
205 : {
206 : // Attach a column accessor to the calibration table
207 : // Input:
208 : // calTable NewCalTable& Calibration table
209 : // tabCol ArrayMeasColumn<MEpoch>& Table measures column
210 : // accessor
211 : // colEnum CTEnums::colDef Column enum
212 : // optional const Bool& true if optional column
213 : // Output to private data:
214 : //
215 : // Convert to column name
216 0 : String colName = NCT::fieldName (colEnum);
217 :
218 : // Check if an optional column
219 0 : if (optional) {
220 0 : if (calTable.tableDesc().isColumn(colName)) {
221 0 : tabCol.attach (calTable, colName);
222 : };
223 : } else {
224 0 : tabCol.attach (calTable, colName);
225 : };
226 0 : };
227 :
228 : //----------------------------------------------------------------------------
229 :
230 0 : void CTMainColumns::attach (NewCalTable& calTable,
231 : ArrayMeasColumn<MFrequency>& tabCol,
232 : CTEnums::colDef colEnum,
233 : const Bool& optional)
234 : {
235 : // Attach a column accessor to the calibration table
236 : // Input:
237 : // calTable CalTable& Calibration table
238 : // tabCol ArrayMeasColumn<MFrequency>& Table measures column
239 : // accessor
240 : // colEnum CTEnums::colDef Column enum
241 : // optional const Bool& true if optional column
242 : // Output to private data:
243 : //
244 : // Convert to column name
245 0 : String colName = NCT::fieldName (colEnum);
246 :
247 : // Check if an optional column
248 0 : if (optional) {
249 0 : if (calTable.tableDesc().isColumn(colName)) {
250 0 : tabCol.attach (calTable, colName);
251 : };
252 : } else {
253 0 : tabCol.attach (calTable, colName);
254 : };
255 0 : };
256 :
257 : //----------------------------------------------------------------------------
258 :
259 0 : void CTMainColumns::attach (NewCalTable& calTable,
260 : ArrayMeasColumn<MDirection>& tabCol,
261 : CTEnums::colDef colEnum,
262 : const Bool& optional)
263 : {
264 : // Attach a column accessor to the calibration table
265 : // Input:
266 : // calTable NewCalTable& Calibration table
267 : // tabCol ArrayMeasColumn<MDirection>& Table measures column
268 : // accessor
269 : // colEnum CTEnums::colDef Column enum
270 : // optional const Bool& true if optional column
271 : // Output to private data:
272 : //
273 : // Convert to column name
274 0 : String colName = NCT::fieldName (colEnum);
275 :
276 : // Check if an optional column
277 0 : if (optional) {
278 0 : if (calTable.tableDesc().isColumn(colName)) {
279 0 : tabCol.attach (calTable, colName);
280 : };
281 : } else {
282 0 : tabCol.attach (calTable, colName);
283 : };
284 0 : };
285 :
286 : //----------------------------------------------------------------------------
287 :
288 384 : void CTMainColumns::attach (NewCalTable& calTable,
289 : ScalarMeasColumn<MEpoch>& tabCol,
290 : CTEnums::colDef colEnum,
291 : const Bool& optional)
292 : {
293 : // Attach a column accessor to the calibration table
294 : // Input:
295 : // calTable CalTable& Calibration table
296 : // tabCol ScalarMeasColumn<MEpoch>& Table measures column
297 : // accessor
298 : // colEnum CTEnums::colDef Column enum
299 : // optional const Bool& true if optional column
300 : // Output to private data:
301 : //
302 : // Convert to column name
303 384 : String colName = NCT::fieldName (colEnum);
304 :
305 : // Check if an optional column
306 384 : if (optional) {
307 0 : if (calTable.tableDesc().isColumn(colName)) {
308 0 : tabCol.attach (calTable, colName);
309 : };
310 : } else {
311 384 : tabCol.attach (calTable, colName);
312 : };
313 384 : };
314 :
315 : //----------------------------------------------------------------------------
316 :
317 1152 : void CTMainColumns::attach (NewCalTable& calTable,
318 : ScalarQuantColumn<Double>& tabCol,
319 : CTEnums::colDef colEnum,
320 : const Bool& optional)
321 : {
322 : // Attach a column accessor to the calibration table
323 : // Input:
324 : // calTable CalTable& Calibration table
325 : // tabCol ScalarQuantColumn<Double>& Table measures column accessor
326 : // colEnum CTEnums::colDef Column enum
327 : // optional const Bool& true if optional column
328 : // Output to private data:
329 : //
330 : // Convert to column name
331 1152 : String colName = NCT::fieldName (colEnum);
332 :
333 : // Check if an optional column
334 1152 : if (optional) {
335 384 : if (calTable.tableDesc().isColumn(colName)) {
336 0 : tabCol.attach (calTable, colName);
337 : };
338 : } else {
339 768 : tabCol.attach (calTable, colName);
340 : };
341 1152 : };
342 :
343 : //----------------------------------------------------------------------------
344 :
345 : //----------------------------------------------------------------------------
346 :
347 287 : ROCTMainColumns::ROCTMainColumns(const NewCalTable& calTable)
348 : {
349 : // Construct from a calibration table
350 : // Input:
351 : // calTable const NewCalTable& Calibration table
352 : // Output to private data:
353 : // time_p ScalarColumn<Double>& Time
354 : // timeMeas_p ROScalarMeasColumn<MEpoch>& Time as a Measure
355 : // timeEP_p ScalarColumn<Double>& Extended precision time
356 : // timeEPQuant_p ROScalarQuantColumn<Double>& EP time as Quantum
357 : // interval_p ScalarColumn<Double>& Time interval
358 : // intervalQuant_p ROScalarQuantColumn<Double>& Time interval as Quantum
359 : // antenna1_p ScalarColumn<Int>& Antenna 1
360 : // antenna2_p ScalarColumn<Int>& Antenna 2
361 : // fieldId_p ScalarColumn<Int>& Field id.
362 : // spwId_p ScalarColumn<Int>& Spectral Window id.
363 : // scanNo_p ScalarColumn<Int>& Scan no.
364 : // obsId_p ScalarColumn<Int>& Obs Id
365 : // param_p ArrayColumn<Complex>& Solution params
366 : // paramerr_p ArrayColumn<Float>& Solution param error
367 : // flag_p ArrayColumn<Bool>& flag
368 : // snr_p ArrayColumn<Float>& Solution SNR
369 : // weight_p ArrayColumn<Float>& Solution weight
370 : //
371 : // Attach all the column accessors (including required and
372 : // optional columns)
373 287 : attach (calTable, time_p, NCT::TIME);
374 287 : attach (calTable, timeQuant_p, NCT::TIME);
375 287 : attach (calTable, timeMeas_p, NCT::TIME);
376 287 : attach (calTable, timeEP_p, NCT::TIME_EXTRA_PREC, true);
377 287 : attach (calTable, timeEPQuant_p, NCT::TIME_EXTRA_PREC, true);
378 287 : attach (calTable, interval_p, NCT::INTERVAL);
379 287 : attach (calTable, intervalQuant_p, NCT::INTERVAL);
380 287 : attach (calTable, antenna1_p, NCT::ANTENNA1);
381 287 : attach (calTable, antenna2_p, NCT::ANTENNA2);
382 287 : attach (calTable, fieldId_p, NCT::FIELD_ID);
383 287 : attach (calTable, spwId_p, NCT::SPECTRAL_WINDOW_ID);
384 287 : attach (calTable, scanNo_p, NCT::SCAN_NUMBER);
385 287 : attach (calTable, obsId_p, NCT::OBSERVATION_ID,true);
386 :
387 : // {C,F}PARAM columns are optional, exactly one should
388 : // be present
389 287 : attach (calTable, cparam_p, NCT::CPARAM, true);
390 287 : attach (calTable, fparam_p, NCT::FPARAM, true);
391 :
392 287 : attach (calTable, paramerr_p, NCT::PARAMERR);
393 287 : attach (calTable, flag_p, NCT::FLAG);
394 287 : attach (calTable, snr_p, NCT::SNR);
395 287 : attach (calTable, weight_p, NCT::WEIGHT);
396 287 : };
397 :
398 : //----------------------------------------------------------------------------
399 :
400 4305 : void ROCTMainColumns::attach (const NewCalTable& calTable,
401 : TableColumn& tabCol,
402 : CTEnums::colDef colEnum,
403 : const Bool& optional)
404 : {
405 : // Attach a column accessor to the calibration table
406 : // Input:
407 : // calTable const NewCalTable& Calibration table
408 : // tabCol TableColumn& Table column accessor
409 : // colEnum CTEnums::colDef Column enum
410 : // optional const Bool& true if optional column
411 : // Output to private data:
412 : //
413 : // Convert to column name
414 4305 : String colName = NCT::fieldName (colEnum);
415 :
416 : // Check if an optional column
417 4305 : if (optional) {
418 1148 : if (calTable.tableDesc().isColumn(colName)) {
419 574 : tabCol.attach (calTable, colName);
420 : };
421 : } else {
422 3157 : tabCol.attach (calTable, colName);
423 : };
424 4305 : };
425 :
426 : //----------------------------------------------------------------------------
427 :
428 0 : void ROCTMainColumns::attach (const NewCalTable& calTable,
429 : ROArrayMeasColumn<MFrequency>& tabCol,
430 : CTEnums::colDef colEnum,
431 : const Bool& optional)
432 : {
433 : // Attach a column accessor to the calibration table
434 : // Input:
435 : // calTable const NewCalTable& Calibration table
436 : // tabCol ROArrayMeasColumn<MFrequency>& Table measures
437 : // column accessor
438 : // colEnum CTEnums::colDef Column enum
439 : // optional const Bool& true if optional column
440 : // Output to private data:
441 : //
442 : // Convert to column name
443 0 : String colName = NCT::fieldName (colEnum);
444 :
445 : // Check if an optional column
446 0 : if (optional) {
447 0 : if (calTable.tableDesc().isColumn(colName)) {
448 0 : tabCol.attach (calTable, colName);
449 : };
450 : } else {
451 0 : tabCol.attach (calTable, colName);
452 : };
453 0 : };
454 :
455 : //----------------------------------------------------------------------------
456 :
457 0 : void ROCTMainColumns::attach (const NewCalTable& calTable,
458 : ROArrayMeasColumn<MEpoch>& tabCol,
459 : CTEnums::colDef colEnum,
460 : const Bool& optional)
461 : {
462 : // Attach a column accessor to the calibration table
463 : // Input:
464 : // calTable const NewCalTable& Calibration table
465 : // tabCol ROArrayMeasColumn<MEpoch>& Table measures
466 : // column accessor
467 : // colEnum CTEnums::colDef Column enum
468 : // optional const Bool& true if optional column
469 : // Output to private data:
470 : //
471 : // Convert to column name
472 0 : String colName = NCT::fieldName (colEnum);
473 :
474 : // Check if an optional column
475 0 : if (optional) {
476 0 : if (calTable.tableDesc().isColumn(colName)) {
477 0 : tabCol.attach (calTable, colName);
478 : };
479 : } else {
480 0 : tabCol.attach (calTable, colName);
481 : };
482 0 : };
483 :
484 : //----------------------------------------------------------------------------
485 :
486 0 : void ROCTMainColumns::attach (const NewCalTable& calTable,
487 : ROArrayMeasColumn<MDirection>& tabCol,
488 : CTEnums::colDef colEnum,
489 : const Bool& optional)
490 : {
491 : // Attach a column accessor to the calibration table
492 : // Input:
493 : // calTable const NewCalTable& Calibration table
494 : // tabCol ROArrayMeasColumn<MDirection>& Table measures
495 : // column accessor
496 : // colEnum CTEnums::colDef Column enum
497 : // optional const Bool& true if optional column
498 : // Output to private data:
499 : //
500 : // Convert to column name
501 0 : String colName = NCT::fieldName (colEnum);
502 :
503 : // Check if an optional column
504 0 : if (optional) {
505 0 : if (calTable.tableDesc().isColumn(colName)) {
506 0 : tabCol.attach (calTable, colName);
507 : };
508 : } else {
509 0 : tabCol.attach (calTable, colName);
510 : };
511 0 : };
512 :
513 : //----------------------------------------------------------------------------
514 :
515 287 : void ROCTMainColumns::attach (const NewCalTable& calTable,
516 : ROScalarMeasColumn<MEpoch>& tabCol,
517 : CTEnums::colDef colEnum,
518 : const Bool& optional)
519 : {
520 : // Attach a column accessor to the calibration table
521 : // Input:
522 : // calTable const NewCalTable& Calibration table
523 : // tabCol ROScalarMeasColumn<MEpoch>& Table measures column
524 : // accessor
525 : // colEnum CTEnums::colDef Column enum
526 : // optional const Bool& true if optional column
527 : // Output to private data:
528 : //
529 : // Convert to column name
530 287 : String colName = NCT::fieldName (colEnum);
531 :
532 : // Check if an optional column
533 287 : if (optional) {
534 0 : if (calTable.tableDesc().isColumn(colName)) {
535 0 : tabCol.attach (calTable, colName);
536 : };
537 : } else {
538 287 : tabCol.attach (calTable, colName);
539 : };
540 287 : };
541 :
542 : //----------------------------------------------------------------------------
543 :
544 861 : void ROCTMainColumns::attach (const NewCalTable& calTable,
545 : ROScalarQuantColumn<Double>& tabCol,
546 : CTEnums::colDef colEnum,
547 : const Bool& optional)
548 : {
549 : // Attach a column accessor to the calibration table
550 : // Input:
551 : // calTable const NewCalTable& Calibration table
552 : // tabCol ROScalarQuantColumn<Double>& Scalar quantum column accessor
553 : // colEnum CTEnums::colDef Column enum
554 : // optional const Bool& true if optional column
555 : // Output to private data:
556 : //
557 : // Convert to column name
558 861 : String colName = NCT::fieldName (colEnum);
559 :
560 : // Check if an optional column
561 861 : if (optional) {
562 287 : if (calTable.tableDesc().isColumn(colName)) {
563 0 : tabCol.attach (calTable, colName);
564 : };
565 : } else {
566 574 : tabCol.attach (calTable, colName);
567 : };
568 861 : };
569 :
570 : } //# NAMESPACE CASA - END
571 :
|
