Line data Source code
1 : //# CalMainBuffer.cc: Implementation of CalMainBuffer.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: aips2-request@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/CalMainBuffer.h>
30 : #include <casacore/casa/Arrays/ArrayMath.h>
31 : #include <casacore/casa/Arrays/ArrayLogical.h>
32 : #include <casacore/casa/Arrays/MaskedArray.h>
33 : #include <casacore/casa/Arrays/ArrayUtil.h>
34 : #include <casacore/tables/Tables/RefRows.h>
35 : #include <casacore/casa/Exceptions/Error.h>
36 : #include <casacore/measures/Measures/MCFrequency.h>
37 : #include <casacore/casa/typeinfo.h>
38 :
39 : using namespace casacore;
40 : namespace casa { //# NAMESPACE CASA - BEGIN
41 :
42 : //----------------------------------------------------------------------------
43 :
44 0 : CalMainBuffer::CalMainBuffer() :
45 0 : connectedToIter_p(false), calIter_p(NULL), calMainCol_p(NULL)
46 : {
47 : // Null constructor
48 : // Output to private data:
49 : // connectedToIter_p Bool true if connected to iterator
50 : // calIter_p CalIterBase* Ptr to calibration table iterator
51 : // calMainCol_p CalMainColumns* Ptr to cal main col accessor
52 : // calDescBuf_p CalDescBuffer* Ptr to cal_desc buffer
53 : // calHistBuf_p CalHistoryBuffer* Ptr to cal_history buffer
54 : // timeMeas_p Vector<MEpoch> Time as a Measure
55 : // timeEPQuant_p Vector<Quantity> Extended prec. time as Quantum
56 : // intervalQuant_p Vector<Quantity> Time interval as Quantum
57 : // antenna1_p Vector<Int> Antenna 1
58 : // feed1_p Vector<Int> Feed 1
59 : // fieldId_p Vector<Int> Field id.
60 : // arrayId_p Vector<Int> Array id.
61 : // obsId_p Vector<Int> Observation id.
62 : // scanNo_p Vector<Int> Scan no.
63 : // processorId_p Vector<Int> Processor id.
64 : // stateId_p Vector<Int> State id.
65 : // phaseId_p Vector<Int> Phase id.
66 : // pulsarBin_p Vector<Int> Pulsar bin
67 : // pulsarGateId_p Vector<Int> Pulsar gate id.
68 : // freqGrp_p Vector<Int> Frequency group
69 : // freqGrpName_p Vector<String> Frequency group name
70 : // fieldName_p Vector<String> Field name
71 : // fieldCode_p Vector<String> Field code
72 : // sourceName_p Vector<String> Source name
73 : // sourceCode_p Vector<String> Source code
74 : // calGrp_p Vector<Int> Calibration group
75 : // gain_p Array<Complex> Gain
76 : // refAnt_p Array<Int> Reference antenna
77 : // refFeed_p Array<Int> Reference feed
78 : // refReceptor_p Array<Int> Reference receptor
79 : // refFreqMeas_p Array<MFrequency> Reference frequency as Measure
80 : // measFreqRef_p Vector<Int> Frequency measures ref.
81 : // refDirMeas_p Array<MDirection> Reference direction as Measure
82 : // measDirRef_p Vector<Int> Direction measures ref.
83 : // calDescId_p Vector<Int> CAL_DESC id.
84 : // calHistoryId_p Vector<Int> CAL_HISTORY id.
85 : // timeMeasOK_p Bool Time as a Measure cache ok
86 : // timeEPQuantOK_p Bool EP time as Quantum cache ok
87 : // intervalQuantOK_p Bool Time interval as Quantum cache ok
88 : // antenna1OK_p Bool Antenna 1 cache ok
89 : // feed1OK_p Bool Feed 1 cache ok
90 : // fieldIdOK_p Bool Field id. cache ok
91 : // arrayIdOK_p Bool Array id. cache ok
92 : // obsIdOK_p Bool Observation id. cache ok
93 : // scanNoOK_p Bool Scan no. cache ok
94 : // processorIdOK_p Bool Processor id. cache ok
95 : // stateIdOK_p Bool State id. cache ok
96 : // phaseIdOK_p Bool Phase id. cache ok
97 : // pulsarBinOK_p Bool Pulsar bin cache ok
98 : // pulsarGateIdOK_p Bool Pulsar gate id. cache ok
99 : // freqGrpOK_p Bool Frequency group cache ok
100 : // freqGrpNameOK_p Bool Frequency group name cache ok
101 : // fieldNameOK_p Bool Field name cache ok
102 : // fieldCodeOK_p Bool Field code cache ok
103 : // sourceNameOK_p Bool Source name cache ok
104 : // sourceCodeOK_p Bool Source code cache ok
105 : // calGrpOK_p Bool Calibration group cache ok
106 : // gainOK_p Bool Gain cache ok
107 : // refAntOK_p Bool Reference antenna cache ok
108 : // refFeedOK_p Bool Reference feed cache ok
109 : // refReceptorOK_p Bool Reference receptor cache ok
110 : // refFreqMeasOK_p Bool Ref. freq. as Measure cache ok
111 : // measFreqRefOK_p Bool Frequency measures ref. cache ok
112 : // refDirMeasOK_p Bool Ref. dir. as Measure cache ok
113 : // measDirRefOK_p Bool Direction measures ref. cache ok
114 : // calDescIdOK_p Bool CAL_DESC id. cache ok
115 : // calHistoryIdOK_p Bool CAL_HISTORY id. cache ok
116 : //
117 : // Invalidate cache
118 0 : invalidate();
119 :
120 : // Construct sub-table cal_desc and cal_history buffers
121 0 : calDescBuf_p = new CalDescBuffer();
122 0 : calHistBuf_p = new CalHistoryBuffer();
123 0 : };
124 :
125 : //----------------------------------------------------------------------------
126 :
127 1 : CalMainBuffer::CalMainBuffer (const Vector<Int>& calIndices,
128 1 : const Block<Vector<Int> >& indexValues) :
129 1 : connectedToIter_p(false), calIter_p(NULL), calMainCol_p(NULL)
130 : {
131 : // Construct from a set of cal buffer indices and specified index values
132 : // Input:
133 : // calIndices const Vector<Int>& Cal indices (as specified as
134 : // enums from class MSCalEnums)
135 : // indexValues const Block<Vec<Int>>& Associated index values
136 : // Output to private data:
137 : // connectedToIter_p Bool true if connected to iterator
138 : // calIter_p CalIterBase* Ptr to cal. table iterator
139 : // calMainCol_p CalMainColumns* Ptr to cal main col accessor
140 : // calDescBuf_p CalDescBuffer* Ptr to cal_desc buffer
141 : // calHistBuf_p CalHistoryBuffer* Ptr to cal_history buffer
142 : //
143 : // Invalidate cache
144 1 : invalidate();
145 :
146 : // Span the calibration buffer using the specified indices and index values
147 1 : fillIndices(calIndices, indexValues);
148 :
149 : // Set non-index columns to default values
150 1 : fillAttributes(calIndices);
151 :
152 : // Construct sub-table cal_desc and cal_history buffers
153 1 : calDescBuf_p = new CalDescBuffer();
154 1 : calHistBuf_p = new CalHistoryBuffer();
155 1 : };
156 :
157 : //----------------------------------------------------------------------------
158 :
159 0 : CalMainBuffer::CalMainBuffer (CalIterBase& calIter) :
160 0 : connectedToIter_p(true), calIter_p(&calIter), calMainCol_p(NULL)
161 : {
162 : // Construct from a calibration table iterator
163 : // Input:
164 : // calIter CalIterBase& Calibration table iterator
165 : // Output to private data:
166 : // connectedToIter_p Bool true if connected to iterator
167 : // calIter_p CalIterBase* Ptr to cal. table iterator
168 : // calMainCol_p CalMainColumns* Ptr to cal main col accessor
169 : // calDescBuf_p CalDescBuffer* Ptr to cal_desc buffer
170 : // calHistBuf_p CalHistoryBuffer* Ptr to cal_history buffer
171 : // timeMeas_p Vector<MEpoch> Time as a Measure
172 : // timeEPQuant_p Vector<Quantity> Extended prec. time as Quantum
173 : // intervalQuant_p Vector<Quantity> Time interval as Quantum
174 : // antenna1_p Vector<Int> Antenna 1
175 : // feed1_p Vector<Int> Feed 1
176 : // fieldId_p Vector<Int> Field id.
177 : // arrayId_p Vector<Int> Array id.
178 : // obsId_p Vector<Int> Observation id.
179 : // scanNo_p Vector<Int> Scan no.
180 : // processorId_p Vector<Int> Processor id.
181 : // stateId_p Vector<Int> State id.
182 : // phaseId_p Vector<Int> Phase id.
183 : // pulsarBin_p Vector<Int> Pulsar bin
184 : // pulsarGateId_p Vector<Int> Pulsar gate id.
185 : // freqGrp_p Vector<Int> Frequency group
186 : // freqGrpName_p Vector<String> Frequency group name
187 : // fieldName_p Vector<String> Field name
188 : // fieldCode_p Vector<String> Field code
189 : // sourceName_p Vector<String> Source name
190 : // sourceCode_p Vector<String> Source code
191 : // calGrp_p Vector<Int> Calibration group
192 : // gain_p Array<Complex> Gain
193 : // refAnt_p Array<Int> Reference antenna
194 : // refFeed_p Array<Int> Reference feed
195 : // refReceptor_p Array<Int> Reference receptor
196 : // refFreqMeas_p Array<MFrequency> Reference frequency as Measure
197 : // measFreqRef_p Vector<Int> Frequency measures ref.
198 : // refDirMeas_p Array<MDirection> Reference direction as Measure
199 : // measDirRef_p Vector<Int> Direction measures ref.
200 : // calDescId_p Vector<Int> CAL_DESC id.
201 : // calHistoryId_p Vector<Int> CAL_HISTORY id.
202 : // timeMeasOK_p Bool Time as a Measure cache ok
203 : // timeEPQuantOK_p Bool EP time as Quantum cache ok
204 : // intervalQuantOK_p Bool Time interval as Quantum cache ok
205 : // antenna1OK_p Bool Antenna 1 cache ok
206 : // feed1OK_p Bool Feed 1 cache ok
207 : // fieldIdOK_p Bool Field id. cache ok
208 : // arrayIdOK_p Bool Array id. cache ok
209 : // obsIdOK_p Bool Observation id. cache ok
210 : // scanNoOK_p Bool Scan no. cache ok
211 : // processorIdOK_p Bool Processor id. cache ok
212 : // stateIdOK_p Bool State id. cache ok
213 : // phaseIdOK_p Bool Phase id. cache ok
214 : // pulsarBinOK_p Bool Pulsar bin cache ok
215 : // pulsarGateIdOK_p Bool Pulsar gate id. cache ok
216 : // freqGrpOK_p Bool Frequency group cache ok
217 : // freqGrpNameOK_p Bool Frequency group name cache ok
218 : // fieldNameOK_p Bool Field name cache ok
219 : // fieldCodeOK_p Bool Field code cache ok
220 : // sourceNameOK_p Bool Source name cache ok
221 : // sourceCodeOK_p Bool Source code cache ok
222 : // calGrpOK_p Bool Calibration group cache ok
223 : // gainOK_p Bool Gain cache ok
224 : // refAntOK_p Bool Reference antenna cache ok
225 : // refFeedOK_p Bool Reference feed cache ok
226 : // refReceptorOK_p Bool Reference receptor cache ok
227 : // refFreqMeasOK_p Bool Ref. freq. as Measure cache ok
228 : // measFreqRefOK_p Bool Frequency measures ref. cache ok
229 : // refDirMeasOK_p Bool Ref. dir. as Measure cache ok
230 : // measDirRefOK_p Bool Direction measures ref. cache ok
231 : // calDescIdOK_p Bool CAL_DESC id. cache ok
232 : // calHistoryIdOK_p Bool CAL_HISTORY id. cache ok
233 : //
234 : // Invalidate cache
235 0 : invalidate();
236 :
237 : // Construct the sub-table cal_desc and cal_history buffers
238 0 : calDescBuf_p = new CalDescBuffer (calIter);
239 0 : calHistBuf_p = new CalHistoryBuffer (calIter);
240 0 : };
241 :
242 : //----------------------------------------------------------------------------
243 :
244 1 : CalMainBuffer::~CalMainBuffer()
245 : {
246 : // Destructor
247 : // Output to private data:
248 : // calMainCol_p CalMainColumns* Ptr to cal main col accessor
249 : //
250 : // Delete all pointer data
251 1 : if (calMainCol_p) delete(calMainCol_p);
252 : // if (calIter_p) delete(calIter_p);
253 1 : if (calDescBuf_p) delete(calDescBuf_p);
254 1 : if (calHistBuf_p) delete(calHistBuf_p);
255 1 : };
256 :
257 : //----------------------------------------------------------------------------
258 :
259 0 : void CalMainBuffer::synchronize()
260 : {
261 : // Synchronize the buffer (if an iterator is attached)
262 : // Output to private data:
263 : // calMainCol_p CalMainColumns* Ptr to cal main col accessor
264 : //
265 : // Construct a new calibration main table columns accessor
266 0 : if (calMainCol_p) delete calMainCol_p;
267 :
268 0 : calMainCol_p = newCalMainCol (calIter_p->subTable());
269 :
270 : // Invalidate cache
271 0 : invalidate();
272 0 : };
273 :
274 : //----------------------------------------------------------------------------
275 :
276 0 : void CalMainBuffer::fillCache()
277 : {
278 : // Force an explicit read to cache for all columns (if attached to an iterator)
279 : // Output to private data:
280 : // timeMeas_p Vector<MEpoch> Time as a Measure
281 : // timeEPQuant_p Vector<Quantity> Extended prec. time as Quantum
282 : // intervalQuant_p Vector<Quantity> Time interval as Quantum
283 : // antenna1_p Vector<Int> Antenna 1
284 : // feed1_p Vector<Int> Feed 1
285 : // fieldId_p Vector<Int> Field id.
286 : // arrayId_p Vector<Int> Array id.
287 : // obsId_p Vector<Int> Observation id.
288 : // scanNo_p Vector<Int> Scan no.
289 : // processorId_p Vector<Int> Processor id.
290 : // stateId_p Vector<Int> State id.
291 : // phaseId_p Vector<Int> Phase id.
292 : // pulsarBin_p Vector<Int> Pulsar bin
293 : // pulsarGateId_p Vector<Int> Pulsar gate id.
294 : // freqGrp_p Vector<Int> Frequency group
295 : // freqGrpName_p Vector<String> Frequency group name
296 : // fieldName_p Vector<String> Field name
297 : // fieldCode_p Vector<String> Field code
298 : // sourceName_p Vector<String> Source name
299 : // sourceCode_p Vector<String> Source code
300 : // calGrp_p Vector<Int> Calibration group
301 : // gain_p Array<Complex> Gain
302 : // refAnt_p Array<Int> Reference antenna
303 : // refFeed_p Array<Int> Reference feed
304 : // refReceptor_p Array<Int> Reference receptor
305 : // refFreqMeas_p Array<MFrequency> Reference frequency as Measure
306 : // measFreqRef_p Vector<Int> Frequency measures ref.
307 : // refDirMeas_p Array<MDirection> Reference direction as Measure
308 : // measDirRef_p Vector<Int> Direction measures ref.
309 : // calDescId_p Vector<Int> CAL_DESC id.
310 : // calHistoryId_p Vector<Int> CAL_HISTORY id.
311 : // timeMeasOK_p Bool Time as a Measure cache ok
312 : // timeEPQuantOK_p Bool EP time as Quantum cache ok
313 : // intervalQuantOK_p Bool Time interval as Quantum cache ok
314 : // antenna1OK_p Bool Antenna 1 cache ok
315 : // feed1OK_p Bool Feed 1 cache ok
316 : // fieldIdOK_p Bool Field id. cache ok
317 : // arrayIdOK_p Bool Array id. cache ok
318 : // obsIdOK_p Bool Observation id. cache ok
319 : // scanNoOK_p Bool Scan no. cache ok
320 : // processorIdOK_p Bool Processor id. cache ok
321 : // stateIdOK_p Bool State id. cache ok
322 : // phaseIdOK_p Bool Phase id. cache ok
323 : // pulsarBinOK_p Bool Pulsar bin cache ok
324 : // pulsarGateIdOK_p Bool Pulsar gate id. cache ok
325 : // freqGrpOK_p Bool Frequency group cache ok
326 : // freqGrpNameOK_p Bool Frequency group name cache ok
327 : // fieldNameOK_p Bool Field name cache ok
328 : // fieldCodeOK_p Bool Field code cache ok
329 : // sourceNameOK_p Bool Source name cache ok
330 : // sourceCodeOK_p Bool Source code cache ok
331 : // calGrpOK_p Bool Calibration group cache ok
332 : // gainOK_p Bool Gain cache ok
333 : // refAntOK_p Bool Reference antenna cache ok
334 : // refFeedOK_p Bool Reference feed cache ok
335 : // refReceptorOK_p Bool Reference receptor cache ok
336 : // refFreqMeasOK_p Bool Ref. freq. as Measure cache ok
337 : // measFreqRefOK_p Bool Frequency measures ref. cache ok
338 : // refDirMeasOK_p Bool Ref. dir. as Measure cache ok
339 : // measDirRefOK_p Bool Direction measures ref. cache ok
340 : // calDescIdOK_p Bool CAL_DESC id. cache ok
341 : // calHistoryIdOK_p Bool CAL_HISTORY id. cache ok
342 : //
343 : // Method nRow() will implicity reference (hence fill) all cache columns
344 0 : nRow();
345 0 : };
346 :
347 : //----------------------------------------------------------------------------
348 :
349 1 : Int CalMainBuffer::append (CalTable& calTable)
350 : {
351 : // Append the current calibration buffer to a calibration table
352 : // Input:
353 : // calTable CalTable& Calibration table
354 : // Output:
355 : // append Int No. of rows appended
356 : //
357 : // Process the CAL_DESC sub-table
358 1 : if (max(calDescId()) >= 0) {
359 : };
360 :
361 : // Process the CAL_HISTORY sub-table
362 1 : if (max(calHistoryId()) >= 0) {
363 : };
364 :
365 : // Extend the cal table by the number of rows in the current cal buffer
366 1 : uInt startRow = calTable.nRowMain();
367 1 : calTable.addRowMain(nRow());
368 1 : uInt endRow = calTable.nRowMain() - 1;
369 :
370 : // Attach a cal table columns accessor
371 2 : CalMainColumns calMainCol(calTable);
372 :
373 : // Append the current cal buffer cal_main columns
374 2 : RefRows refRows(startRow, endRow);
375 1 : calMainCol.antenna1().putColumnCells(refRows, antenna1());
376 1 : calMainCol.feed1().putColumnCells(refRows, feed1());
377 1 : calMainCol.fieldId().putColumnCells(refRows, fieldId());
378 1 : calMainCol.arrayId().putColumnCells(refRows, arrayId());
379 1 : calMainCol.obsId().putColumnCells(refRows, obsId());
380 1 : calMainCol.scanNo().putColumnCells(refRows, scanNo());
381 1 : calMainCol.processorId().putColumnCells(refRows, processorId());
382 1 : calMainCol.stateId().putColumnCells(refRows, stateId());
383 1 : calMainCol.phaseId().putColumnCells(refRows, phaseId());
384 1 : calMainCol.pulsarBin().putColumnCells(refRows, pulsarBin());
385 1 : calMainCol.pulsarGateId().putColumnCells(refRows, pulsarGateId());
386 1 : calMainCol.freqGrp().putColumnCells(refRows, freqGrp());
387 1 : calMainCol.freqGrpName().putColumnCells(refRows, freqGrpName());
388 1 : calMainCol.fieldName().putColumnCells(refRows, fieldName());
389 1 : calMainCol.fieldCode().putColumnCells(refRows, fieldCode());
390 1 : calMainCol.sourceName().putColumnCells(refRows, sourceName());
391 1 : calMainCol.sourceCode().putColumnCells(refRows, sourceCode());
392 1 : calMainCol.calGrp().putColumnCells(refRows, calGrp());
393 1 : calMainCol.gain().putColumnCells(refRows, gain());
394 1 : calMainCol.refAnt().putColumnCells(refRows, refAnt());
395 1 : calMainCol.refFeed().putColumnCells(refRows, refFeed());
396 1 : calMainCol.refReceptor().putColumnCells(refRows, refReceptor());
397 1 : calMainCol.calDescId().putColumnCells(refRows, calDescId());
398 1 : calMainCol.calHistoryId().putColumnCells(refRows, calHistoryId());
399 :
400 :
401 : // Do the measures columns by cell (no putColumnCells() method
402 : // available for TableMeasures columns)
403 2 : IPosition blcRefFreq(refFreqMeas().shape());
404 1 : blcRefFreq = 0;
405 2 : IPosition trcRefFreq = refFreqMeas().shape() - 1;
406 2 : IPosition blcRefDir(refDirMeas().shape());
407 1 : blcRefDir = 0;
408 1 : IPosition trcRefDir = refDirMeas().shape() - 1;
409 1 : uInt lastAxis = trcRefDir.nelements() - 1;
410 :
411 21 : for (uInt row=startRow; row <= endRow; row++) {
412 20 : Int indx = row - startRow;
413 20 : calMainCol.timeMeas().put(row, timeMeas()(indx));
414 20 : calMainCol.timeEPQuant().put(row, timeEPQuant()(indx));
415 20 : calMainCol.intervalQuant().put(row, intervalQuant()(indx));
416 40 : IPosition currIndxPos(1, indx);
417 20 : blcRefFreq.setLast(currIndxPos);
418 20 : trcRefFreq.setLast(currIndxPos);
419 : Array<MFrequency> rowRefFreq =
420 40 : refFreqMeas()(blcRefFreq,trcRefFreq).nonDegenerate(lastAxis);
421 20 : calMainCol.refFreqMeas().put(row, rowRefFreq);
422 20 : blcRefDir.setLast(currIndxPos);
423 20 : trcRefDir.setLast(currIndxPos);
424 : Array<MDirection> rowRefDir =
425 40 : refDirMeas()(blcRefDir,trcRefDir).nonDegenerate(lastAxis);
426 20 : calMainCol.refDirMeas().put(row, rowRefDir);
427 : };
428 :
429 2 : return (endRow-startRow+1);
430 : };
431 :
432 : //----------------------------------------------------------------------------
433 :
434 25 : Int CalMainBuffer::nRow()
435 : {
436 : // Return the maximum number of rows in the calibration buffer
437 : // Input from private data:
438 : // timeMeas_p Vector<MEpoch> Time as a Measure
439 : // timeEPQuant_p Vector<Quantity> Extended prec. time as Quantum
440 : // intervalQuant_p Vector<Quantity> Time interval as Quantum
441 : // antenna1_p Vector<Int> Antenna 1
442 : // feed1_p Vector<Int> Feed 1
443 : // fieldId_p Vector<Int> Field id.
444 : // arrayId_p Vector<Int> Array id.
445 : // obsId_p Vector<Int> Observation id.
446 : // scanNo_p Vector<Int> Scan no.
447 : // processorId_p Vector<Int> Processor id.
448 : // stateId_p Vector<Int> State id.
449 : // phaseId_p Vector<Int> Phase id.
450 : // pulsarBin_p Vector<Int> Pulsar bin
451 : // pulsarGateId_p Vector<Int> Pulsar gate id.
452 : // freqGrp_p Vector<Int> Frequency group
453 : // freqGrpName_p Vector<String> Frequency group name
454 : // fieldName_p Vector<String> Field name
455 : // fieldCode_p Vector<String> Field code
456 : // sourceName_p Vector<String> Source name
457 : // sourceCode_p Vector<String> Source code
458 : // calGrp_p Vector<Int> Calibration group
459 : // gain_p Array<Complex> Gain
460 : // refAnt_p Array<Int> Reference antenna
461 : // refFeed_p Array<Int> Reference feed
462 : // refReceptor_p Array<Int> Reference receptor
463 : // refFreqMeas_p Array<MFrequency> Reference frequency as Measure
464 : // measFreqRef_p Vector<Int> Frequency measures ref.
465 : // refDirMeas_p Array<MDirection> Reference direction as Measure
466 : // measDirRef_p Vector<Int> Direction measures ref.
467 : // calDescId_p Vector<Int> CAL_DESC id.
468 : // calHistoryId_p Vector<Int> CAL_HISTORY id.
469 : //
470 : // Process each column individually
471 50 : Vector<Int> colLength(31, 0);
472 25 : Int n = 0;
473 25 : colLength(n++) = timeMeas().nelements();
474 25 : colLength(n++) = timeEPQuant().nelements();
475 25 : colLength(n++) = intervalQuant().nelements();
476 25 : colLength(n++) = antenna1().nelements();
477 25 : colLength(n++) = feed1().nelements();
478 25 : colLength(n++) = fieldId().nelements();
479 25 : colLength(n++) = arrayId().nelements();
480 25 : colLength(n++) = obsId().nelements();
481 25 : colLength(n++) = scanNo().nelements();
482 25 : colLength(n++) = processorId().nelements();
483 25 : colLength(n++) = stateId().nelements();
484 25 : colLength(n++) = phaseId().nelements();
485 25 : colLength(n++) = pulsarBin().nelements();
486 25 : colLength(n++) = pulsarGateId().nelements();
487 25 : colLength(n++) = freqGrp().nelements();
488 25 : colLength(n++) = freqGrpName().nelements();
489 25 : colLength(n++) = fieldName().nelements();
490 25 : colLength(n++) = fieldCode().nelements();
491 25 : colLength(n++) = sourceName().nelements();
492 25 : colLength(n++) = sourceCode().nelements();
493 25 : colLength(n++) = calGrp().nelements();
494 49 : colLength(n++) = gain().shape().nelements() > 0 ?
495 49 : gain().shape().getLast(1)(0) : 0;
496 49 : colLength(n++) = refAnt().shape().nelements() > 0 ?
497 49 : refAnt().shape().getLast(1)(0) : 0;
498 49 : colLength(n++) = refFeed().shape().nelements() > 0 ?
499 49 : refFeed().shape().getLast(1)(0) : 0;
500 49 : colLength(n++) = refReceptor().shape().nelements() > 0 ?
501 49 : refReceptor().shape().getLast(1)(0) : 0;
502 49 : colLength(n++) = refFreqMeas().shape().nelements() > 0 ?
503 49 : refFreqMeas().shape().getLast(1)(0) : 0;
504 25 : colLength(n++) = measFreqRef().nelements();
505 49 : colLength(n++) = refDirMeas().shape().nelements() > 1 ?
506 49 : refDirMeas().shape().getLast(1)(0) : 0;
507 25 : colLength(n++) = measDirRef().nelements();
508 25 : colLength(n++) = calDescId().nelements();
509 25 : colLength(n++) = calHistoryId().nelements();
510 :
511 50 : return max(colLength);
512 : };
513 :
514 : //----------------------------------------------------------------------------
515 :
516 48 : Vector<MEpoch>& CalMainBuffer::timeMeas()
517 : {
518 : // TIME data field accessor (as Measure)
519 : // Input from private data:
520 : // connectedToIter_p Bool true if connected to iterator
521 : // timeMeas_p Vector<MEpoch>& Time as Measure
522 : //
523 : // Fill local cache for this column if cache not valid
524 48 : if (connectedToIter()) {
525 0 : if (!timeMeasOK_p) {
526 0 : Int nrow = calMainCol()->time().nrow();
527 0 : timeMeas_p.resize(nrow);
528 0 : for (Int row=0; row < nrow; row++) {
529 0 : calMainCol()->timeMeas().get (row, timeMeas_p(row));
530 : };
531 0 : timeMeasOK_p = true;
532 : };
533 : };
534 48 : return timeMeas_p;
535 : };
536 :
537 : //----------------------------------------------------------------------------
538 :
539 47 : Vector<Quantity>& CalMainBuffer::timeEPQuant()
540 : {
541 : // TIME_EXTRA_PREC data field accessor (as Quantum)
542 : // Input from private data:
543 : // connectedToIter_p Bool true if connected to iterator
544 : // timeEPQuant_p Vector<Quantity> Time EP as Quantum
545 : //
546 : // Fill local cache for this column if cache not valid
547 47 : if (connectedToIter()) {
548 0 : if (!timeEPQuantOK_p) {
549 0 : uInt nrow = calMainCol()->time().nrow();
550 0 : timeEPQuant_p.resize(nrow);
551 0 : for (uInt row=0; row < nrow; row++) {
552 0 : calMainCol()->timeEPQuant().get (row, timeEPQuant_p(row));
553 : };
554 0 : timeEPQuantOK_p = true;
555 : };
556 : };
557 47 : return timeEPQuant_p;
558 : };
559 :
560 : //----------------------------------------------------------------------------
561 :
562 47 : Vector<Quantity>& CalMainBuffer::intervalQuant()
563 : {
564 : // INTERVAL data field accessor (as Quantum)
565 : // Input from private data:
566 : // connectedToIter_p Bool true if connected to iterator
567 : // intervalQuant_p Vector<Quantity> Interval as Quantum
568 : //
569 : // Fill local cache for this column if cache not valid
570 47 : if (connectedToIter()) {
571 0 : if (!intervalQuantOK_p) {
572 0 : uInt nrow = calMainCol()->time().nrow();
573 0 : intervalQuant_p.resize(nrow);
574 0 : for (uInt row = 0; row < nrow; row++) {
575 0 : calMainCol()->intervalQuant().get (row, intervalQuant_p(row));
576 : };
577 0 : intervalQuantOK_p = true;
578 : };
579 : };
580 47 : return intervalQuant_p;
581 : };
582 :
583 : //----------------------------------------------------------------------------
584 :
585 86 : Vector<Int>& CalMainBuffer::antenna1()
586 : {
587 : // ANTENNA1 data field accessor
588 : // Input from private data:
589 : // connectedToIter_p Bool true if connected to iterator
590 : // antenna1_p Vector<Int> Antenna1
591 : //
592 : // Fill local cache for this column if cache not valid
593 86 : if (connectedToIter()) {
594 0 : if (!antenna1OK_p) {
595 0 : calMainCol()->antenna1().getColumn (antenna1_p);
596 0 : antenna1OK_p = true;
597 : };
598 : };
599 86 : return antenna1_p;
600 : };
601 :
602 : //----------------------------------------------------------------------------
603 :
604 28 : Vector<Int>& CalMainBuffer::feed1()
605 : {
606 : // FEED1 data field accessor
607 : // Input from private data:
608 : // connectedToIter_p Bool true if connected to iterator
609 : // feed1_p Vector<Int> Feed1
610 : //
611 : // Fill local cache for this column if cache not valid
612 28 : if (connectedToIter()) {
613 0 : if (!feed1OK_p) {
614 0 : calMainCol()->feed1().getColumn (feed1_p);
615 0 : feed1OK_p = true;
616 : };
617 : };
618 28 : return feed1_p;
619 : };
620 :
621 : //----------------------------------------------------------------------------
622 :
623 86 : Vector<Int>& CalMainBuffer::fieldId()
624 : {
625 : // FIELD_ID data field accessor
626 : // Input from private data:
627 : // connectedToIter_p Bool true if connected to iterator
628 : // fieldId_p Vector<Int> Field id.
629 : //
630 : // Fill local cache for this column if cache not valid
631 86 : if (connectedToIter()) {
632 0 : if (!fieldIdOK_p) {
633 0 : calMainCol()->fieldId().getColumn (fieldId_p);
634 0 : fieldIdOK_p = true;
635 : };
636 : };
637 86 : return fieldId_p;
638 : };
639 :
640 : //----------------------------------------------------------------------------
641 :
642 28 : Vector<Int>& CalMainBuffer::arrayId()
643 : {
644 : // ARRAY_ID data field accessor
645 : // Input from private data:
646 : // connectedToIter_p Bool true if connected to iterator
647 : // arrayId_p Vector<Int> Array id.
648 : //
649 : // Fill local cache for this column if cache not valid
650 28 : if (connectedToIter()) {
651 0 : if (!arrayIdOK_p) {
652 0 : calMainCol()->arrayId().getColumn (arrayId_p);
653 0 : arrayIdOK_p = true;
654 : };
655 : };
656 28 : return arrayId_p;
657 : };
658 :
659 : //----------------------------------------------------------------------------
660 :
661 28 : Vector<Int>& CalMainBuffer::obsId()
662 : {
663 : // OBSERVATION_ID data field accessor
664 : // Input from private data:
665 : // connectedToIter_p Bool true if connected to iterator
666 : // obsId_p Vector<Int> Obs id.
667 : //
668 : // Fill local cache for this column if cache not valid
669 28 : if (connectedToIter()) {
670 0 : if (!obsIdOK_p) {
671 0 : calMainCol()->obsId().getColumn (obsId_p);
672 0 : obsIdOK_p = true;
673 : };
674 : };
675 28 : return obsId_p;
676 : };
677 :
678 : //----------------------------------------------------------------------------
679 :
680 28 : Vector<Int>& CalMainBuffer::scanNo()
681 : {
682 : // SCAN_NUMBER data field accessor
683 : // Input from private data:
684 : // connectedToIter_p Bool true if connected to iterator
685 : // scanNo_p Vector<Int> Scan no.
686 : //
687 : // Fill local cache for this column if cache not valid
688 28 : if (connectedToIter()) {
689 0 : if (!scanNoOK_p) {
690 0 : calMainCol()->scanNo().getColumn (scanNo_p);
691 0 : scanNoOK_p = true;
692 : };
693 : };
694 28 : return scanNo_p;
695 : };
696 :
697 : //----------------------------------------------------------------------------
698 :
699 28 : Vector<Int>& CalMainBuffer::processorId()
700 : {
701 : // PROCESSOR_ID data field accessor
702 : // Input from private data:
703 : // connectedToIter_p Bool true if connected to iterator
704 : // processorId_p Vector<Int> Processor id.
705 : //
706 : // Fill local cache for this column if cache not valid
707 28 : if (connectedToIter()) {
708 0 : if (!processorIdOK_p) {
709 0 : calMainCol()->processorId().getColumn (processorId_p);
710 0 : processorIdOK_p = true;
711 : };
712 : };
713 28 : return processorId_p;
714 : };
715 :
716 : //----------------------------------------------------------------------------
717 :
718 28 : Vector<Int>& CalMainBuffer::stateId()
719 : {
720 : // STATE_ID data field accessor
721 : // Input from private data:
722 : // connectedToIter_p Bool true if connected to iterator
723 : // stateId_p Vector<Int> State id.
724 : //
725 : // Fill local cache for this column if cache not valid
726 28 : if (connectedToIter()) {
727 0 : if (!stateIdOK_p) {
728 0 : calMainCol()->stateId().getColumn (stateId_p);
729 0 : stateIdOK_p = true;
730 : };
731 : };
732 28 : return stateId_p;
733 : };
734 :
735 : //----------------------------------------------------------------------------
736 :
737 28 : Vector<Int>& CalMainBuffer::phaseId()
738 : {
739 : // PHASE_ID data field accessor
740 : // Input from private data:
741 : // connectedToIter_p Bool true if connected to iterator
742 : // phaseId_p Vector<Int> Phase id.
743 : //
744 : // Fill local cache for this column if cache not valid
745 28 : if (connectedToIter()) {
746 0 : if (!phaseIdOK_p) {
747 0 : calMainCol()->phaseId().getColumn (phaseId_p);
748 0 : phaseIdOK_p = true;
749 : };
750 : };
751 28 : return phaseId_p;
752 : };
753 :
754 : //----------------------------------------------------------------------------
755 :
756 28 : Vector<Int>& CalMainBuffer::pulsarBin()
757 : {
758 : // PULSAR_BIN data field accessor
759 : // Input from private data:
760 : // connectedToIter_p Bool true if connected to iterator
761 : // pulsarBin_p Vector<Int> Pulsar bin
762 : //
763 : // Fill local cache for this column if cache not valid
764 28 : if (connectedToIter()) {
765 0 : if (!pulsarBinOK_p) {
766 0 : calMainCol()->pulsarBin().getColumn (pulsarBin_p);
767 0 : pulsarBinOK_p = true;
768 : };
769 : };
770 28 : return pulsarBin_p;
771 : };
772 :
773 : //----------------------------------------------------------------------------
774 :
775 28 : Vector<Int>& CalMainBuffer::pulsarGateId()
776 : {
777 : // PULSAR_GATE_ID data field accessor
778 : // Input from private data:
779 : // connectedToIter_p Bool true if connected to iterator
780 : // pulsarGateId_p Vector<Int> Pulsar gate id.
781 : //
782 : // Fill local cache for this column if cache not valid
783 28 : if (connectedToIter()) {
784 0 : if (!pulsarGateIdOK_p) {
785 0 : calMainCol()->pulsarGateId().getColumn (pulsarGateId_p);
786 0 : pulsarGateIdOK_p = true;
787 : };
788 : };
789 28 : return pulsarGateId_p;
790 : };
791 :
792 : //----------------------------------------------------------------------------
793 :
794 28 : Vector<Int>& CalMainBuffer::freqGrp()
795 : {
796 : // FREQ_GROUP data field accessor
797 : // Input from private data:
798 : // connectedToIter_p Bool true if connected to iterator
799 : // freqGrp_p Vector<Int> Frequency group
800 : //
801 : // Fill local cache for this column if cache not valid
802 28 : if (connectedToIter()) {
803 0 : if (!freqGrpOK_p) {
804 0 : calMainCol()->freqGrp().getColumn (freqGrp_p);
805 0 : freqGrpOK_p = true;
806 : };
807 : };
808 28 : return freqGrp_p;
809 : };
810 :
811 : //----------------------------------------------------------------------------
812 :
813 48 : Vector<String>& CalMainBuffer::freqGrpName()
814 : {
815 : // FREQ_GROUP_NAME data field accessor
816 : // Input from private data:
817 : // connectedToIter_p Bool true if connected to iterator
818 : // freqGrpName_p Vector<String> Frequency group name
819 : //
820 : // Fill local cache for this column if cache not valid
821 48 : if (connectedToIter()) {
822 0 : if (!freqGrpNameOK_p) {
823 0 : calMainCol()->freqGrpName().getColumn (freqGrpName_p);
824 0 : freqGrpNameOK_p = true;
825 : };
826 : };
827 48 : return freqGrpName_p;
828 : };
829 :
830 : //----------------------------------------------------------------------------
831 :
832 28 : Vector<String>& CalMainBuffer::fieldName()
833 : {
834 : // FIELD_NAME data field accessor
835 : // Input from private data:
836 : // connectedToIter_p Bool true if connected to iterator
837 : // fieldName_p Vector<String> Field name
838 : //
839 : // Fill local cache for this column if cache not valid
840 28 : if (connectedToIter()) {
841 0 : if (!fieldNameOK_p) {
842 0 : calMainCol()->fieldName().getColumn (fieldName_p);
843 0 : fieldNameOK_p = true;
844 : };
845 : };
846 28 : return fieldName_p;
847 : };
848 :
849 : //----------------------------------------------------------------------------
850 :
851 28 : Vector<String>& CalMainBuffer::fieldCode()
852 : {
853 : // FIELD_CODE data field accessor
854 : // Input from private data:
855 : // connectedToIter_p Bool true if connected to iterator
856 : // fieldCode_p Vector<String> Field code
857 : //
858 : // Fill local cache for this column if cache not valid
859 28 : if (connectedToIter()) {
860 0 : if (!fieldCodeOK_p) {
861 0 : calMainCol()->fieldCode().getColumn (fieldCode_p);
862 0 : fieldCodeOK_p = true;
863 : };
864 : };
865 28 : return fieldCode_p;
866 : };
867 :
868 : //----------------------------------------------------------------------------
869 :
870 28 : Vector<String>& CalMainBuffer::sourceName()
871 : {
872 : // SOURCE_NAME data field accessor
873 : // Input from private data:
874 : // connectedToIter_p Bool true if connected to iterator
875 : // sourceName_p Vector<String> Source name
876 : //
877 : // Fill local cache for this column if cache not valid
878 28 : if (connectedToIter()) {
879 0 : if (!sourceNameOK_p) {
880 0 : calMainCol()->sourceName().getColumn (sourceName_p);
881 0 : sourceNameOK_p = true;
882 : };
883 : };
884 28 : return sourceName_p;
885 : };
886 :
887 : //----------------------------------------------------------------------------
888 :
889 28 : Vector<String>& CalMainBuffer::sourceCode()
890 : {
891 : // SOURCE_CODE data field accessor
892 : // Input from private data:
893 : // connectedToIter_p Bool true if connected to iterator
894 : // sourceCode_p Vector<String> Source code
895 : //
896 : // Fill local cache for this column if cache not valid
897 28 : if (connectedToIter()) {
898 0 : if (!sourceCodeOK_p) {
899 0 : calMainCol()->sourceCode().getColumn (sourceCode_p);
900 0 : sourceCodeOK_p = true;
901 : };
902 : };
903 28 : return sourceCode_p;
904 : };
905 :
906 : //----------------------------------------------------------------------------
907 :
908 28 : Vector<Int>& CalMainBuffer::calGrp()
909 : {
910 : // CALIBRATION_GROUP data field accessor
911 : // Input from private data:
912 : // connectedToIter_p Bool true if connected to iterator
913 : // calGrp_p Vector<Int> Calibration group
914 : //
915 : // Fill local cache for this column if cache not valid
916 28 : if (connectedToIter()) {
917 0 : if (!calGrpOK_p) {
918 0 : calMainCol()->calGrp().getColumn (calGrp_p);
919 0 : calGrpOK_p = true;
920 : };
921 : };
922 28 : return calGrp_p;
923 : };
924 :
925 : //----------------------------------------------------------------------------
926 :
927 52 : Array<Complex>& CalMainBuffer::gain()
928 : {
929 : // GAIN data field accessor
930 : // Input from private data:
931 : // connectedToIter_p Bool true if connected to iterator
932 : // gain_p Array<Complex> Calibration gain
933 : //
934 : // Fill local cache for this column if cache not valid
935 52 : if (connectedToIter()) {
936 0 : if (!gainOK_p) {
937 0 : calMainCol()->gain().getColumn (gain_p);
938 0 : gainOK_p = true;
939 : };
940 : };
941 52 : return gain_p;
942 : };
943 :
944 : //----------------------------------------------------------------------------
945 :
946 72 : Array<Int>& CalMainBuffer::refAnt()
947 : {
948 : // REF_ANT data field accessor
949 : // Input from private data:
950 : // connectedToIter_p Bool true if connected to iterator
951 : // refAnt_p Array<Int> Reference antenna
952 : //
953 : // Fill local cache for this column if cache not valid
954 72 : if (connectedToIter()) {
955 0 : if (!refAntOK_p) {
956 0 : calMainCol()->refAnt().getColumn (refAnt_p);
957 0 : refAntOK_p = true;
958 : };
959 : };
960 72 : return refAnt_p;
961 : };
962 :
963 : //----------------------------------------------------------------------------
964 :
965 52 : Array<Int>& CalMainBuffer::refFeed()
966 : {
967 : // REF_FEED data field accessor
968 : // Input from private data:
969 : // connectedToIter_p Bool true if connected to iterator
970 : // refFeed_p Array<Int> Reference feed
971 : //
972 : // Fill local cache for this column if cache not valid
973 52 : if (connectedToIter()) {
974 0 : if (!refFeedOK_p) {
975 0 : calMainCol()->refFeed().getColumn (refFeed_p);
976 0 : refFeedOK_p = true;
977 : };
978 : };
979 52 : return refFeed_p;
980 : };
981 :
982 : //----------------------------------------------------------------------------
983 :
984 52 : Array<Int>& CalMainBuffer::refReceptor()
985 : {
986 : // REF_FEED data field accessor
987 : // Input from private data:
988 : // connectedToIter_p Bool true if connected to iterator
989 : // refReceptor_p Array<Int> Reference receptor
990 : //
991 : // Fill local cache for this column if cache not valid
992 52 : if (connectedToIter()) {
993 0 : if (!refReceptorOK_p) {
994 0 : calMainCol()->refReceptor().getColumn (refReceptor_p);
995 0 : refReceptorOK_p = true;
996 : };
997 : };
998 52 : return refReceptor_p;
999 : };
1000 :
1001 : //----------------------------------------------------------------------------
1002 :
1003 113 : Array<MFrequency>& CalMainBuffer::refFreqMeas()
1004 : {
1005 : // REF_FREQUENCY data field accessor (as Measure)
1006 : // Input from private data:
1007 : // connectedToIter_p Bool true if connected to iterator
1008 : // refFreqMeas_p Array<MFrequency> Reference frequency as Measure
1009 : //
1010 : // Fill local cache for this column if cache not valid
1011 113 : if (connectedToIter()) {
1012 0 : if (!refFreqMeasOK_p) {
1013 0 : uInt nrow = calMainCol()->time().nrow();
1014 :
1015 : // Assume fixed shape for Array calibration columns
1016 0 : Array<MFrequency> rowRefFreq;
1017 0 : calMainCol()->refFreqMeas().get (0, rowRefFreq);
1018 0 : IPosition rowShape = rowRefFreq.shape();
1019 0 : rowShape.append (IPosition(1,nrow));
1020 0 : refFreqMeas_p.resize(rowShape);
1021 0 : IPosition blc = rowShape;
1022 0 : blc = 0;
1023 0 : IPosition trc = rowShape - 1;
1024 :
1025 0 : for (uInt row = 0; row < nrow; row++) {
1026 0 : calMainCol()->refFreqMeas().get (row, rowRefFreq);
1027 0 : blc.setLast(IPosition(1,row));
1028 0 : trc.setLast(IPosition(1,row));
1029 0 : refFreqMeas_p(blc,trc) = rowRefFreq.addDegenerate(1).copy();
1030 : };
1031 0 : refFreqMeasOK_p = true;
1032 : };
1033 : };
1034 113 : return refFreqMeas_p;
1035 : };
1036 :
1037 : //----------------------------------------------------------------------------
1038 :
1039 27 : Vector<Int>& CalMainBuffer::measFreqRef()
1040 : {
1041 : // REF_FEED data field accessor
1042 : // Input from private data:
1043 : // connectedToIter_p Bool true if connected to iterator
1044 : // measFreqRef_p Vector<Int> Reference frequency frame
1045 : //
1046 : // Fill local cache for this column if cache not valid
1047 27 : if (connectedToIter()) {
1048 0 : if (!measFreqRefOK_p) {
1049 0 : calMainCol()->measFreqRef().getColumn (measFreqRef_p);
1050 0 : measFreqRefOK_p = true;
1051 : };
1052 : };
1053 27 : return measFreqRef_p;
1054 : };
1055 :
1056 : //----------------------------------------------------------------------------
1057 :
1058 73 : Array<MDirection>& CalMainBuffer::refDirMeas()
1059 : {
1060 : // REF_DIRECTION data field accessor (as Measure)
1061 : // Input from private data:
1062 : // connectedToIter_p Bool true if connected to iterator
1063 : // refDirMeas_p Array<MDirection> Reference direction as Measure
1064 : //
1065 : // Fill local cache for this column if cache not valid
1066 73 : if (connectedToIter()) {
1067 0 : if (!refDirMeasOK_p) {
1068 0 : uInt nrow = calMainCol()->time().nrow();
1069 :
1070 : // Assume fixed shape for Array calibration columns
1071 0 : Array<MDirection> rowRefDir;
1072 0 : calMainCol()->refDirMeas().get (0, rowRefDir);
1073 0 : IPosition rowShape = rowRefDir.shape();
1074 0 : rowShape.append (IPosition(1,nrow));
1075 0 : refDirMeas_p.resize(rowShape);
1076 0 : IPosition blc = rowShape;
1077 0 : blc = 0;
1078 0 : IPosition trc = rowShape - 1;
1079 :
1080 0 : for (uInt row = 0; row < nrow; row++) {
1081 0 : calMainCol()->refDirMeas().get (row, rowRefDir);
1082 0 : blc.setLast(IPosition(1,row));
1083 0 : trc.setLast(IPosition(1,row));
1084 0 : refDirMeas_p(blc,trc) = rowRefDir.addDegenerate(1).copy();
1085 : };
1086 0 : refDirMeasOK_p = true;
1087 : };
1088 : };
1089 73 : return refDirMeas_p;
1090 : };
1091 :
1092 : //----------------------------------------------------------------------------
1093 :
1094 27 : Vector<Int>& CalMainBuffer::measDirRef()
1095 : {
1096 : // REF_DIRECTION data field accessor
1097 : // Input from private data:
1098 : // connectedToIter_p Bool true if connected to iterator
1099 : // measDirRef_p Vector<Int> Reference direction frame
1100 : //
1101 : // Fill local cache for this column if cache not valid
1102 27 : if (connectedToIter()) {
1103 0 : if (!measDirRefOK_p) {
1104 0 : calMainCol()->measDirRef().getColumn (measDirRef_p);
1105 0 : measDirRefOK_p = true;
1106 : };
1107 : };
1108 27 : return measDirRef_p;
1109 : };
1110 :
1111 : //----------------------------------------------------------------------------
1112 :
1113 30 : Vector<Int>& CalMainBuffer::calDescId()
1114 : {
1115 : // CAL_DESC_ID data field accessor
1116 : // Input from private data:
1117 : // connectedToIter_p Bool true if connected to iterator
1118 : // calDescId_p Vector<Int> Calibration format descriptor
1119 : //
1120 : // Fill local cache for this column if cache not valid
1121 30 : if (connectedToIter()) {
1122 0 : if (!calDescIdOK_p) {
1123 0 : calMainCol()->calDescId().getColumn (calDescId_p);
1124 0 : calDescIdOK_p = true;
1125 : };
1126 : };
1127 30 : return calDescId_p;
1128 : };
1129 :
1130 : //----------------------------------------------------------------------------
1131 :
1132 29 : Vector<Int>& CalMainBuffer::calHistoryId()
1133 : {
1134 : // CAL_HISTORY_ID data field accessor
1135 : // Input from private data:
1136 : // connectedToIter_p Bool true if connected to iterator
1137 : // calHistoryId_p Vector<Int> Calibration history identifier
1138 : //
1139 : // Fill local cache for this column if cache not valid
1140 29 : if (connectedToIter()) {
1141 0 : if (!calHistoryIdOK_p) {
1142 0 : calMainCol()->calHistoryId().getColumn (calHistoryId_p);
1143 0 : calHistoryIdOK_p = true;
1144 : };
1145 : };
1146 29 : return calHistoryId_p;
1147 : };
1148 :
1149 : //----------------------------------------------------------------------------
1150 :
1151 106 : Vector<Int>& CalMainBuffer::asVecInt (const MSCalEnums::colDef& calEnum)
1152 : {
1153 : // Generic access to integer-type cal buffer columns
1154 : // Input:
1155 : // calEnum const MSCalEnums::colDef& Calibration enum
1156 : // Output:
1157 : // asVecInt Vector<Int>& Reference to the specified
1158 : // calibration buffer column
1159 : //
1160 :
1161 : // Case cal enum of:
1162 106 : switch (calEnum) {
1163 :
1164 : // ANTENNA1:
1165 40 : case MSC::ANTENNA1: {
1166 40 : return antenna1();
1167 : break;
1168 : };
1169 :
1170 : // FEED1
1171 2 : case MSC::FEED1: {
1172 2 : return feed1();
1173 : break;
1174 : };
1175 :
1176 : // FIELD_ID
1177 40 : case MSC::FIELD_ID: {
1178 40 : return fieldId();
1179 : break;
1180 : };
1181 :
1182 : // ARRAY_ID
1183 2 : case MSC::ARRAY_ID: {
1184 2 : return arrayId();
1185 : break;
1186 : };
1187 :
1188 : // OBSERVATION_ID
1189 2 : case MSC::OBSERVATION_ID: {
1190 2 : return obsId();
1191 : break;
1192 : };
1193 :
1194 : // SCAN_NUMBER
1195 2 : case MSC::SCAN_NUMBER: {
1196 2 : return scanNo();
1197 : break;
1198 : };
1199 :
1200 : // PROCESSOR_ID
1201 2 : case MSC::PROCESSOR_ID: {
1202 2 : return processorId();
1203 : break;
1204 : };
1205 :
1206 : // PHASE_ID
1207 2 : case MSC::PHASE_ID: {
1208 2 : return phaseId();
1209 : break;
1210 : };
1211 :
1212 : // STATE_ID
1213 2 : case MSC::STATE_ID: {
1214 2 : return stateId();
1215 : break;
1216 : };
1217 :
1218 : // PULSAR_BIN
1219 2 : case MSC::PULSAR_BIN: {
1220 2 : return pulsarBin();
1221 : break;
1222 : };
1223 :
1224 : // PULSAR_GATE_ID
1225 2 : case MSC::PULSAR_GATE_ID: {
1226 2 : return pulsarGateId();
1227 : break;
1228 : };
1229 :
1230 : // FREQ_GROUP
1231 2 : case MSC::FREQ_GROUP: {
1232 2 : return freqGrp();
1233 : break;
1234 : };
1235 :
1236 : // CALIBRATION_GROUP
1237 2 : case MSC::CALIBRATION_GROUP: {
1238 2 : return calGrp();
1239 : break;
1240 : };
1241 :
1242 : // MEAS_FREQ_REF
1243 0 : case MSC::MEAS_FREQ_REF: {
1244 0 : return measFreqRef();
1245 : break;
1246 : };
1247 :
1248 : // MEAS_DIR_REF
1249 0 : case MSC::MEAS_DIR_REF: {
1250 0 : return measDirRef();
1251 : break;
1252 : };
1253 :
1254 : // CAL_DESC_ID
1255 2 : case MSC::CAL_DESC_ID: {
1256 2 : return calDescId();
1257 : break;
1258 : };
1259 :
1260 : // CAL_HISTORY_ID
1261 2 : case MSC::CAL_HISTORY_ID: {
1262 2 : return calHistoryId();
1263 : break;
1264 : };
1265 :
1266 : // Unrecognized column enum
1267 0 : default: {
1268 0 : throw (AipsError("Unrecognized integer calibration column"));
1269 : };
1270 : };
1271 : };
1272 :
1273 : //----------------------------------------------------------------------------
1274 :
1275 10 : Vector<String>& CalMainBuffer::asVecString (const MSCalEnums::colDef& calEnum)
1276 : {
1277 : // Generic access to string-type cal buffer columns
1278 : // Input:
1279 : // calEnum const MSCalEnums::colDef& Calibration enum
1280 : // Output:
1281 : // asVecString Vector<String>& Reference to the specified
1282 : // calibration buffer column
1283 : //
1284 : // Case cal enum of:
1285 10 : switch (calEnum) {
1286 :
1287 : // FREQ_GROUP_NAME
1288 2 : case MSC::FREQ_GROUP_NAME: {
1289 2 : return freqGrpName();
1290 : break;
1291 : };
1292 :
1293 : // FIELD_NAME
1294 2 : case MSC::FIELD_NAME: {
1295 2 : return fieldName();
1296 : break;
1297 : };
1298 :
1299 : // FIELD_CODE
1300 2 : case MSC::FIELD_CODE: {
1301 2 : return fieldCode();
1302 : break;
1303 : };
1304 :
1305 : // SOURCE_NAME
1306 2 : case MSC::SOURCE_NAME: {
1307 2 : return sourceName();
1308 : break;
1309 : };
1310 :
1311 : // SOURCE_CODE
1312 2 : case MSC::SOURCE_CODE: {
1313 2 : return sourceCode();
1314 : break;
1315 : };
1316 :
1317 : // Unrecognized column enum
1318 0 : default: {
1319 0 : throw (AipsError("Unrecognized string calibration column"));
1320 : };
1321 : };
1322 : };
1323 :
1324 : //----------------------------------------------------------------------------
1325 :
1326 0 : Vector<Int> CalMainBuffer::matchAntenna1 (const Int& antennaId)
1327 : {
1328 : // Find matching rows for a given antenna 1 id.
1329 : // Input:
1330 : // antennaId const Int& Antenna 1 id. to match
1331 : // Output:
1332 : // matchAntenna1 Vector<Int> Matching buffer row numbers
1333 : //
1334 : // Do the match
1335 0 : LogicalArray maskArray = (antenna1() == antennaId);
1336 0 : Vector<Int> rowNo(nRow());
1337 0 : indgen(rowNo);
1338 0 : MaskedArray<Int> maskRowNo(rowNo, maskArray);
1339 0 : return maskRowNo.getCompressedArray();
1340 : };
1341 :
1342 :
1343 : //----------------------------------------------------------------------------
1344 :
1345 20 : Vector<Int> CalMainBuffer::matchAntenna1AndFieldId (const Int& antennaId,
1346 : const Int& fldId)
1347 : {
1348 : // Find matching rows for a given antenna 1 id. and field id. pair
1349 : // Input:
1350 : // antennaId const Int& Antenna 1 id. to match
1351 : // fldId const Int& Field id. to match
1352 : // Output:
1353 : // matchAntenna1AndFieldId Vector<Int> Matching buffer row numbers
1354 : //
1355 : // Do the match
1356 60 : LogicalArray maskArray = (antenna1() == antennaId && fieldId() == fldId);
1357 40 : Vector<Int> rowNo(nRow());
1358 20 : indgen(rowNo);
1359 40 : MaskedArray<Int> maskRowNo(rowNo, maskArray);
1360 20 : Vector<Int> tmp(maskRowNo.getCompressedArray());
1361 40 : return tmp;
1362 : };
1363 :
1364 : //----------------------------------------------------------------------------
1365 :
1366 0 : Vector<Int> CalMainBuffer::matchAntenna1AndFreqGrp (const Int& antennaId,
1367 : const String& frqGrpName)
1368 : {
1369 : // Find matching rows for a given antenna 1 id. and freq. group name
1370 : // Input:
1371 : // antennaId const Int& Antenna 1 id. to match
1372 : // frqGrpName const String& Freq. group name to match
1373 : // Output:
1374 : // matchAntenna1AndFreqGrp Vector<Int> Matching buffer row numbers
1375 : //
1376 : // Do the match
1377 0 : LogicalArray maskArray = (antenna1() == antennaId &&
1378 0 : freqGrpName() == frqGrpName);
1379 0 : Vector<Int> rowNo(nRow());
1380 0 : indgen(rowNo);
1381 0 : MaskedArray<Int> maskRowNo(rowNo, maskArray);
1382 0 : return maskRowNo.getCompressedArray();
1383 : };
1384 :
1385 : //----------------------------------------------------------------------------
1386 :
1387 1 : void CalMainBuffer::invalidate()
1388 : {
1389 : // Invalidate the current cache
1390 : // Output to private data:
1391 : // timeMeasOK_p Bool Time as a Measure cache ok
1392 : // timeEPQuantOK_p Bool EP time as Quantum cache ok
1393 : // intervalQuantOK_p Bool Time interval as Quantum cache ok
1394 : // antenna1OK_p Bool Antenna 1 cache ok
1395 : // feed1OK_p Bool Feed 1 cache ok
1396 : // fieldIdOK_p Bool Field id. cache ok
1397 : // arrayIdOK_p Bool Array id. cache ok
1398 : // obsIdOK_p Bool Observation id. cache ok
1399 : // scanNoOK_p Bool Scan no. cache ok
1400 : // processorIdOK_p Bool Processor id. cache ok
1401 : // stateIdOK_p Bool State id. cache ok
1402 : // phaseIdOK_p Bool Phase id. cache ok
1403 : // pulsarBinOK_p Bool Pulsar bin cache ok
1404 : // pulsarGateIdOK_p Bool Pulsar gate id. cache ok
1405 : // freqGrpOK_p Bool Frequency group cache ok
1406 : // freqGrpNameOK_p Bool Frequency group name cache ok
1407 : // fieldNameOK_p Bool Field name cache ok
1408 : // fieldCodeOK_p Bool Field code cache ok
1409 : // sourceNameOK_p Bool Source name cache ok
1410 : // sourceCodeOK_p Bool Source code cache ok
1411 : // calGrpOK_p Bool Calibration group cache ok
1412 : // gainOK_p Bool Gain cache ok
1413 : // refAntOK_p Bool Reference antenna cache ok
1414 : // refFeedOK_p Bool Reference feed cache ok
1415 : // refReceptorOK_p Bool Reference receptor cache ok
1416 : // refFreqMeasOK_p Bool Ref. freq. as Measure cache ok
1417 : // measFreqRefOK_p Bool Frequency measures ref. cache ok
1418 : // refDirMeasOK_p Bool Ref. dir. as Measure cache ok
1419 : // measDirRefOK_p Bool Direction measures ref. cache ok
1420 : // calDescIdOK_p Bool CAL_DESC id. cache ok
1421 : // calHistoryIdOK_p Bool CAL_HISTORY id. cache ok
1422 : //
1423 : // Set all cache flags to false
1424 1 : timeMeasOK_p = false;
1425 1 : timeEPQuantOK_p = false;
1426 1 : intervalQuantOK_p = false;
1427 1 : antenna1OK_p = false;
1428 1 : feed1OK_p = false;
1429 1 : fieldIdOK_p = false;
1430 1 : arrayIdOK_p = false;
1431 1 : obsIdOK_p = false;
1432 1 : scanNoOK_p = false;
1433 1 : processorIdOK_p = false;
1434 1 : stateIdOK_p = false;
1435 1 : phaseIdOK_p = false;
1436 1 : pulsarBinOK_p = false;
1437 1 : pulsarGateIdOK_p = false;
1438 1 : freqGrpOK_p = false;
1439 1 : freqGrpNameOK_p = false;
1440 1 : fieldNameOK_p = false;
1441 1 : fieldCodeOK_p = false;
1442 1 : sourceNameOK_p = false;
1443 1 : sourceCodeOK_p = false;
1444 1 : calGrpOK_p = false;
1445 1 : gainOK_p = false;
1446 1 : refAntOK_p = false;
1447 1 : refFeedOK_p = false;
1448 1 : refReceptorOK_p = false;
1449 1 : refFreqMeasOK_p = false;
1450 1 : measFreqRefOK_p = false;
1451 1 : refDirMeasOK_p = false;
1452 1 : measDirRefOK_p = false;
1453 1 : calDescIdOK_p = false;
1454 1 : calHistoryIdOK_p = false;
1455 1 : };
1456 :
1457 : //----------------------------------------------------------------------------
1458 :
1459 0 : void CalMainBuffer::fillIndices (const Vector<Int>& calIndices,
1460 : const VisBuffer& vb)
1461 : {
1462 : //
1463 : // Input:
1464 : // calIndices const Vector<Int>& Vector of cal indices, specified
1465 : // as enums from class MSCalEnums
1466 : // vb const VisBuffer& Visibility data buffer
1467 : //
1468 : // Number of input cal indices
1469 0 : Int nCalIndices = calIndices.nelements();
1470 :
1471 0 : if (nCalIndices > 0) {
1472 : // Extract the index ranges from the visibility buffer for each index
1473 0 : Block <Vector<Int> > indexValues(nCalIndices);
1474 0 : for (Int i=0; i < nCalIndices; i++) {
1475 0 : MSC::colDef calEnum = static_cast<MSCalEnums::colDef> (calIndices(i));
1476 : // This method requires indices of integer type
1477 0 : if (MSC::basicType(calEnum) == TpInt) {
1478 : // Case index type of:
1479 0 : switch (calEnum) {
1480 : // ANTENNA1: (requires reading ANTENNA1 and ANTENNA2)
1481 0 : case MSC::ANTENNA1:
1482 0 : indexValues[i] = vb.antIdRange();
1483 0 : break;
1484 : // Other integer columns
1485 0 : default:
1486 0 : indexValues[i] = vb.vecIntRange(calEnum);
1487 0 : break;
1488 : };
1489 :
1490 : } else {
1491 0 : throw AipsError("Calibration buffer initialization error");
1492 : };
1493 : };
1494 :
1495 : // Update the indices in the cal buffer
1496 0 : fillIndices(calIndices, indexValues);
1497 : };
1498 0 : return;
1499 : };
1500 :
1501 :
1502 : //----------------------------------------------------------------------------
1503 :
1504 1 : void CalMainBuffer::fillIndices (const Vector<Int>& calIndices,
1505 : const Block<Vector<Int> >& indexValues)
1506 : {
1507 : //
1508 : // Input:
1509 : // calIndices const Vector<Int>& Vector of cal indices, specified
1510 : // as enums from class MSCalEnums
1511 : // indexValues const Block<Vec<Int>>& Index ranges
1512 : //
1513 : // Output to private data:
1514 : // Possibly several integer columns (via CalMainBuffer::asVecInt()).
1515 : //
1516 : // Number of mapped cal indices
1517 1 : Int nMap = indexValues.nelements();
1518 1 : if (nMap > 0) {
1519 :
1520 : // Fill the cal buffer index columns with all permutations of
1521 : // the cal indices. First compute the product of all index
1522 : // vector lengths up to each index number (minus one)
1523 2 : Vector<Int> nProd(nMap+1);
1524 1 : nProd(0) = 1;
1525 3 : for (Int i=1; i < (nMap+1); i++) {
1526 2 : nProd(i) = nProd(i-1) * indexValues[i-1].nelements();
1527 : };
1528 :
1529 : // Determine the permuted indices for this row, and update
1530 : // each one in the cal buffer
1531 21 : for (Int row=0; row < nProd(nMap); row++) {
1532 20 : Int reduce = row;
1533 60 : for (Int j=nMap-1; j >= 0; j--) {
1534 40 : Int index = reduce / nProd(j);
1535 40 : reduce = reduce - index * nProd(j);
1536 : // Update this index in the cal buffer
1537 : MSCalEnums::colDef calEnum =
1538 40 : static_cast<MSCalEnums::colDef> (calIndices(j));
1539 40 : Vector<Int>& ref = asVecInt(calEnum);
1540 40 : if (ref.nelements() < static_cast<uInt>(row+1)) {
1541 40 : ref.resize (row+1, true);
1542 : };
1543 40 : asVecInt(calEnum)(row) = indexValues[j](index);
1544 : };
1545 : };
1546 : };
1547 1 : return;
1548 : };
1549 :
1550 : //----------------------------------------------------------------------------
1551 :
1552 0 : void CalMainBuffer::fillAttributes (const Vector<Int>& calIndices,
1553 : const VisBuffer& vb)
1554 : {
1555 : //
1556 : // Input:
1557 : // calIndices const Vector<Int>& Vector of cal indices, specified
1558 : // as enums from class MSCalEnums,
1559 : // to exclude
1560 : // vb const VisBuffer& Visibility data buffer
1561 : // Output to private data:
1562 : // timeMeas_p Vector<MEpoch> Time as a Measure
1563 : // timeEPQuant_p Vector<Quantity> Extended prec. time as Quantum
1564 : // intervalQuant_p Vector<Quantity> Time interval as Quantum
1565 : // antenna1_p Vector<Int> Antenna 1
1566 : // feed1_p Vector<Int> Feed 1
1567 : // fieldId_p Vector<Int> Field id.
1568 : // arrayId_p Vector<Int> Array id.
1569 : // obsId_p Vector<Int> Observation id.
1570 : // scanNo_p Vector<Int> Scan no.
1571 : // processorId_p Vector<Int> Processor id.
1572 : // stateId_p Vector<Int> State id.
1573 : // phaseId_p Vector<Int> Phase id.
1574 : // pulsarBin_p Vector<Int> Pulsar bin
1575 : // pulsarGateId_p Vector<Int> Pulsar gate id.
1576 : // freqGrp_p Vector<Int> Frequency group
1577 : // freqGrpName_p Vector<String> Frequency group name
1578 : // fieldName_p Vector<String> Field name
1579 : // fieldCode_p Vector<String> Field code
1580 : // sourceName_p Vector<String> Source name
1581 : // sourceCode_p Vector<String> Source code
1582 : // calGrp_p Vector<Int> Calibration group
1583 : // gain_p Array<Complex> Gain
1584 : // refAnt_p Array<Int> Reference antenna
1585 : // refFeed_p Array<Int> Reference feed
1586 : // refReceptor_p Array<Int> Reference receptor
1587 : // refFreqMeas_p Array<MFrequency> Reference frequency as Measure
1588 : // measFreqRef_p Vector<Int> Frequency measures ref.
1589 : // refDirMeas_p Array<MDirection> Reference direction as Measure
1590 : // measDirRef_p Vector<Int> Direction measures ref.
1591 : // calDescId_p Vector<Int> CAL_DESC id.
1592 : // calHistoryId_p Vector<Int> CAL_HISTORY id.
1593 : //
1594 : // Resize all attribute columns, and set to their default values
1595 0 : fillAttributes(calIndices);
1596 :
1597 : // Process each cal buffer column separately
1598 : //
1599 : // TIME, TIME_EXTRA_PREC and INTERVAL
1600 0 : MEpoch time;
1601 0 : MVEpoch timeEP, interval;
1602 0 : if (vb.timeRange(time, timeEP, interval)) {
1603 0 : if (!excluded(MSC::TIME, calIndices)) {
1604 0 : timeMeas() = time;
1605 : };
1606 0 : if (!excluded(MSC::TIME_EXTRA_PREC, calIndices)) {
1607 0 : timeEPQuant() = timeEP.getTime("s");
1608 : };
1609 0 : if (!excluded(MSC::INTERVAL, calIndices)) {
1610 0 : intervalQuant() = interval.getTime("s");
1611 : };
1612 : } else {
1613 0 : throw(AipsError("Invalid TIME column in uv-data buffer"));
1614 : };
1615 :
1616 : // ANTENNA1, FEED1, FIELD_ID, ARRAY_ID, OBSERVATION_ID, SCAN_NUMBER,
1617 : // PROCESSOR_ID, PHASE_ID, STATE_ID, PULSAR_BIN, PULSAR_GATE_ID
1618 : // (all of Int type)
1619 0 : Vector<Int> colInt(13);
1620 0 : colInt(0) = MSC::ANTENNA1;
1621 0 : colInt(1) = MSC::FEED1;
1622 0 : colInt(2) = MSC::FIELD_ID;
1623 0 : colInt(3) = MSC::ARRAY_ID;
1624 0 : colInt(4) = MSC::OBSERVATION_ID;
1625 0 : colInt(5) = MSC::SCAN_NUMBER;
1626 0 : colInt(6) = MSC::PROCESSOR_ID;
1627 0 : colInt(7) = MSC::PHASE_ID;
1628 0 : colInt(8) = MSC::STATE_ID;
1629 0 : colInt(9) = MSC::PULSAR_BIN;
1630 0 : colInt(10) = MSC::PULSAR_GATE_ID;
1631 0 : colInt(11) = MSC::FREQ_GROUP;
1632 0 : colInt(12) = MSC::CALIBRATION_GROUP;
1633 :
1634 0 : for (uInt i=0; i < colInt.nelements(); i++) {
1635 0 : MSCalEnums::colDef calEnum = static_cast<MSCalEnums::colDef>(colInt(i));
1636 0 : if (!excluded(calEnum, calIndices)) {
1637 0 : Vector<Int> range = vb.vecIntRange(calEnum);
1638 0 : if (range.nelements() == 1) {
1639 : // Single unique value found
1640 0 : asVecInt(calEnum) = range(0);
1641 : } else {
1642 : // Multiple values; denote by -1
1643 0 : asVecInt(calEnum) = -1;
1644 : };
1645 : };
1646 : };
1647 :
1648 0 : return;
1649 : };
1650 :
1651 : //----------------------------------------------------------------------------
1652 :
1653 1 : void CalMainBuffer::fillAttributes (const Vector<Int>& calIndices)
1654 : {
1655 : // Resize all attribute columns and set to their default values
1656 : // Input:
1657 : // calIndices const Vector<Int>& Vector of cal indices, specified
1658 : // as enums from class MSCalEnums,
1659 : // to exclude
1660 : // Output to private data:
1661 : // Possibly several integer columns (via CalMainBuffer::asVecInt()).
1662 : //
1663 : // Use the maximum number of rows currently defined in the cal buffer
1664 1 : uInt nrow = nRow();
1665 :
1666 : // Process each cal buffer column separately
1667 : //
1668 : // TIME
1669 1 : timeMeas().resize(nrow);
1670 1 : timeMeas() = MEpoch(Quantity(0, "s"));
1671 :
1672 : // TIME_EXTRA_PREC
1673 1 : timeEPQuant().resize(nrow);
1674 1 : timeEPQuant() = Quantity(0, "s");
1675 :
1676 : // INTERVAL
1677 1 : intervalQuant().resize(nrow);
1678 1 : intervalQuant() = Quantity(0, "s");
1679 :
1680 : // ANTENNA1, FEED1, FIELD_ID, ARRAY_ID, OBSERVATION_ID, SCAN_NUMBER,
1681 : // PROCESSOR_ID, PHASE_ID, STATE_ID, PULSAR_BIN, PULSAR_GATE_ID,
1682 : // FREQ_GROUP, CALIBRATION_GROUP, CAL_DESC_ID and CAL_HISTORY_ID
1683 : // (all of Int type)
1684 2 : Vector<Int> colInt(15);
1685 1 : colInt(0) = MSC::ANTENNA1;
1686 1 : colInt(1) = MSC::FEED1;
1687 1 : colInt(2) = MSC::FIELD_ID;
1688 1 : colInt(3) = MSC::ARRAY_ID;
1689 1 : colInt(4) = MSC::OBSERVATION_ID;
1690 1 : colInt(5) = MSC::SCAN_NUMBER;
1691 1 : colInt(6) = MSC::PROCESSOR_ID;
1692 1 : colInt(7) = MSC::PHASE_ID;
1693 1 : colInt(8) = MSC::STATE_ID;
1694 1 : colInt(9) = MSC::PULSAR_BIN;
1695 1 : colInt(10) = MSC::PULSAR_GATE_ID;
1696 1 : colInt(11) = MSC::FREQ_GROUP;
1697 1 : colInt(12) = MSC::CALIBRATION_GROUP;
1698 1 : colInt(13) = MSC::CAL_DESC_ID;
1699 1 : colInt(14) = MSC::CAL_HISTORY_ID;
1700 :
1701 16 : for (uInt i=0; i < colInt.nelements(); i++) {
1702 15 : MSCalEnums::colDef calEnum = static_cast<MSCalEnums::colDef>(colInt(i));
1703 15 : if (!excluded(calEnum, calIndices)) {
1704 13 : asVecInt(calEnum).resize(nrow);
1705 13 : asVecInt(calEnum) = -1;
1706 : };
1707 : };
1708 :
1709 : // FREQ_GROUP_NAME, FIELD_NAME, FIELD_CODE, SOURCE_NAME and SOURCE_CODE
1710 : // (all of String type)
1711 2 : Vector<Int> colString(5);
1712 1 : colString(0) = MSC::FREQ_GROUP_NAME;
1713 1 : colString(1) = MSC::FIELD_NAME;
1714 1 : colString(2) = MSC::FIELD_CODE;
1715 1 : colString(3) = MSC::SOURCE_NAME;
1716 1 : colString(4) = MSC::SOURCE_CODE;
1717 :
1718 6 : for (uInt i=0; i < colString.nelements(); i++) {
1719 5 : MSCalEnums::colDef calEnum = static_cast<MSCalEnums::colDef>(colString(i));
1720 5 : if (!excluded(calEnum, calIndices)) {
1721 5 : asVecString(calEnum).resize(nrow);
1722 5 : asVecString(calEnum) = "";
1723 : };
1724 : };
1725 :
1726 : // Array-based columns (set to default unit length in each dimension)
1727 1 : uInt numSpw = 1;
1728 1 : uInt numChan = 1;
1729 1 : uInt numReceptors = 1;
1730 1 : uInt nJones = 1;
1731 2 : IPosition sizeA(5, nJones, nJones, numSpw, numChan, nrow);
1732 2 : IPosition sizeB(4, numReceptors, numSpw, numChan, nrow);
1733 :
1734 : // GAIN
1735 1 : gain().resize(sizeA);
1736 1 : gain() = 0;
1737 :
1738 : // REF_ANT
1739 1 : refAnt().resize(sizeB);
1740 1 : refAnt() = 0;
1741 :
1742 : // REF_FEED
1743 1 : refFeed().resize(sizeB);
1744 1 : refFeed() = 0;
1745 :
1746 : // REF_RECEPTOR
1747 1 : refReceptor().resize(sizeB);
1748 1 : refReceptor() = 0;
1749 :
1750 : // REF_FREQUENCY and MEAS_FREQ_REF
1751 1 : refFreqMeas().resize(sizeB);
1752 1 : refFreqMeas() = MFrequency(Quantity(0, "Hz"));
1753 1 : measFreqRef().resize(nrow);
1754 1 : measFreqRef() = 0;
1755 :
1756 : // REF_DIRECTION and MEAS_DIR_REF
1757 1 : refDirMeas().resize(sizeB);
1758 1 : refDirMeas() = MDirection();
1759 1 : measDirRef().resize(nrow);
1760 1 : measDirRef() = 0;
1761 :
1762 2 : return;
1763 : };
1764 :
1765 : //----------------------------------------------------------------------------
1766 :
1767 20 : Bool CalMainBuffer::excluded (const MSCalEnums::colDef& calEnum,
1768 : const Vector<Int>& excludeIndices)
1769 : {
1770 : //
1771 : // Input:
1772 : // calEnum const MSCalEnums::colDef& Calibration enum (from MSCalEnums)
1773 : // calIndices const Vector<Int>& Vector of excluded calibration
1774 : // enums (from class MSCalEnums)
1775 : // Output:
1776 : // excluded Bool true if enum is present in the
1777 : // list of excluded enums
1778 : //
1779 : // Check for membership
1780 20 : Int calEnumInt = static_cast<Int>(calEnum);
1781 40 : return anyEQ(excludeIndices, calEnumInt);
1782 : };
1783 :
1784 : //----------------------------------------------------------------------------
1785 :
1786 : } //# NAMESPACE CASA - END
1787 :
|
