Line data Source code
1 : /*
2 : * VisBufferImpl.cc
3 : *
4 : * Created on: Jul 3, 2012
5 : * Author: jjacobs
6 : */
7 :
8 :
9 : //#include <casa/Arrays/ArrayLogical.h>
10 : //#include <casa/Arrays/ArrayMath.h>
11 : //#include <casa/Arrays/ArrayUtil.h>
12 : //#include <casa/Arrays/MaskArrMath.h>
13 : //#include <casa/Arrays/MaskedArray.h>
14 : #include <casacore/casa/OS/Path.h>
15 : #include <casacore/casa/OS/Timer.h>
16 : #include <casacore/casa/Utilities.h>
17 : #include <casacore/casa/aipstype.h>
18 : #include <typeinfo>
19 : #include <components/ComponentModels/ComponentList.h>
20 : #include <casacore/ms/MeasurementSets/MSColumns.h>
21 : #include <stdcasa/UtilJ.h>
22 : #include <msvis/MSVis/VisBufferAsyncWrapper2.h>
23 : #include <msvis/MSVis/VisBufferComponents2.h>
24 : #include <msvis/MSVis/VisBufferComponents2.h>
25 : #include <msvis/MSVis/VisBufferImpl2.h>
26 : #include <msvis/MSVis/VisBuffer2Adapter.h>
27 : #include <msvis/MSVis/VisibilityIterator2.h>
28 : #include <msvis/MSVis/Vbi2MsRow.h>
29 : #include <msvis/MSVis/VisModelDataI.h>
30 : #include <msvis/MSVis/VisBufferImpl2Internal.h>
31 :
32 :
33 : #define CheckVisIter() checkVisIter (__func__, __FILE__, __LINE__)
34 : #define CheckVisIter1(s) checkVisIter (__func__, __FILE__, __LINE__,s)
35 : #define CheckVisIterBase() checkVisIterBase (__func__, __FILE__, __LINE__)
36 :
37 : #include <functional>
38 :
39 : using namespace std;
40 :
41 : using namespace casacore;
42 : namespace casa {
43 :
44 : using namespace casacore;
45 : using namespace casa::ms;
46 :
47 : namespace vi {
48 :
49 :
50 :
51 53981 : VisBufferCache::VisBufferCache (VisBufferImpl2 * vb)
52 53981 : : imagingWeight_p (true)
53 : {
54 53981 : ThrowIf (vb == NULL, "VisBufferCacheImpl not connected to VisBufferImpl2");
55 53981 : }
56 :
57 : void
58 53981 : VisBufferCache::initialize (VisBufferImpl2 * vb)
59 : {
60 :
61 : // Initialize the cache items. This will also register them
62 : // with the vb object to allow it to iterate over the cached
63 : // values.
64 :
65 53981 : antenna1_p.initialize (this, vb, & VisBufferImpl2::fillAntenna1,
66 : VisBufferComponent2::Antenna1, Nr, true);
67 53981 : antenna2_p.initialize (this, vb, &VisBufferImpl2::fillAntenna2,
68 : VisBufferComponent2::Antenna2, Nr, true);
69 53981 : arrayId_p.initialize (this, vb, &VisBufferImpl2::fillArrayId,
70 : VisBufferComponent2::ArrayId, Nr, true);
71 53981 : cjones_p.initialize (this, vb, &VisBufferImpl2::fillJonesC,
72 : VisBufferComponent2::JonesC, NoCheck, false);
73 53981 : correctedVisCube_p.initialize (this, vb, &VisBufferImpl2::fillCubeCorrected,
74 : VisBufferComponent2::VisibilityCubeCorrected,
75 : NcNfNr, false);
76 53981 : correctedVisCubes_p.initialize (this, vb, &VisBufferImpl2::fillCubesCorrected,
77 : VisBufferComponent2::VisibilityCubesCorrected,
78 : NsNcNfNr, false);
79 53981 : corrType_p.initialize (this, vb, &VisBufferImpl2::fillCorrType,
80 : VisBufferComponent2::CorrType, NoCheck, false);
81 53981 : dataDescriptionIds_p.initialize (this, vb, &VisBufferImpl2::fillDataDescriptionIds,
82 : VisBufferComponent2::DataDescriptionIds, Nr, true);
83 53981 : direction1_p.initialize (this, vb, &VisBufferImpl2::fillDirection1,
84 : VisBufferComponent2::Direction1, NoCheck, false);
85 53981 : direction2_p.initialize (this, vb, &VisBufferImpl2::fillDirection2,
86 : VisBufferComponent2::Direction2, NoCheck, false);
87 53981 : exposure_p.initialize (this, vb, &VisBufferImpl2::fillExposure,
88 : VisBufferComponent2::Exposure, Nr, false);
89 53981 : feed1_p.initialize (this, vb, &VisBufferImpl2::fillFeed1,
90 : VisBufferComponent2::Feed1, Nr, false);
91 53981 : feed1Pa_p.initialize (this, vb, &VisBufferImpl2::fillFeedPa1,
92 : VisBufferComponent2::FeedPa1, NoCheck, false);
93 53981 : feed2_p.initialize (this, vb, &VisBufferImpl2::fillFeed2,
94 : VisBufferComponent2::Feed2, Nr, false);
95 53981 : feed2Pa_p.initialize (this, vb, &VisBufferImpl2::fillFeedPa2,
96 : VisBufferComponent2::FeedPa2, NoCheck, false);
97 53981 : fieldId_p.initialize (this, vb, &VisBufferImpl2::fillFieldId,
98 : VisBufferComponent2::FieldId, Nr, true);
99 53981 : flagCategory_p.initialize (this, vb, &VisBufferImpl2::fillFlagCategory,
100 : VisBufferComponent2::FlagCategory, NoCheck, false);
101 : // required column but not used in casa, make it a nocheck for shape validation
102 53981 : flagCube_p.initialize (this, vb, &VisBufferImpl2::fillFlagCube,
103 : VisBufferComponent2::FlagCube, NcNfNr, false);
104 53981 : flagCubes_p.initialize (this, vb, &VisBufferImpl2::fillFlagCubes,
105 : VisBufferComponent2::FlagCubes, NsNcNfNr, false);
106 53981 : flagRow_p.initialize (this, vb, &VisBufferImpl2::fillFlagRow,
107 : VisBufferComponent2::FlagRow, Nr, false);
108 53981 : floatDataCube_p.initialize (this, vb, &VisBufferImpl2::fillFloatData,
109 : VisBufferComponent2::VisibilityCubeFloat, NcNfNr, false);
110 53981 : floatDataCubes_p.initialize (this, vb, &VisBufferImpl2::fillFloatCubes,
111 : VisBufferComponent2::VisibilityCubesFloat, NsNcNfNr, false);
112 53981 : imagingWeight_p.initialize (this, vb, &VisBufferImpl2::fillImagingWeight,
113 : VisBufferComponent2::ImagingWeight, NoCheck, false);
114 53981 : modelVisCube_p.initialize (this, vb, &VisBufferImpl2::fillCubeModel,
115 : VisBufferComponent2::VisibilityCubeModel, NcNfNr, false);
116 53981 : modelVisCubes_p.initialize (this, vb, &VisBufferImpl2::fillCubesModel,
117 : VisBufferComponent2::VisibilityCubesModel, NsNcNfNr, false);
118 53981 : nAntennas_p.initialize (this, vb, &VisBufferImpl2::fillNAntennas,
119 : VisBufferComponent2::NAntennas, false);
120 53981 : nChannels_p.initialize (this, vb, &VisBufferImpl2::fillNChannel,
121 : VisBufferComponent2::NChannels, false);
122 53981 : nCorrelations_p.initialize (this, vb, &VisBufferImpl2::fillNCorr,
123 : VisBufferComponent2::NCorrelations);
124 53981 : nRows_p.initialize (this, vb, &VisBufferImpl2::fillNRow,
125 : VisBufferComponent2::NRows, false);
126 53981 : nShapes_p.initialize (this, vb, &VisBufferImpl2::fillNShapes,
127 : VisBufferComponent2::NShapes, false);
128 53981 : nRowsPerShape_p.initialize (this, vb, &VisBufferImpl2::fillNRowPerShape,
129 : VisBufferComponent2::NRowsPerShape, Ns, false);
130 53981 : nChannelsPerShape_p.initialize (this, vb, &VisBufferImpl2::fillNChannelPerShape,
131 : VisBufferComponent2::NChannelsPerShape, Ns, false);
132 53981 : nCorrelationsPerShape_p.initialize (this, vb, &VisBufferImpl2::fillNCorrPerShape,
133 : VisBufferComponent2::NCorrelationsPerShape, Ns, false);
134 53981 : observationId_p.initialize (this, vb, &VisBufferImpl2::fillObservationId,
135 : VisBufferComponent2::ObservationId, Nr, true);
136 53981 : phaseCenter_p.initialize (this, vb, &VisBufferImpl2::fillPhaseCenter,
137 : VisBufferComponent2::PhaseCenter, false);
138 53981 : polFrame_p.initialize (this, vb, &VisBufferImpl2::fillPolFrame,
139 : VisBufferComponent2::PolFrame, false);
140 53981 : polarizationId_p.initialize (this, vb, &VisBufferImpl2::fillPolarizationId,
141 : VisBufferComponent2::PolarizationId, false);
142 53981 : processorId_p.initialize (this, vb, &VisBufferImpl2::fillProcessorId,
143 : VisBufferComponent2::ProcessorId, Nr, true);
144 53981 : rowIds_p.initialize (this, vb, &VisBufferImpl2::fillRowIds,
145 : VisBufferComponent2::RowIds, Nr, false);
146 53981 : scan_p.initialize (this, vb, &VisBufferImpl2::fillScan,
147 : VisBufferComponent2::Scan, Nr, true);
148 53981 : sigma_p.initialize (this, vb, &VisBufferImpl2::fillSigma,
149 : VisBufferComponent2::Sigma, NcNr, false);
150 53981 : sigmas_p.initialize (this, vb, &VisBufferImpl2::fillSigmas,
151 : VisBufferComponent2::Sigma, NsNcNr, false);
152 53981 : spectralWindows_p.initialize (this, vb, &VisBufferImpl2::fillSpectralWindows,
153 : VisBufferComponent2::SpectralWindows, Nr, false);
154 53981 : stateId_p.initialize (this, vb, &VisBufferImpl2::fillStateId,
155 : VisBufferComponent2::StateId, Nr, true);
156 53981 : time_p.initialize (this, vb, &VisBufferImpl2::fillTime,
157 : VisBufferComponent2::Time, Nr, true);
158 53981 : timeCentroid_p.initialize (this, vb, &VisBufferImpl2::fillTimeCentroid,
159 : VisBufferComponent2::TimeCentroid, Nr, false);
160 53981 : timeInterval_p.initialize (this, vb, &VisBufferImpl2::fillTimeInterval,
161 : VisBufferComponent2::TimeInterval, Nr, false);
162 53981 : uvw_p.initialize (this, vb, &VisBufferImpl2::fillUvw,
163 : VisBufferComponent2::Uvw, I3Nr, false);
164 53981 : visCube_p.initialize (this, vb, &VisBufferImpl2::fillCubeObserved,
165 : VisBufferComponent2::VisibilityCubeObserved, NcNfNr, false);
166 53981 : visCubes_p.initialize (this, vb, &VisBufferImpl2::fillCubesObserved,
167 : VisBufferComponent2::VisibilityCubesObserved, NsNcNfNr, false);
168 53981 : weight_p.initialize (this, vb, &VisBufferImpl2::fillWeight,
169 : VisBufferComponent2::Weight, NcNr, false);
170 53981 : weights_p.initialize (this, vb, &VisBufferImpl2::fillWeights,
171 : VisBufferComponent2::Weights, NsNcNr, false);
172 53981 : weightSpectrum_p.initialize (this, vb, &VisBufferImpl2::fillWeightSpectrum,
173 : VisBufferComponent2::WeightSpectrum,
174 : NcNfNr, false);
175 53981 : weightSpectra_p.initialize (this, vb, &VisBufferImpl2::fillWeightSpectra,
176 : VisBufferComponent2::WeightSpectra,
177 : NsNcNfNr, false);
178 53981 : sigmaSpectrum_p.initialize (this, vb, &VisBufferImpl2::fillSigmaSpectrum,
179 : VisBufferComponent2::SigmaSpectrum,
180 : NcNfNr, false);
181 53981 : sigmaSpectra_p.initialize (this, vb, &VisBufferImpl2::fillSigmaSpectra,
182 : VisBufferComponent2::SigmaSpectra,
183 : NsNcNfNr, false);
184 53981 : }
185 :
186 : void
187 3022936 : VisBufferCache::registerItem (VbCacheItemBase * item)
188 : {
189 3022936 : registry_p.push_back (item);
190 3022936 : }
191 :
192 : void
193 3022936 : VbCacheItemBase::initialize (VisBufferCache * cache, VisBufferImpl2 * vb, VisBufferComponent2 component, Bool isKey)
194 : {
195 3022936 : vbComponent_p = component;
196 3022936 : vb_p = vb;
197 3022936 : cache->registerItem (this);
198 3022936 : setIsKey (isKey);
199 3022936 : }
200 :
201 :
202 : using namespace vi;
203 :
204 : ////////////////////////////////////////////////////////////
205 : //
206 : // Basic VisBufferImpl2 Methods
207 : // ========================
208 : //
209 : // Other sections contain the accessor and filler methods
210 :
211 47196 : VisBufferImpl2::VisBufferImpl2 (VisBufferOptions options)
212 47196 : : cache_p (0), msRow_p (0), state_p (0)
213 : {
214 47196 : construct (0, options);
215 47196 : }
216 :
217 6785 : VisBufferImpl2::VisBufferImpl2(ViImplementation2 * vii, VisBufferOptions options)
218 6785 : : cache_p (0),
219 6785 : msRow_p (0),
220 6785 : state_p (0)
221 : {
222 6785 : construct (vii, options);
223 6785 : }
224 :
225 107599 : VisBufferImpl2::~VisBufferImpl2 ()
226 : {
227 53981 : delete cache_p;
228 53981 : delete msRow_p;
229 53981 : delete state_p;
230 107599 : }
231 :
232 : void
233 490219 : VisBufferImpl2::appendRow (Vbi2MsRow * rowSrc,
234 : Int initialCapacity,
235 : const VisBufferComponents2 & optionalComponentsToCopy,
236 : bool doCopy)
237 : {
238 : // First check to see if the buffer needs to be reconfigured before another
239 : // row can be appended.
240 :
241 : // if (state_p->appendSize_p == 0 ||
242 : // state_p->appendSize_p == state_p->appendCapacity_p){
243 : //
244 : // if (msRow_p == 0){
245 : // msRow_p = new Vbi2MsRow (0, this);
246 : // }
247 : //
248 : // // The buffer is either empty or completely full; resize it so
249 : // // that there is room to add more rows.
250 : //
251 : // Int nRowsToAdd;
252 : //
253 : // if (state_p->appendSize_p == 0){
254 : //
255 : // // If appendSize is zero then the buffer is completely empty.
256 : // // If capacity is nonzero then reuse that capacity.
257 : //
258 : // nRowsToAdd = state_p->appendCapacity_p; // nonzero if buffer is being reused
259 : //
260 : // if (nRowsToAdd == 0){
261 : // nRowsToAdd = initialCapacity; // new buffer: use provided initial capacity
262 : // }
263 : //
264 : // state_p->appendCapacity_p = nRowsToAdd;
265 : // }
266 : // else{
267 : //
268 : // // All rows in use so add 40% more rows
269 : //
270 : // nRowsToAdd = (state_p->appendCapacity_p * 4) / 10;
271 : // state_p->appendCapacity_p += nRowsToAdd;
272 : // }
273 : //
274 : // for (CacheRegistry::iterator i = cache_p->registry_p.begin();
275 : // i != cache_p->registry_p.end();
276 : // i++){
277 : //
278 : // // Resize the various arrays so that they have the appropriate
279 : // // row dimension.
280 : //
281 : // (*i)->appendRows (state_p->appendCapacity_p);
282 : // }
283 : // }
284 :
285 : // Now append the row.
286 :
287 : // Assert (state_p->appendSize_p <= cache_p->time_p.getItem().shape()(0));
288 :
289 490219 : if (msRow_p == 0){
290 361 : msRow_p = new Vbi2MsRow (0, this);
291 : }
292 :
293 :
294 490219 : state_p->appendSize_p ++;
295 :
296 490219 : if (state_p->appendSize_p >= cache_p->time_p.getItem().shape().last()){
297 :
298 54174 : Int desiredNRows = max (state_p->appendSize_p, initialCapacity);
299 :
300 54174 : for (CacheRegistry::iterator i = cache_p->registry_p.begin();
301 3087918 : i != cache_p->registry_p.end();
302 3033744 : i++){
303 :
304 : // Resize the various arrays so that they have the appropriate
305 : // row dimension.
306 :
307 3033744 : (*i)->appendRows (desiredNRows);
308 : }
309 : }
310 :
311 : // Now copy the provided row into the next one in this buffer.
312 :
313 490219 : if (doCopy){
314 :
315 490219 : msRow_p->changeRow (state_p->appendSize_p - 1);
316 :
317 490219 : msRow_p->copy (rowSrc, optionalComponentsToCopy);
318 : }
319 490219 : }
320 :
321 : void
322 52351 : VisBufferImpl2::appendRowsComplete ()
323 : {
324 : // Close out the append operation by trimming off the
325 : // excess baselines in the buffer.
326 :
327 52351 : for (CacheRegistry::iterator i = cache_p->registry_p.begin();
328 2984007 : i != cache_p->registry_p.end();
329 2931656 : i++){
330 :
331 2931656 : (*i)->appendRows (state_p->appendSize_p, true);
332 : }
333 :
334 52351 : cache_p->nRows_p.setSpecial (state_p->appendSize_p);
335 : //Assume that the append happens on the first shape only
336 52351 : Vector<rownr_t> nRowsPerShape = cache_p->nRowsPerShape_p.get();
337 52351 : nRowsPerShape[0] = state_p->appendSize_p;
338 52351 : cache_p->nRowsPerShape_p.setSpecial (nRowsPerShape);
339 :
340 52351 : state_p->appendSize_p = 0; //
341 52351 : }
342 :
343 : Int
344 1157424 : VisBufferImpl2::appendSize () const
345 : {
346 1157424 : return state_p->appendSize_p;
347 : }
348 :
349 :
350 :
351 : Bool
352 0 : VisBufferImpl2::areCorrelationsInCanonicalOrder () const
353 : {
354 0 : Vector<Int> corrs(correlationTypes());
355 :
356 : // Only a meaningful question is all 4 corrs present
357 :
358 0 : Bool result = corrs.nelements () == 4 &&
359 0 : (corrs (1) == Stokes::LL || corrs (1) == Stokes::YY);
360 :
361 0 : return result;
362 0 : }
363 :
364 : Bool
365 0 : VisBufferImpl2::areCorrelationsSorted() const
366 : {
367 0 : return state_p->areCorrelationsSorted_p = false;
368 : }
369 :
370 : void
371 36051764 : VisBufferImpl2::checkVisIter (const char * func, const char * file, int line, const char * extra) const
372 : {
373 36051764 : checkVisIterBase (func, file, line, extra);
374 36051764 : }
375 :
376 : void
377 36092776 : VisBufferImpl2::checkVisIterBase (const char * func, const char * file, int line, const char * extra) const
378 : {
379 36092776 : if (! state_p->isAttached_p) {
380 0 : throw AipsError (String ("VisBuffer not attached to a ViImplementation2 while filling this field in (") +
381 0 : func + extra + ")", file, line);
382 : }
383 :
384 36092776 : if (getViiP() == NULL){
385 0 : throw AipsError (String ("VisBuffer's ViImplementation2 is NULL while filling this field in (") +
386 0 : func + extra + ")", file, line);
387 : }
388 36092776 : }
389 :
390 : void
391 3979573 : VisBufferImpl2::cacheClear (Bool markAsCached)
392 : {
393 3979573 : for (CacheRegistry::iterator i = cache_p->registry_p.begin();
394 226835661 : i != cache_p->registry_p.end();
395 222856088 : i++){
396 :
397 222856088 : (*i)->clear (false);
398 :
399 222856088 : if (markAsCached){
400 0 : (*i)->setAsPresent ();
401 : }
402 : }
403 3979573 : }
404 :
405 : void
406 14691 : VisBufferImpl2::cacheResizeAndZero (const VisBufferComponents2 & components)
407 : {
408 14691 : Bool doAll = components.empty();
409 :
410 14691 : for (CacheRegistry::iterator i = cache_p->registry_p.begin();
411 837387 : i != cache_p->registry_p.end();
412 822696 : i++){
413 :
414 822696 : if (! doAll && ! components.contains((*i)->getComponent())){
415 407100 : continue; // this one is excluded
416 : }
417 :
418 415596 : (*i)->resize (false);
419 :
420 415596 : (*i)->setAsPresent();
421 : }
422 14691 : }
423 :
424 :
425 :
426 : void
427 53981 : VisBufferImpl2::construct (ViImplementation2 * vi, VisBufferOptions options)
428 : {
429 53981 : state_p = new VisBufferState ();
430 :
431 : // Initialize all non-object member variables
432 :
433 53981 : state_p->areCorrelationsSorted_p = false; // Have correlations been sorted by sortCorr?
434 :
435 53981 : state_p->isAttached_p = vi != 0;
436 53981 : state_p->pointingTableLastRow_p = -1;
437 53981 : state_p->newMs_p = true;
438 53981 : state_p->vi_p = vi;
439 :
440 : // Handle the options
441 :
442 53981 : state_p->isWritable_p = false;
443 53981 : state_p->isRekeyable_p = false;
444 :
445 53981 : if (options & VbRekeyable){
446 :
447 48074 : state_p->isWritable_p = true; // rekeyable implies writable
448 48074 : state_p->isRekeyable_p = true;
449 : }
450 5907 : else if (options & VbWritable){
451 3232 : state_p->isWritable_p = true;
452 : }
453 :
454 53981 : cache_p = new VisBufferCache (this);
455 53981 : cache_p->initialize (this);
456 53981 : }
457 :
458 : void
459 0 : VisBufferImpl2::copy (const VisBuffer2 & otherRaw, Bool fetchIfNeeded)
460 : {
461 0 : copyComponents (otherRaw, VisBufferComponents2::exceptThese({VisBufferComponent2::FlagCategory}),
462 : true, fetchIfNeeded);
463 0 : }
464 :
465 : void
466 47196 : VisBufferImpl2::copyComponents (const VisBuffer2 & otherRaw,
467 : const VisBufferComponents2 & components,
468 : Bool allowShapeChange,
469 : Bool fetchIfNeeded)
470 : {
471 47196 : const VisBufferImpl2 * other = dynamic_cast<const VisBufferImpl2 *> (& otherRaw);
472 :
473 47196 : ThrowIf (other == 0,
474 : String::format ("Copy between %s and VisBufferImpl2 not implemented.",
475 : typeid (otherRaw).name()));
476 :
477 47196 : if (! hasShape()){
478 :
479 : // If this VB is shapeless, then assume the shape of the source VB.
480 :
481 47196 : setShape (otherRaw.nCorrelations(), otherRaw.nChannels(), otherRaw.nRows(), true);
482 : }
483 0 : else if (allowShapeChange && getShape() != otherRaw.getShape()){
484 :
485 0 : setShape (otherRaw.nCorrelations(), otherRaw.nChannels(), otherRaw.nRows(), true);
486 : }
487 :
488 47196 : setIterationInfo (other->msId(),
489 47196 : other->msName (),
490 47196 : other->isNewMs (),
491 47196 : other->isNewArrayId (),
492 47196 : other->isNewFieldId (),
493 47196 : other->isNewSpectralWindow (),
494 47196 : other->getSubchunk (),
495 94392 : other->getCorrelationTypes(),
496 94392 : other->getCorrelationTypesDefined(),
497 94392 : other->getCorrelationTypesSelected(),
498 94392 : other->getWeightScaling());
499 :
500 47196 : Bool wasFillable = isFillable();
501 47196 : setFillable (true);
502 :
503 94392 : for (CacheRegistry::iterator dst = cache_p->registry_p.begin(),
504 47196 : src = other->cache_p->registry_p.begin();
505 2690172 : dst != cache_p->registry_p.end();
506 2642976 : dst ++, src ++){
507 :
508 2642976 : if (components.contains ((* src)->getComponent())){
509 :
510 : try {
511 :
512 849528 : (* dst)->copy (* src, fetchIfNeeded);
513 : }
514 0 : catch (AipsError & e){
515 :
516 : String m = String::format ("While copying %s",
517 0 : VisBufferComponents2::name ((* src)->getComponent()).c_str());
518 0 : Rethrow (e, m);
519 0 : }
520 : }
521 : }
522 :
523 47196 : setFillable (wasFillable);
524 47196 : }
525 :
526 : void
527 0 : VisBufferImpl2::copyCoordinateInfo (const VisBuffer2 * vb, Bool dirDependent,
528 : Bool allowShapeChange, Bool fetchIfNeeded)
529 : {
530 :
531 : VisBufferComponents2 components =
532 : VisBufferComponents2::these ({VisBufferComponent2::Antenna1,
533 : VisBufferComponent2::Antenna2,
534 : VisBufferComponent2::ArrayId,
535 : VisBufferComponent2::DataDescriptionIds,
536 : VisBufferComponent2::FieldId,
537 : VisBufferComponent2::SpectralWindows,
538 : VisBufferComponent2::Time,
539 : VisBufferComponent2::NRows,
540 : VisBufferComponent2::Feed1,
541 0 : VisBufferComponent2::Feed2});
542 :
543 0 : copyComponents (* vb, components, allowShapeChange, fetchIfNeeded);
544 :
545 0 : if(dirDependent){
546 :
547 : VisBufferComponents2 components =
548 : VisBufferComponents2::these ({VisBufferComponent2::Direction1,
549 : VisBufferComponent2::Direction2,
550 : VisBufferComponent2::FeedPa1,
551 0 : VisBufferComponent2::FeedPa2});
552 :
553 0 : copyComponents (* vb, components, allowShapeChange, fetchIfNeeded);
554 0 : }
555 0 : }
556 :
557 : void
558 0 : VisBufferImpl2::copyRow (Int sourceRow, Int destinationRow)
559 : {
560 0 : for (CacheRegistry::iterator i = cache_p->registry_p.begin();
561 0 : i != cache_p->registry_p.end();
562 0 : i++){
563 :
564 0 : if (! (* i)->isPresent()){
565 0 : continue;
566 : }
567 :
568 0 : (* i)->copyRowElement (sourceRow, destinationRow);
569 :
570 : }
571 :
572 0 : }
573 :
574 : void
575 0 : VisBufferImpl2::dirtyComponentsAdd (const VisBufferComponents2 & additionalDirtyComponents)
576 : {
577 : // Loop through all of the cached VB components and mark them dirty if
578 : // they're in the set <of addition dirty components
579 :
580 0 : for (CacheRegistry::iterator i = cache_p->registry_p.begin();
581 0 : i != cache_p->registry_p.end();
582 0 : i++){
583 :
584 0 : if (additionalDirtyComponents.contains ((* i)->getComponent())){
585 :
586 0 : (* i)->setDirty ();
587 : }
588 : }
589 0 : }
590 :
591 : void
592 0 : VisBufferImpl2::dirtyComponentsAdd (VisBufferComponent2 component)
593 : {
594 0 : dirtyComponentsAdd (VisBufferComponents2::singleton (component));
595 0 : }
596 :
597 :
598 : void
599 200599 : VisBufferImpl2::dirtyComponentsClear ()
600 : {
601 200599 : for (CacheRegistry::iterator i = cache_p->registry_p.begin();
602 11434143 : i != cache_p->registry_p.end();
603 11233544 : i++){
604 :
605 11233544 : (* i)->clearDirty ();
606 : }
607 200599 : }
608 :
609 : VisBufferComponents2
610 202975 : VisBufferImpl2::dirtyComponentsGet () const
611 : {
612 202975 : VisBufferComponents2 dirtyComponents;
613 :
614 202975 : for (CacheRegistry::iterator i = cache_p->registry_p.begin();
615 11569575 : i != cache_p->registry_p.end();
616 11366600 : i++){
617 :
618 11366600 : if ((*i)->isDirty ()){
619 :
620 556574 : VisBufferComponent2 component = (* i)->getComponent ();
621 :
622 556574 : if (component != VisBufferComponent2::Unknown){
623 1113148 : dirtyComponents = dirtyComponents +
624 1669722 : VisBufferComponents2::singleton (component);
625 : }
626 : }
627 : }
628 :
629 202975 : return dirtyComponents;
630 0 : }
631 :
632 : void
633 0 : VisBufferImpl2::dirtyComponentsSet (const VisBufferComponents2 & dirtyComponents)
634 : {
635 : // Clear the dirty state for the cache
636 :
637 0 : cacheClear ();
638 :
639 : // Add in the specified components to the newly cleared cache.
640 :
641 0 : dirtyComponentsAdd (dirtyComponents);
642 0 : }
643 :
644 : void
645 0 : VisBufferImpl2::dirtyComponentsSet (VisBufferComponent2 component)
646 : {
647 0 : dirtyComponentsSet (VisBufferComponents2::singleton (component));
648 0 : }
649 :
650 :
651 : Bool
652 36679278 : VisBufferImpl2::isAttached () const
653 : {
654 36679278 : return state_p->isAttached_p;
655 : }
656 :
657 : Bool
658 36621864 : VisBufferImpl2::isFillable () const
659 : {
660 36621864 : return state_p->isFillable_p;
661 : }
662 :
663 :
664 : Int
665 45062914 : VisBufferImpl2::msId () const
666 : {
667 45062914 : return state_p->msId_p;
668 : }
669 :
670 : String
671 159787 : VisBufferImpl2::msName (Bool stripPath) const
672 : {
673 159787 : String result;
674 :
675 159787 : if(stripPath){
676 :
677 73069 : Path path(state_p->msName_p);
678 73069 : result = path.baseName();
679 73069 : }
680 : else{
681 86718 : result = state_p->msName_p;
682 : }
683 :
684 159787 : return result;
685 0 : }
686 :
687 : Double
688 31414499 : VisBufferImpl2::getFrequency (Int rowInBuffer, Int frequencyIndex, Int frame) const
689 : {
690 31414499 : if (frame == FrameNotSpecified){
691 31414499 : frame = getViiP()->getReportingFrameOfReference();
692 : }
693 :
694 31414499 : state_p->frequencies_p.updateCacheIfNeeded (getViiP(), rowInBuffer, frame, this);
695 :
696 31414499 : return state_p->frequencies_p.values_p (frequencyIndex);
697 : }
698 :
699 : const Vector<Double> &
700 3290993 : VisBufferImpl2::getFrequencies (Int rowInBuffer, Int frame) const
701 : {
702 3290993 : if (frame == FrameNotSpecified){
703 2362432 : frame = getViiP()->getReportingFrameOfReference();
704 : }
705 :
706 3290993 : state_p->frequencies_p.updateCacheIfNeeded (getViiP(), rowInBuffer, frame, this);
707 :
708 3290993 : return state_p->frequencies_p.values_p;
709 : }
710 :
711 : Int
712 0 : VisBufferImpl2::getChannelNumber (Int rowInBuffer, Int frequencyIndex) const
713 : {
714 0 : state_p->channelNumbers_p.updateCacheIfNeeded (getViiP(), rowInBuffer, 0, this);
715 :
716 0 : return state_p->channelNumbers_p.values_p (frequencyIndex);
717 : }
718 :
719 : const Vector<Int> &
720 316494 : VisBufferImpl2::getChannelNumbers (Int rowInBuffer) const
721 : {
722 316494 : state_p->channelNumbers_p.updateCacheIfNeeded (getViiP(), rowInBuffer, 0, this);
723 :
724 316494 : return state_p->channelNumbers_p.values_p;
725 : }
726 :
727 0 : Vector<Int> VisBufferImpl2::getChannelNumbersSelected (Int outputChannelIndex) const
728 : {
729 0 : return Vector<Int>(1,outputChannelIndex);
730 : }
731 :
732 : Vector<Stokes::StokesTypes>
733 86718 : VisBufferImpl2::getCorrelationTypesDefined () const
734 : {
735 173436 : return state_p->correlationsDefined_p.copy();
736 : }
737 :
738 : Vector<Stokes::StokesTypes>
739 1408644 : VisBufferImpl2::getCorrelationTypesSelected () const
740 : {
741 2817288 : return state_p->correlationsSelected_p.copy();
742 : }
743 :
744 :
745 : Vector<Int>
746 86718 : VisBufferImpl2::getCorrelationTypes () const
747 : {
748 173436 : return state_p->correlations_p.copy();
749 : }
750 :
751 :
752 : String
753 0 : VisBufferImpl2::getFillErrorMessage () const
754 : {
755 0 : return "VisBuffer not positioned to a subchunk";
756 : }
757 :
758 :
759 : Subchunk
760 47196 : VisBufferImpl2::getSubchunk () const
761 : {
762 47196 : return state_p->subchunk_p;
763 : }
764 :
765 : IPosition
766 10391858 : VisBufferImpl2::getValidShape (Int i) const
767 : {
768 10391858 : ThrowIf (i < 0 || i >= (int) state_p->validShapes_p.nelements(),
769 : String::format ("Invalid shape requested: %d", i));
770 :
771 10391858 : return state_p->validShapes_p (i);
772 : }
773 :
774 : Vector<IPosition>
775 14691 : VisBufferImpl2::getValidVectorShapes (Int i) const
776 : {
777 14691 : ThrowIf (i < 0 || i >= (int) state_p->validVectorShapes_p.nelements(),
778 : String::format ("Invalid shape requested: %d", i));
779 :
780 14691 : return state_p->validVectorShapes_p (i);
781 : }
782 :
783 : ViImplementation2 *
784 169418380 : VisBufferImpl2::getViiP () const
785 : {
786 169418380 : ThrowIf (state_p->vi_p == nullptr, "Null pointer dereference!");
787 :
788 169418380 : return state_p->vi_p;
789 : }
790 :
791 : VisModelDataI *
792 0 : VisBufferImpl2::getVisModelData () const
793 : {
794 0 : return state_p->visModelData_p;
795 : }
796 :
797 : IPosition
798 2057188 : VisBufferImpl2::getShape () const
799 : {
800 2057188 : IPosition shape;
801 :
802 2057188 : if (hasShape()){
803 4114376 : shape = IPosition (3, cache_p->nCorrelations_p.get(), cache_p->nChannels_p.get(),
804 4114376 : cache_p->nRows_p.get());
805 : }
806 : else{
807 0 : shape = IPosition ();
808 : }
809 :
810 2057188 : return shape;
811 0 : }
812 :
813 :
814 : Bool
815 2220484 : VisBufferImpl2::hasShape () const
816 : {
817 2220484 : Bool hasShape = cache_p->nCorrelations_p.isPresent() && cache_p->nCorrelations_p.get() > 0;
818 2220484 : hasShape = hasShape && cache_p->nChannels_p.isPresent() && cache_p->nChannels_p.get() > 0;
819 2220484 : hasShape = hasShape && cache_p->nRows_p.isPresent() && cache_p->nRows_p.get() > 0;
820 :
821 2220484 : return hasShape;
822 : }
823 :
824 : void
825 245812 : VisBufferImpl2::invalidate ()
826 : {
827 245812 : cacheClear (false); // empty cached values
828 245812 : setFillable (false); // buffer is in limbo
829 245812 : }
830 :
831 : Bool
832 86718 : VisBufferImpl2::isNewArrayId () const
833 : {
834 86718 : return state_p->isNewArrayId_p;
835 : }
836 :
837 : Bool
838 99678 : VisBufferImpl2::isNewFieldId () const
839 : {
840 99678 : return state_p->isNewFieldId_p;
841 : }
842 :
843 : Bool
844 86718 : VisBufferImpl2::isNewMs() const
845 : {
846 86718 : return state_p->isNewMs_p;
847 : }
848 :
849 : Bool
850 86718 : VisBufferImpl2::isNewSpectralWindow () const
851 : {
852 86718 : return state_p->isNewSpectralWindow_p;
853 : }
854 :
855 : Bool
856 943921 : VisBufferImpl2::isRekeyable () const
857 : {
858 943921 : return state_p->isRekeyable_p;
859 : }
860 :
861 :
862 : Bool
863 8478771 : VisBufferImpl2::isWritable () const
864 : {
865 8478771 : return state_p->isWritable_p;
866 : }
867 :
868 : void
869 0 : VisBufferImpl2::normalize()
870 : {
871 : // NB: Handles pol-dep weights in chan-indep way
872 :
873 : // Check for missing data
874 :
875 0 : ThrowIf (! cache_p->visCube_p.isPresent(),
876 : "Cannot normalize; visCube is missing.");
877 0 : ThrowIf (! cache_p->modelVisCube_p.isPresent (),
878 : "Cannot normalize; modelVisCube is missing.");
879 0 : ThrowIf (! cache_p->weight_p.isPresent(),
880 : "Cannot normalize; weightMap is missing.");
881 :
882 : // Get references to the cached values to be used in the
883 : // normalization.
884 :
885 0 : Int nCorrelations = this->nCorrelations ();
886 :
887 0 : const Vector<Bool> & rowFlagged = cache_p->flagRow_p.get ();
888 0 : const Cube<Bool> & flagged = cache_p->flagCube_p.get ();
889 :
890 0 : Cube<Complex> & visCube = cache_p->visCube_p.getRef();
891 0 : Cube<Complex> & modelCube = cache_p->modelVisCube_p.getRef();
892 0 : Matrix<Float> & weight = cache_p->weight_p.getRef();
893 :
894 : // Normalize each row.
895 :
896 0 : for (rownr_t row = 0; row < nRows (); row++) {
897 :
898 0 : if (rowFlagged (row)){
899 :
900 0 : weight.column(row) = 0.0f; // Zero weight on this flagged row
901 0 : continue;
902 : }
903 :
904 0 : normalizeRow (row, nCorrelations, flagged, visCube,
905 : modelCube, weight);
906 :
907 : }
908 0 : }
909 :
910 : // Rotate visibility phase for given vector (dim = nrow of vb) of phases (metres)
911 : void
912 0 : VisBufferImpl2::phaseCenterShift(const Vector<Double>& phase)
913 : {
914 : // Use the frequencies corresponding to the SPW of the first row in the buffer
915 0 : Vector<Double> freq(getFrequencies(0));
916 :
917 : // Set vis cube references
918 0 : Cube<Complex> visCubeRef;
919 0 : Cube<Complex> visCubeModelRef;
920 0 : Cube<Complex> visCubeCorrectedRef;
921 0 : if (cache_p->visCube_p.isPresent())
922 : {
923 0 : visCubeRef.reference(visCube());
924 : }
925 0 : if (cache_p->modelVisCube_p.isPresent())
926 : {
927 0 : visCubeModelRef.reference(visCubeModel());
928 : }
929 0 : if (cache_p->correctedVisCube_p.isPresent())
930 : {
931 0 : visCubeCorrectedRef.reference(visCubeCorrected());
932 : }
933 :
934 :
935 0 : Complex cph;
936 : Double ph, udx;
937 0 : for (rownr_t row_idx = 0; row_idx < nRows(); ++row_idx)
938 : {
939 0 : udx = phase(row_idx) * -2.0 * C::pi / C::c; // in radian/Hz
940 :
941 0 : for (Int chan_idx = 0; chan_idx < nChannels(); ++chan_idx)
942 : {
943 : // Calculate the Complex factor for this row and channel
944 0 : ph = udx * freq(chan_idx);
945 :
946 0 : if (ph != 0.)
947 : {
948 0 : cph = Complex(cos(ph), sin(ph));
949 :
950 : // Shift each correlation:
951 0 : for (Int corr_idx = 0; corr_idx < nCorrelations(); ++corr_idx)
952 : {
953 0 : if (cache_p->visCube_p.isPresent())
954 : {
955 0 : visCubeRef(corr_idx, chan_idx, row_idx) *= cph;
956 : }
957 :
958 0 : if (cache_p->modelVisCube_p.isPresent())
959 : {
960 0 : visCubeModelRef(corr_idx, chan_idx, row_idx) *= cph;
961 : }
962 :
963 0 : if (cache_p->correctedVisCube_p.isPresent())
964 : {
965 0 : visCubeCorrectedRef(corr_idx, chan_idx, row_idx) *= cph;
966 : }
967 : }
968 : }
969 : }
970 : }
971 0 : }
972 :
973 : // Rotate visibility phase for phase center offsets
974 : void
975 0 : VisBufferImpl2::phaseCenterShift(Double dx, Double dy)
976 : {
977 : // Offsets in radians (input is arcsec)
978 0 : dx *= (C::pi / 180.0 / 3600.0);
979 0 : dy *= (C::pi / 180.0 / 3600.0);
980 :
981 : // Extra path as fraction of U and V
982 0 : Vector<Double> udx;
983 0 : udx = uvw().row(0);
984 0 : Vector<Double> vdy;
985 0 : vdy = uvw().row(1);
986 0 : udx *= dx; // in m
987 0 : vdy *= dy;
988 :
989 : // Combine axes
990 0 : udx += vdy;
991 :
992 0 : phaseCenterShift(udx);
993 0 : }
994 :
995 : void
996 0 : VisBufferImpl2::normalizeRow (Int row, Int nCorrelations, const Cube<Bool> & flagged,
997 : Cube<Complex> & visCube, Cube<Complex> & modelCube,
998 : Matrix<Float> & weightMat)
999 : {
1000 0 : Vector<Float> amplitudeSum = Vector<Float> (nCorrelations, 0.0f);
1001 0 : Vector<Int> count = Vector<Int> (nCorrelations, 0);
1002 :
1003 0 : for (Int channel = 0; channel < nChannels (); channel ++) {
1004 :
1005 0 : for (Int correlation = 0; correlation < nCorrelations; correlation ++) {
1006 :
1007 0 : if (flagged (correlation, channel, row)){
1008 0 : continue; // data is flagged so skip over it
1009 : }
1010 :
1011 : // If the model amplitude is zero, zero out the observed value.
1012 : // Otherwise divide the observed value by the model value and
1013 : // set the model value to 1.0.
1014 :
1015 0 : Float amplitude = abs (modelCube(correlation, channel, row));
1016 :
1017 0 : if (amplitude <= 0.0f) { // zero data if model is zero
1018 :
1019 0 : visCube (correlation, channel, row) = 0.0;
1020 0 : continue;
1021 : }
1022 :
1023 : // Normalize visibility datum by corresponding model data point.
1024 :
1025 0 : DComplex vis = visCube(correlation, channel, row);
1026 0 : DComplex mod = modelCube(correlation, channel, row);
1027 :
1028 0 : visCube (correlation, channel, row) = Complex (vis / mod);
1029 0 : modelCube (correlation, channel, row) = Complex(1.0);
1030 :
1031 : // Count and sum up the nonzero model amplitudes for this correlation.
1032 :
1033 0 : amplitudeSum (correlation) += amplitude;
1034 0 : count (correlation) ++;
1035 : }
1036 : }
1037 :
1038 : // Adjust the weight matrix entries for this row appropriately
1039 :
1040 0 : for (Int correlation = 0; correlation < nCorrelations; correlation++) {
1041 :
1042 0 : if (count (correlation) > 0) {
1043 :
1044 0 : weightMat (correlation, row) *= square (amplitudeSum (correlation) /
1045 0 : count (correlation));
1046 : }
1047 : else {
1048 :
1049 0 : weightMat (correlation, row) = 0.0f;
1050 : }
1051 : }
1052 0 : }
1053 :
1054 : void
1055 0 : VisBufferImpl2::registerCacheItem (VbCacheItemBase * item)
1056 : {
1057 0 : cache_p->registry_p.push_back (item);
1058 0 : }
1059 :
1060 : void
1061 465104 : VisBufferImpl2::resetWeightsUsingSigma ()
1062 : {
1063 :
1064 465104 : if (getViiP()->weightSpectrumExists()) { // Exists and contains actual values
1065 : // We are doing spectral weights
1066 :
1067 20965 : if (getViiP()->sigmaSpectrumExists()) {
1068 : // Init WS from SS for calibration
1069 19860 : Cube<Float> wtsp(nCorrelations(),nChannels(),nRows(),0.0);
1070 19860 : const Cube <Float> & sigmaSpec = this->sigmaSpectrum ();
1071 :
1072 154113 : for (rownr_t irow=0;irow<nRows();++irow) {
1073 5293872 : for (Int ichan=0;ichan<nChannels();++ichan) {
1074 18796617 : for (Int icorr=0;icorr<nCorrelations();++icorr) {
1075 13636998 : const Float &s=sigmaSpec(icorr,ichan,irow);
1076 13636998 : wtsp(icorr,ichan,irow) = (s>0.0 ? 1.0f/square(s) : 0.0);
1077 : }
1078 : }
1079 : }
1080 : // Set it in the VB
1081 19860 : setWeightSpectrum(wtsp);
1082 :
1083 19860 : }
1084 : else {
1085 : // Init WS from S, broadcast on chan axis
1086 1105 : Cube<Float> wtsp(nCorrelations(),nChannels(),nRows(),0.0);
1087 1105 : const Matrix <Float> & sigma = this->sigma ();
1088 :
1089 213921 : for (rownr_t irow=0;irow<nRows();++irow) {
1090 636243 : for (Int icorr=0;icorr<nCorrelations();++icorr) {
1091 423427 : const Float &s=sigma(icorr,irow);
1092 846854 : wtsp(Slice(icorr,1,1),Slice(),Slice(irow,1,1)) =
1093 1270281 : (s>0.0 ? 1.0f/square(s) : 0.0);
1094 : }
1095 : }
1096 : // Set it in the VB
1097 1105 : setWeightSpectrum(wtsp);
1098 1105 : }
1099 : }
1100 : else {
1101 : // Not using WS, fill W from S
1102 444139 : Matrix<Float> wtm(nCorrelations(),nRows(),0.0);
1103 444139 : const Matrix <Float> & sigma = this->sigma ();
1104 :
1105 18905087 : for (rownr_t irow=0;irow<nRows();++irow) {
1106 91452406 : for (Int icorr=0;icorr<nCorrelations();++icorr) {
1107 72991458 : const Float &s=sigma(icorr,irow);
1108 72991458 : wtm(icorr,irow) = (s>0.0 ? 1.0f/square(s) : 0.0);
1109 : }
1110 : }
1111 : // Set it in the VB
1112 444139 : setWeight(wtm);
1113 444139 : }
1114 :
1115 465104 : }
1116 :
1117 : void
1118 3743901 : VisBufferImpl2::setIterationInfo (Int msId,
1119 : const String & msName,
1120 : Bool isNewMs,
1121 : Bool isNewArrayId,
1122 : Bool isNewFieldId,
1123 : Bool isNewSpectralWindow,
1124 : const Subchunk & subchunk,
1125 : const Vector<Int> & correlations,
1126 : const Vector<Stokes::StokesTypes> & correlationsDefined,
1127 : const Vector<Stokes::StokesTypes> & correlationsSelected,
1128 : CountedPtr <WeightScaling> weightScaling)
1129 : {
1130 : // Set the iteration attributes into this VisBuffer
1131 :
1132 3743901 : state_p->msId_p = msId;
1133 3743901 : state_p->msName_p = msName;
1134 3743901 : state_p->isNewMs_p = isNewMs;
1135 3743901 : state_p->isNewMs_p = isNewMs;
1136 3743901 : state_p->isNewArrayId_p = isNewArrayId;
1137 3743901 : state_p->isNewFieldId_p = isNewFieldId;
1138 3743901 : state_p->isNewSpectralWindow_p = isNewSpectralWindow;
1139 3743901 : state_p->subchunk_p = subchunk;
1140 3743901 : state_p->correlations_p.assign (correlations);
1141 3743901 : state_p->correlationsDefined_p.assign (correlationsDefined);
1142 3743901 : state_p->correlationsSelected_p.assign (correlationsSelected);
1143 3743901 : state_p->weightScaling_p = weightScaling;
1144 3743901 : }
1145 :
1146 : void
1147 4049738 : VisBufferImpl2::setFillable (Bool isFillable)
1148 : {
1149 4049738 : state_p->isFillable_p = isFillable;
1150 4049738 : }
1151 :
1152 :
1153 :
1154 : void
1155 3657183 : VisBufferImpl2::configureNewSubchunk (Int msId,
1156 : const String & msName,
1157 : Bool isNewMs,
1158 : Bool isNewArrayId,
1159 : Bool isNewFieldId,
1160 : Bool isNewSpectralWindow,
1161 : const Subchunk & subchunk,
1162 : const casacore::Vector<casacore::rownr_t>& nRowsPerShape,
1163 : const casacore::Vector<casacore::Int>& nChannelsPerShape,
1164 : const casacore::Vector<casacore::Int>& nCorrelationsPerShape,
1165 : const Vector<Int> & correlations,
1166 : const Vector<Stokes::StokesTypes> & correlationsDefined,
1167 : const Vector<Stokes::StokesTypes> & correlationsSelected,
1168 : CountedPtr<WeightScaling> weightScaling)
1169 : {
1170 : // Prepare this VisBuffer for the new subchunk
1171 :
1172 3657183 : cacheClear();
1173 :
1174 3657183 : setIterationInfo (msId, msName, isNewMs, isNewArrayId, isNewFieldId,
1175 : isNewSpectralWindow, subchunk, correlations,
1176 : correlationsDefined, correlationsSelected, weightScaling);
1177 :
1178 3657183 : setFillable (true); // New subchunk, so it's fillable
1179 :
1180 3657183 : state_p->frequencies_p.flush();
1181 3657183 : state_p->channelNumbers_p.flush();
1182 :
1183 : // Initialize the API methods that do not support several shapes with the first shape
1184 : // Clients which use this "old" API should work as expected as long as there is one
1185 : // single shape in the VisBuffer.
1186 3657183 : cache_p->nRows_p.setSpecial (std::accumulate(nRowsPerShape.begin(), nRowsPerShape.end(), 0));
1187 3657183 : cache_p->nChannels_p.setSpecial (nChannelsPerShape[0]);
1188 3657183 : cache_p->nCorrelations_p.setSpecial (nCorrelationsPerShape[0]);
1189 :
1190 3657183 : cache_p->nShapes_p.setSpecial (nRowsPerShape.size());
1191 3657183 : cache_p->nRowsPerShape_p.setSpecial (nRowsPerShape);
1192 3657183 : cache_p->nChannelsPerShape_p.setSpecial (nChannelsPerShape);
1193 3657183 : cache_p->nCorrelationsPerShape_p.setSpecial (nCorrelationsPerShape);
1194 :
1195 3657183 : setupValidShapes ();
1196 3657183 : }
1197 :
1198 : void
1199 39522 : VisBufferImpl2::setRekeyable (Bool isRekeyable)
1200 : {
1201 39522 : state_p->isRekeyable_p = isRekeyable;
1202 39522 : }
1203 :
1204 : void
1205 116100 : VisBufferImpl2::setShape (Int nCorrelations, Int nChannels, rownr_t nRows,
1206 : Bool clearTheCache)
1207 : {
1208 116100 : ThrowIf (hasShape() && ! isRekeyable(),
1209 : "Operation setShape is illegal on nonrekeyable VisBuffer");
1210 :
1211 116100 : if (clearTheCache){
1212 76578 : cacheClear (false); // leave values alone so that array could be reused
1213 : }
1214 :
1215 116100 : cache_p->nCorrelations_p.setSpecial(nCorrelations);
1216 116100 : cache_p->nChannels_p.setSpecial(nChannels);
1217 116100 : cache_p->nRows_p.setSpecial(nRows);
1218 :
1219 116100 : Vector<rownr_t> nRowsPerShape(1);
1220 116100 : Vector<Int> nChannelsPerShape(1);
1221 116100 : Vector<Int> nCorrelationsPerShape(1);
1222 116100 : nRowsPerShape[0] = nRows;
1223 116100 : nChannelsPerShape[0] = nChannels;
1224 116100 : nCorrelationsPerShape[0] = nCorrelations;
1225 :
1226 116100 : cache_p->nShapes_p.setSpecial (1);
1227 116100 : cache_p->nRowsPerShape_p.setSpecial (nRowsPerShape);
1228 116100 : cache_p->nChannelsPerShape_p.setSpecial (nChannelsPerShape);
1229 116100 : cache_p->nCorrelationsPerShape_p.setSpecial (nCorrelationsPerShape);
1230 :
1231 116100 : setupValidShapes ();
1232 116100 : }
1233 :
1234 : void
1235 3773283 : VisBufferImpl2::setupValidShapes ()
1236 : {
1237 3773283 : state_p->validShapes_p [Nr] = IPosition (1, nRows());
1238 3773283 : state_p->validShapes_p [NfNr] = IPosition (2, nChannels(), nRows());
1239 3773283 : state_p->validShapes_p [NcNr] = IPosition (2, nCorrelations(), nRows());
1240 3773283 : state_p->validShapes_p [NcNfNr] = IPosition (3, nCorrelations(), nChannels(), nRows());
1241 3773283 : state_p->validShapes_p [I3Nr] = IPosition (2, 3, nRows());
1242 : //state_p->validShapes [NcNfNcatNr] = IPosition (4, nCorrelations(), nChannels(), nCategories(), nRows());
1243 : // flag_category is not used in CASA, so no need to implement checking.
1244 :
1245 3773283 : state_p->validVectorShapes_p [Ns] = IPosition (1, nShapes());
1246 3773283 : state_p->validVectorShapes_p [NsNcNr].resize(nShapes());
1247 3773283 : state_p->validVectorShapes_p [NsNcNfNr].resize(nShapes());
1248 8405782 : for(size_t iShape = 0; iShape < nShapes(); iShape++)
1249 : {
1250 4632499 : state_p->validVectorShapes_p [NsNcNr][iShape] = IPosition (2, nCorrelationsPerShape()[iShape], nRowsPerShape()[iShape]);
1251 4632499 : state_p->validVectorShapes_p [NsNcNfNr][iShape] = IPosition (3, nCorrelationsPerShape()[iShape], nChannelsPerShape()[iShape], nRowsPerShape()[iShape]);
1252 : }
1253 3773283 : }
1254 :
1255 : bool
1256 526516 : VisBufferImpl2::setWritability (Bool newWritability)
1257 : {
1258 526516 : bool oldWritability = state_p->isWritable_p;
1259 526516 : state_p->isWritable_p = newWritability;
1260 526516 : return oldWritability;
1261 : }
1262 :
1263 :
1264 :
1265 : // Sort correlations: (PP,QQ,PQ,QP) -> (PP,PQ,QP,QQ)
1266 : void
1267 0 : VisBufferImpl2::sortCorrelationsAux (bool makeSorted)
1268 : {
1269 :
1270 : // This method is for temporarily sorting the correlations
1271 : // into canonical order if the MS data is out-of-order
1272 : // NB: Always sorts the weightMat()
1273 : // NB: Only works on the visCube-style data
1274 : // NB: It only sorts the data columns which are already present
1275 : // (so make sure the ones you need are already read!)
1276 : // NB: It is the user's responsibility to run unSortCorr
1277 : // after using the sorted data to put it back in order
1278 : // NB: corrType_p is NOT changed to match the sorted
1279 : // correlations (it is expected that this sort is
1280 : // temporary, and that we will run unSortCorr
1281 : // NB: This method does nothing if no sort required
1282 :
1283 : // Sort if nominal order is non-canonical (only for nCorr=4).
1284 : // Also do not sort or unsort if that is the current sort state.
1285 :
1286 0 : if (! areCorrelationsInCanonicalOrder() &&
1287 0 : (state_p->areCorrelationsSorted_p != makeSorted)) {
1288 :
1289 : // First sort the weights
1290 :
1291 0 : weight(); // (ensures it is filled)
1292 :
1293 0 : Vector<Float> wtmp(nRows ());
1294 0 : Vector<Float> w1, w2, w3;
1295 0 : IPosition wblc (1, 0, 0);
1296 0 : IPosition wtrc (2, 0, nRows () - 1);
1297 0 : IPosition vec (1, nRows ());
1298 :
1299 0 : VisBufferCache::sortCorrelationItem (cache_p->weight_p, wblc, wtrc, vec, wtmp, makeSorted);
1300 :
1301 : // Now sort the complex data cubes
1302 :
1303 0 : Matrix<Complex> tmp(nChannels (), nRows ());
1304 0 : Matrix<Complex> p1, p2, p3;
1305 0 : IPosition blc(3, 0, 0, 0);
1306 0 : IPosition trc(3, 0, nChannels () - 1, nRows () - 1);
1307 0 : IPosition mat(2, nChannels (), nRows ());
1308 :
1309 : // Sort the various visCubes, if present
1310 :
1311 0 : VisBufferCache::sortCorrelationItem (cache_p->visCube_p, blc, trc, mat, tmp, makeSorted);
1312 :
1313 0 : VisBufferCache::sortCorrelationItem (cache_p->modelVisCube_p, blc, trc, mat, tmp, makeSorted);
1314 :
1315 0 : VisBufferCache::sortCorrelationItem (cache_p->correctedVisCube_p, blc, trc, mat, tmp, makeSorted);
1316 :
1317 : // Finally sort the float data cube
1318 :
1319 0 : Matrix<Float> tmp2 (nChannels (), nRows ());
1320 :
1321 0 : VisBufferCache::sortCorrelationItem (cache_p->floatDataCube_p, blc, trc, mat, tmp2, makeSorted);
1322 :
1323 : // Record the sort state
1324 :
1325 0 : state_p->areCorrelationsSorted_p = makeSorted;
1326 0 : }
1327 :
1328 0 : }
1329 :
1330 : // Sort correlations: (PP,QQ,PQ,QP) -> (PP,PQ,QP,QQ)
1331 : void
1332 0 : VisBufferImpl2::sortCorr()
1333 : {
1334 0 : sortCorrelationsAux (true);
1335 0 : }
1336 :
1337 :
1338 : void
1339 0 : VisBufferImpl2::stateCopy (const VisBufferImpl2 & other)
1340 : {
1341 : // Copy state from the other buffer
1342 :
1343 0 : state_p->areCorrelationsSorted_p = other.areCorrelationsSorted ();
1344 0 : state_p->dirtyComponents_p = other.dirtyComponentsGet ();
1345 0 : state_p->isAttached_p = false; // attachment isn't copyabled
1346 0 : state_p->isNewArrayId_p = other.isNewArrayId ();
1347 0 : state_p->isNewFieldId_p = other.isNewFieldId ();
1348 0 : state_p->isNewMs_p = other.isNewMs ();
1349 0 : state_p->isNewSpectralWindow_p = other.isNewSpectralWindow ();
1350 0 : state_p->pointingTableLastRow_p = -1; // This will slow pointing table lookup
1351 : // but probably not important in cases
1352 : // where a vb is being copied (?).
1353 0 : state_p->newMs_p = other.isNewMs ();
1354 0 : state_p->vi_p = 0; // just to be safe
1355 0 : state_p->visModelData_p = other.getVisModelData ()->clone();
1356 0 : }
1357 :
1358 :
1359 : // Unsort correlations: (PP,PQ,QP,QQ) -> (PP,QQ,PQ,QP)
1360 : void
1361 0 : VisBufferImpl2::unSortCorr()
1362 : {
1363 0 : sortCorrelationsAux (false);
1364 0 : }
1365 :
1366 : void
1367 0 : VisBufferImpl2::validate ()
1368 : {
1369 0 : cacheClear (true); // empty values but mark as cached.
1370 0 : }
1371 :
1372 : void
1373 3499 : VisBufferImpl2::validateShapes () const
1374 : {
1375 : // Check that all of the modified array columns have the proper shape.
1376 : // Throw an exception if any columns have improper shape. This is
1377 : // intended to be a last chance sanity-check before the data is written to disk
1378 : // or made available for use.
1379 :
1380 3499 : String message;
1381 :
1382 3499 : for (CacheRegistry::iterator i = cache_p->registry_p.begin();
1383 199443 : i != cache_p->registry_p.end();
1384 195944 : i++){
1385 :
1386 195944 : if ((*i)->isDirty() && ! (*i)->isShapeOk ()){
1387 :
1388 0 : message += (*i)->shapeErrorMessage () + "\n";
1389 : }
1390 : }
1391 :
1392 3499 : ThrowIf (! message.empty(), message);
1393 3499 : }
1394 :
1395 : void
1396 202975 : VisBufferImpl2::writeChangesBack ()
1397 : {
1398 202975 : ThrowIf (! state_p->isAttached_p,
1399 : "Call to writeChangesBack on unattached VisBuffer.");
1400 :
1401 202975 : ViImplementation2 * rwvi = dynamic_cast <ViImplementation2 *> (getViiP());
1402 :
1403 202975 : ThrowIf (rwvi == 0, "Can't write to a read-only VisibilityIterator.");
1404 :
1405 202975 : if (isRekeyable()){
1406 :
1407 3499 : validateShapes ();
1408 : }
1409 :
1410 202975 : rwvi->writeBackChanges (this);
1411 202975 : }
1412 :
1413 : void
1414 2094 : VisBufferImpl2::initWeightSpectrum(const Cube<Float>& wtspec)
1415 : {
1416 2094 : ThrowIf (! state_p->isAttached_p,
1417 : "Call to writeChangesBack on unattached VisBuffer.");
1418 :
1419 2094 : ViImplementation2 * rwvi = dynamic_cast <ViImplementation2 *> (getViiP());
1420 :
1421 2094 : ThrowIf (rwvi == 0, "Can't write to a read-only VisibilityIterator.");
1422 :
1423 : // TBD: Should verify that shape is correct!
1424 :
1425 2094 : rwvi->initWeightSpectrum(wtspec);
1426 2094 : }
1427 :
1428 : void
1429 1556 : VisBufferImpl2::initSigmaSpectrum(const Cube<Float>& wtspec)
1430 : {
1431 1556 : ThrowIf (! state_p->isAttached_p,
1432 : "Call to writeChangesBack on unattached VisBuffer.");
1433 :
1434 1556 : ViImplementation2 * rwvi = dynamic_cast <ViImplementation2 *> (getViiP());
1435 :
1436 1556 : ThrowIf (rwvi == 0, "Can't write to a read-only VisibilityIterator.");
1437 :
1438 : // TBD: Should verify that shape is correct!
1439 :
1440 1556 : rwvi->initSigmaSpectrum(wtspec);
1441 1556 : }
1442 :
1443 :
1444 : const casacore::MeasurementSet&
1445 313415 : VisBufferImpl2::ms() const {
1446 313415 : return getViiP()->ms();
1447 : }
1448 :
1449 : const vi::SubtableColumns&
1450 2875192 : VisBufferImpl2::subtableColumns () const {
1451 2875192 : return getViiP()->subtableColumns();
1452 : }
1453 :
1454 : casacore::Bool
1455 951582 : VisBufferImpl2::existsColumn(VisBufferComponent2 id) const {
1456 951582 : return getViiP()->existsColumn(id);
1457 : }
1458 :
1459 : // +---------------+
1460 : // | |
1461 : // | Calculators |
1462 : // | |
1463 : // +---------------+
1464 :
1465 :
1466 : MDirection
1467 0 : VisBufferImpl2::azel0(Double time) const
1468 : {
1469 0 : return getViiP()->azel0(time);
1470 : }
1471 :
1472 : const Vector<MDirection> &
1473 159282 : VisBufferImpl2::azel(Double time) const
1474 : {
1475 159282 : return getViiP()->azel(time);
1476 : }
1477 :
1478 : const Vector<Float> &
1479 7425625 : VisBufferImpl2::feedPa(Double time) const
1480 : {
1481 7425625 : return getViiP()->feed_pa(time);
1482 : }
1483 :
1484 : Double
1485 0 : VisBufferImpl2::hourang(Double time) const
1486 : {
1487 0 : return getViiP()->hourang(time);
1488 : }
1489 :
1490 : Float
1491 0 : VisBufferImpl2::parang0(Double time) const
1492 : {
1493 0 : return getViiP()->parang0(time);
1494 : }
1495 :
1496 : const Vector<Float> &
1497 0 : VisBufferImpl2::parang(Double time) const
1498 : {
1499 0 : return getViiP()->parang(time);
1500 : }
1501 :
1502 : // +-------------+
1503 : // | |
1504 : // | Accessors |
1505 : // | |
1506 : // +-------------+
1507 :
1508 : const Vector<Int> &
1509 317290271 : VisBufferImpl2::antenna1 () const
1510 : {
1511 317290271 : return cache_p->antenna1_p.get ();
1512 : }
1513 :
1514 : void
1515 0 : VisBufferImpl2::setAntenna1 (const Vector<Int> & value)
1516 : {
1517 0 : cache_p->antenna1_p.set (value);
1518 0 : }
1519 :
1520 : const Vector<Int> &
1521 316836775 : VisBufferImpl2::antenna2 () const
1522 : {
1523 316836775 : return cache_p->antenna2_p.get ();
1524 : }
1525 :
1526 : void
1527 0 : VisBufferImpl2::setAntenna2 (const Vector<Int> & value)
1528 : {
1529 0 : cache_p->antenna2_p.set (value);
1530 0 : }
1531 :
1532 : const Vector<Int> &
1533 2021866 : VisBufferImpl2::arrayId () const
1534 : {
1535 2021866 : return cache_p->arrayId_p.get ();
1536 : }
1537 :
1538 : void
1539 0 : VisBufferImpl2::setArrayId (const Vector<Int> &value)
1540 : {
1541 0 : cache_p->arrayId_p.set (value);
1542 0 : }
1543 :
1544 : const Vector<SquareMatrix<Complex, 2> > &
1545 0 : VisBufferImpl2::cjones () const
1546 : {
1547 0 : return cache_p->cjones_p.get ();
1548 : }
1549 :
1550 : const Vector<Int> &
1551 1022064 : VisBufferImpl2::correlationTypes () const
1552 : {
1553 1022064 : return cache_p->corrType_p.get ();
1554 : }
1555 :
1556 : //Int
1557 : //VisBufferImpl2::dataDescriptionId () const
1558 : //{
1559 : // return cache_p->dataDescriptionId_p.get ();
1560 : //}
1561 :
1562 : const Vector<Int> &
1563 1618959 : VisBufferImpl2::dataDescriptionIds () const
1564 : {
1565 1618959 : return cache_p->dataDescriptionIds_p.get ();
1566 : }
1567 :
1568 : //void
1569 : //VisBufferImpl2::setDataDescriptionId (Int value)
1570 : //{
1571 : // cache_p->dataDescriptionId_p.set (value);
1572 : //}
1573 :
1574 : void
1575 0 : VisBufferImpl2::setDataDescriptionIds (const Vector<Int> & value)
1576 : {
1577 0 : cache_p->dataDescriptionIds_p.set (value);
1578 0 : }
1579 :
1580 :
1581 : const Vector<MDirection> &
1582 16410 : VisBufferImpl2::direction1 () const
1583 : {
1584 16410 : return cache_p->direction1_p.get ();
1585 : }
1586 :
1587 : const Vector<MDirection> &
1588 13448 : VisBufferImpl2::direction2 () const
1589 : {
1590 13448 : return cache_p->direction2_p.get ();
1591 : }
1592 :
1593 : const Vector<Double> &
1594 22760895 : VisBufferImpl2::exposure () const
1595 : {
1596 22760895 : return cache_p->exposure_p.get ();
1597 : }
1598 :
1599 : void
1600 0 : VisBufferImpl2::setExposure (const Vector<Double> & value)
1601 : {
1602 0 : cache_p->exposure_p.set (value);
1603 0 : }
1604 :
1605 : const Vector<Int> &
1606 1512118 : VisBufferImpl2::feed1 () const
1607 : {
1608 1512118 : return cache_p->feed1_p.get ();
1609 : }
1610 :
1611 : void
1612 0 : VisBufferImpl2::setFeed1 (const Vector<Int> & value)
1613 : {
1614 0 : cache_p->feed1_p.set (value);
1615 0 : }
1616 :
1617 : const Vector<Float> &
1618 21837 : VisBufferImpl2::feedPa1 () const
1619 : {
1620 21837 : return cache_p->feed1Pa_p.get ();
1621 : }
1622 :
1623 : const Vector<Int> &
1624 1341212 : VisBufferImpl2::feed2 () const
1625 : {
1626 1341212 : return cache_p->feed2_p.get ();
1627 : }
1628 :
1629 : void
1630 0 : VisBufferImpl2::setFeed2 (const Vector<Int> & value)
1631 : {
1632 0 : cache_p->feed2_p.set (value);
1633 0 : }
1634 :
1635 : const Vector<Float> &
1636 19531 : VisBufferImpl2::feedPa2 () const
1637 : {
1638 19531 : return cache_p->feed2Pa_p.get ();
1639 : }
1640 :
1641 : const Vector<Int> &
1642 6772624 : VisBufferImpl2::fieldId () const
1643 : {
1644 6772624 : return cache_p->fieldId_p.get ();
1645 : }
1646 :
1647 : void
1648 0 : VisBufferImpl2::setFieldId (const Vector<Int> & value)
1649 : {
1650 0 : cache_p->fieldId_p.set (value);
1651 0 : }
1652 :
1653 : //const Matrix<Bool> &
1654 : //VisBufferImpl2::flag () const
1655 : //{
1656 : // return cache_p->flag_p.get ();
1657 : //}
1658 :
1659 : //void
1660 : //VisBufferImpl2::setFlag (const Matrix<Bool>& value)
1661 : //{
1662 : // cache_p->flag_p.set (value);
1663 : //}
1664 :
1665 : const Array<Bool> &
1666 0 : VisBufferImpl2::flagCategory () const
1667 : {
1668 0 : return cache_p->flagCategory_p.get();
1669 : }
1670 :
1671 : void
1672 0 : VisBufferImpl2::setFlagCategory (const Array<Bool>& value)
1673 : {
1674 0 : cache_p->flagCategory_p.set (value);
1675 0 : }
1676 :
1677 : const casacore::Vector<casacore::Array<casacore::Bool>> &
1678 0 : VisBufferImpl2::flagCategories () const
1679 : {
1680 0 : return cache_p->flagCategories_p.get();
1681 : }
1682 :
1683 : void
1684 0 : VisBufferImpl2::setFlagCategories (const casacore::Vector<casacore::Array<casacore::Bool>>& value)
1685 : {
1686 0 : cache_p->flagCategories_p.set (value);
1687 0 : }
1688 :
1689 : const Cube<Bool> &
1690 39291797 : VisBufferImpl2::flagCube () const
1691 : {
1692 39291797 : return cache_p->flagCube_p.get ();
1693 : }
1694 :
1695 : const Vector<Cube<Bool>> &
1696 0 : VisBufferImpl2::flagCubes () const
1697 : {
1698 0 : return cache_p->flagCubes_p.get ();
1699 : }
1700 :
1701 : Cube<Bool> &
1702 0 : VisBufferImpl2::flagCubeRef ()
1703 : {
1704 0 : return cache_p->flagCube_p.getRef ();
1705 : }
1706 :
1707 : Vector<Cube<Bool>> &
1708 0 : VisBufferImpl2::flagCubesRef ()
1709 : {
1710 0 : return cache_p->flagCubes_p.getRef ();
1711 : }
1712 :
1713 : void
1714 386749 : VisBufferImpl2::setFlagCube (const Cube<Bool>& value)
1715 : {
1716 386749 : cache_p->flagCube_p.set (value);
1717 386749 : }
1718 :
1719 : void
1720 0 : VisBufferImpl2::setFlagCubes (const Vector<Cube<Bool>>& value)
1721 : {
1722 0 : cache_p->flagCubes_p.set (value);
1723 0 : }
1724 :
1725 : const Vector<Bool> &
1726 72538583 : VisBufferImpl2::flagRow () const
1727 : {
1728 72538583 : return cache_p->flagRow_p.get ();
1729 : }
1730 :
1731 : Vector<Bool> &
1732 0 : VisBufferImpl2::flagRowRef ()
1733 : {
1734 0 : return cache_p->flagRow_p.getRef ();
1735 : }
1736 :
1737 : void
1738 3499 : VisBufferImpl2::setFlagRow (const Vector<Bool>& value)
1739 : {
1740 3499 : cache_p->flagRow_p.set (value);
1741 3499 : }
1742 :
1743 : const Matrix<Float> &
1744 970222 : VisBufferImpl2::imagingWeight () const
1745 : {
1746 970222 : return cache_p->imagingWeight_p.get ();
1747 : }
1748 :
1749 : void
1750 186990 : VisBufferImpl2::setImagingWeight (const Matrix<Float> & newImagingWeight)
1751 : {
1752 186990 : cache_p->imagingWeight_p.set (newImagingWeight);
1753 186990 : }
1754 :
1755 :
1756 : //const Vector<Double> &
1757 : //VisBufferImpl2::lsrFrequency () const
1758 : //{
1759 : // return cache_p->lsrFrequency_p.get ();
1760 : //}
1761 :
1762 : Int
1763 103026 : VisBufferImpl2::nAntennas () const
1764 : {
1765 103026 : return cache_p->nAntennas_p.get ();
1766 : }
1767 :
1768 : Int
1769 414902715 : VisBufferImpl2::nChannels () const
1770 : {
1771 414902715 : return cache_p->nChannels_p.get ();
1772 : }
1773 :
1774 : Int
1775 604759327 : VisBufferImpl2::nCorrelations () const
1776 : {
1777 604759327 : return cache_p->nCorrelations_p.get();
1778 : }
1779 :
1780 : rownr_t
1781 450482172 : VisBufferImpl2::nRows () const
1782 : {
1783 450482172 : return cache_p->nRows_p.get ();
1784 : }
1785 :
1786 : rownr_t
1787 19725631 : VisBufferImpl2::nShapes () const
1788 : {
1789 19725631 : return cache_p->nShapes_p.get ();
1790 : }
1791 :
1792 : const Vector<rownr_t>&
1793 9264998 : VisBufferImpl2::nRowsPerShape () const
1794 : {
1795 9264998 : return cache_p->nRowsPerShape_p.get ();
1796 : }
1797 :
1798 : const Vector<Int> &
1799 4632499 : VisBufferImpl2::nChannelsPerShape () const
1800 : {
1801 4632499 : return cache_p->nChannelsPerShape_p.get ();
1802 : }
1803 :
1804 : const Vector<Int> &
1805 9264998 : VisBufferImpl2::nCorrelationsPerShape () const
1806 : {
1807 9264998 : return cache_p->nCorrelationsPerShape_p.get ();
1808 : }
1809 :
1810 : const Vector<Int> &
1811 2515638 : VisBufferImpl2::observationId () const
1812 : {
1813 2515638 : return cache_p->observationId_p.get ();
1814 : }
1815 :
1816 : void
1817 0 : VisBufferImpl2::setObservationId (const Vector<Int> & value)
1818 : {
1819 0 : cache_p->observationId_p.set (value);
1820 0 : }
1821 :
1822 : const MDirection&
1823 53876 : VisBufferImpl2::phaseCenter () const
1824 : {
1825 53876 : return cache_p->phaseCenter_p.get ();
1826 : }
1827 :
1828 : Int
1829 211079 : VisBufferImpl2::polarizationFrame () const
1830 : {
1831 211079 : return cache_p->polFrame_p.get ();
1832 : }
1833 :
1834 : Int
1835 61805 : VisBufferImpl2::polarizationId () const
1836 : {
1837 61805 : return cache_p->polarizationId_p.get ();
1838 : }
1839 :
1840 : const Vector<Int> &
1841 1313069 : VisBufferImpl2::processorId () const
1842 : {
1843 1313069 : return cache_p->processorId_p.get ();
1844 : }
1845 :
1846 : void
1847 0 : VisBufferImpl2::setProcessorId (const Vector<Int> & value)
1848 : {
1849 0 : cache_p->processorId_p.set (value);
1850 0 : }
1851 :
1852 : const Vector<rownr_t> &
1853 513087 : VisBufferImpl2::rowIds () const
1854 : {
1855 513087 : return cache_p->rowIds_p.get ();
1856 : }
1857 :
1858 : const Vector<Int> &
1859 7337407 : VisBufferImpl2::scan () const
1860 : {
1861 7337407 : return cache_p->scan_p.get ();
1862 : }
1863 :
1864 : void
1865 0 : VisBufferImpl2::setScan (const Vector<Int> & value)
1866 : {
1867 0 : cache_p->scan_p.set (value);
1868 0 : }
1869 :
1870 : const Matrix<Float> &
1871 26787009 : VisBufferImpl2::sigma () const
1872 : {
1873 26787009 : return cache_p->sigma_p.get ();
1874 : }
1875 :
1876 : const Vector<Matrix<Float>> &
1877 0 : VisBufferImpl2::sigmas () const
1878 : {
1879 0 : return cache_p->sigmas_p.get ();
1880 : }
1881 :
1882 : void
1883 5950 : VisBufferImpl2::setSigma (const Matrix<Float> & sigmas)
1884 : {
1885 5950 : cache_p->sigma_p.set (sigmas);
1886 5950 : }
1887 :
1888 : void
1889 0 : VisBufferImpl2::setSigmas (const Vector<Matrix<Float>> & sigmas)
1890 : {
1891 0 : cache_p->sigmas_p.set (sigmas);
1892 0 : }
1893 :
1894 : //const Matrix<Float> &
1895 : //VisBufferImpl2::sigmaMat () const
1896 : //{
1897 : // return cache_p->sigmaMat_p.get ();
1898 : //}
1899 :
1900 : const Vector<Int> &
1901 54592344 : VisBufferImpl2::spectralWindows () const
1902 : {
1903 54592344 : return cache_p->spectralWindows_p.get ();
1904 : }
1905 :
1906 : void
1907 0 : VisBufferImpl2::setSpectralWindows (const Vector<Int> & spectralWindows)
1908 : {
1909 0 : cache_p->spectralWindows_p.set (spectralWindows);
1910 0 : }
1911 :
1912 :
1913 : const Vector<Int> &
1914 1962877 : VisBufferImpl2::stateId () const
1915 : {
1916 1962877 : return cache_p->stateId_p.get ();
1917 : }
1918 :
1919 : void
1920 0 : VisBufferImpl2::setStateId (const Vector<Int> & value)
1921 : {
1922 0 : cache_p->stateId_p.set (value);
1923 0 : }
1924 :
1925 : const Vector<Double> &
1926 158197020 : VisBufferImpl2::time () const
1927 : {
1928 158197020 : return cache_p->time_p.get ();
1929 : }
1930 :
1931 : void
1932 0 : VisBufferImpl2::setTime (const Vector<Double> & value)
1933 : {
1934 0 : cache_p->time_p.set (value);
1935 0 : }
1936 :
1937 : const Vector<Double> &
1938 24482175 : VisBufferImpl2::timeCentroid () const
1939 : {
1940 24482175 : return cache_p->timeCentroid_p.get ();
1941 : }
1942 :
1943 : void
1944 0 : VisBufferImpl2::setTimeCentroid (const Vector<Double> & value)
1945 : {
1946 0 : cache_p->timeCentroid_p.set (value);
1947 0 : }
1948 :
1949 : const Vector<Double> &
1950 12906462 : VisBufferImpl2::timeInterval () const
1951 : {
1952 12906462 : return cache_p->timeInterval_p.get ();
1953 : }
1954 :
1955 : void
1956 0 : VisBufferImpl2::setTimeInterval (const Vector<Double> & value)
1957 : {
1958 0 : cache_p->timeInterval_p.set (value);
1959 0 : }
1960 :
1961 : const Matrix<Double> &
1962 805074162 : VisBufferImpl2::uvw () const
1963 : {
1964 805074162 : return cache_p->uvw_p.get ();
1965 : }
1966 :
1967 : void
1968 0 : VisBufferImpl2::setUvw (const Matrix<Double> & value)
1969 : {
1970 0 : cache_p->uvw_p.set (value);
1971 0 : }
1972 :
1973 : const Cube<Complex> &
1974 24510084 : VisBufferImpl2::visCubeCorrected () const
1975 : {
1976 24510084 : return cache_p->correctedVisCube_p.get ();
1977 : }
1978 :
1979 : Cube<Complex> &
1980 0 : VisBufferImpl2::visCubeCorrectedRef ()
1981 : {
1982 0 : return cache_p->correctedVisCube_p.getRef ();
1983 : }
1984 :
1985 : void
1986 727699 : VisBufferImpl2::setVisCubeCorrected (const Cube<Complex> & value)
1987 : {
1988 727699 : cache_p->correctedVisCube_p.set (value);
1989 727699 : }
1990 :
1991 : const Vector<Cube<Complex>> &
1992 0 : VisBufferImpl2::visCubesCorrected () const
1993 : {
1994 0 : return cache_p->correctedVisCubes_p.get ();
1995 : }
1996 :
1997 : Vector<Cube<Complex>> &
1998 0 : VisBufferImpl2::visCubesCorrectedRef ()
1999 : {
2000 0 : return cache_p->correctedVisCubes_p.getRef ();
2001 : }
2002 :
2003 : void
2004 0 : VisBufferImpl2::setVisCubesCorrected (const Vector<Cube<Complex>> & value)
2005 : {
2006 0 : cache_p->correctedVisCubes_p.set (value);
2007 0 : }
2008 :
2009 : //const Matrix<CStokesVector> &
2010 : //VisBufferImpl2::visCorrected () const
2011 : //{
2012 : // return cache_p->correctedVisibility_p.get ();
2013 : //}
2014 :
2015 : //void
2016 : //VisBufferImpl2::setVisCorrected (const Matrix<CStokesVector> & value)
2017 : //{
2018 : // cache_p->correctedVisibility_p.set (value);
2019 : //}
2020 :
2021 : const Cube<Float> &
2022 209677 : VisBufferImpl2::visCubeFloat () const
2023 : {
2024 209677 : return cache_p->floatDataCube_p.get ();
2025 : }
2026 :
2027 : void
2028 0 : VisBufferImpl2::setVisCubeFloat (const Cube<Float> & value)
2029 : {
2030 0 : cache_p->floatDataCube_p.set (value);
2031 0 : }
2032 :
2033 : const Vector<Cube<Float>> &
2034 0 : VisBufferImpl2::visCubesFloat () const
2035 : {
2036 0 : return cache_p->floatDataCubes_p.get ();
2037 : }
2038 :
2039 : void
2040 0 : VisBufferImpl2::setVisCubesFloat (const Vector<Cube<Float>> & value)
2041 : {
2042 0 : cache_p->floatDataCubes_p.set (value);
2043 0 : }
2044 :
2045 : const Cube<Complex> &
2046 24679013 : VisBufferImpl2::visCubeModel () const
2047 : {
2048 24679013 : return cache_p->modelVisCube_p.get ();
2049 : }
2050 :
2051 : Cube<Complex> &
2052 0 : VisBufferImpl2::visCubeModelRef ()
2053 : {
2054 0 : return cache_p->modelVisCube_p.getRef ();
2055 : }
2056 :
2057 : void
2058 294815 : VisBufferImpl2::setVisCubeModel (const Complex & value)
2059 : {
2060 294815 : cache_p->modelVisCube_p.set (value);
2061 294815 : }
2062 :
2063 : void
2064 1006231 : VisBufferImpl2::setVisCubeModel (const Cube<Complex> & value)
2065 : {
2066 1006231 : cache_p->modelVisCube_p.set (value);
2067 1006231 : }
2068 :
2069 : const Vector<Cube<Complex>> &
2070 0 : VisBufferImpl2::visCubesModel () const
2071 : {
2072 0 : return cache_p->modelVisCubes_p.get ();
2073 : }
2074 :
2075 : Vector<Cube<Complex>> &
2076 0 : VisBufferImpl2::visCubesModelRef ()
2077 : {
2078 0 : return cache_p->modelVisCubes_p.getRef ();
2079 : }
2080 :
2081 : void
2082 0 : VisBufferImpl2::setVisCubesModel (const Vector<Cube<Complex>> & value)
2083 : {
2084 0 : cache_p->modelVisCubes_p.set (value);
2085 0 : }
2086 :
2087 : //void
2088 : //VisBufferImpl2::setVisCubesModel (const Complex & value)
2089 : //{
2090 : // cache_p->modelVisCubes_p.set (value);
2091 : //}
2092 :
2093 : ms::MsRow *
2094 592578 : VisBufferImpl2::getRow (Int row) const
2095 : {
2096 592578 : ms::MsRow * msRow = new ms::Vbi2MsRow (row, this);
2097 :
2098 592578 : return msRow;
2099 : }
2100 :
2101 : ms::MsRow *
2102 0 : VisBufferImpl2::getRowMutable (Int row)
2103 : {
2104 0 : ms::MsRow * msRow = new ms::Vbi2MsRow (row, this);
2105 :
2106 0 : return msRow;
2107 : }
2108 :
2109 :
2110 : //const Matrix<CStokesVector> &
2111 : //VisBufferImpl2::visModel () const
2112 : //{
2113 : // return cache_p->modelVisibility_p.get ();
2114 : //}
2115 :
2116 : //void
2117 : //VisBufferImpl2::setVisModel (Matrix<CStokesVector> & value)
2118 : //{
2119 : // cache_p->modelVisibility_p.set (value);
2120 : //}
2121 :
2122 : void
2123 91785 : VisBufferImpl2::setVisCubeModel(const Vector<Float>& stokesIn)
2124 : {
2125 :
2126 : enum {I, Q, U, V};
2127 :
2128 91785 : Vector<Float> stokes (4, 0.0);
2129 :
2130 91785 : stokes [I] = 1.0; // Stokes parameters, nominally unpolarized, unit I
2131 :
2132 458925 : for (uInt i = 0; i < stokesIn.nelements(); ++i){
2133 367140 : stokes [i] = stokesIn [i];
2134 : }
2135 :
2136 : // Convert to correlations, according to basis
2137 91785 : Vector<Complex> stokesFinal (4, Complex(0.0)); // initially all zero
2138 :
2139 91785 : if (polarizationFrame() == MSIter::Circular){
2140 17052 : stokesFinal(0) = Complex(stokes [I] + stokes [V]);
2141 17052 : stokesFinal(1) = Complex(stokes [Q], stokes [U]);
2142 17052 : stokesFinal(2) = Complex(stokes [Q], -stokes [U]);
2143 17052 : stokesFinal(3) = Complex(stokes [I] - stokes [V]);
2144 : }
2145 74733 : else if (polarizationFrame() == MSIter::Linear) {
2146 74733 : stokesFinal(0) = Complex(stokes [I] + stokes [Q]);
2147 74733 : stokesFinal(1) = Complex(stokes [U], stokes [V]);
2148 74733 : stokesFinal(2) = Complex(stokes [U], -stokes [V]);
2149 74733 : stokesFinal(3) = Complex(stokes [I] - stokes [Q]);
2150 : }
2151 : else {
2152 0 : throw(AipsError("Model-setting only works for CIRCULAR and LINEAR bases, for now."));
2153 : }
2154 :
2155 : // A map onto the actual correlations in the VisBuffer (which may be a subset)
2156 91785 : Vector<Int> corrmap;
2157 91785 : corrmap.assign(correlationTypes()); // actual copy, to avoid changing correlationTypes()!
2158 91785 : corrmap -= corrmap(0);
2159 :
2160 91785 : ThrowIf (max(corrmap) >= 4, "HELP! The correlations in the data are not normal!");
2161 :
2162 : // Set the modelVisCube accordingly
2163 91785 : Cube<Complex> visCube (getViiP()->visibilityShape(), 0.0);
2164 :
2165 458925 : for (Int icorr = 0; icorr < nCorrelations (); ++icorr){
2166 367140 : if (abs(stokesFinal(corrmap(icorr))) > 0.0) {
2167 217442 : visCube (Slice (icorr, 1, 1), Slice(), Slice()).set(stokesFinal (corrmap (icorr)));
2168 : }
2169 : }
2170 :
2171 91785 : cache_p->modelVisCube_p.set (visCube);
2172 :
2173 91785 : }
2174 :
2175 :
2176 : const Cube<Complex> &
2177 3811570 : VisBufferImpl2::visCube () const
2178 : {
2179 3811570 : return cache_p->visCube_p.get ();
2180 : }
2181 :
2182 : Cube<Complex> &
2183 0 : VisBufferImpl2::visCubeRef ()
2184 : {
2185 0 : return cache_p->visCube_p.getRef ();
2186 : }
2187 :
2188 : void
2189 864 : VisBufferImpl2::setVisCube (const Complex & value)
2190 : {
2191 864 : cache_p->visCube_p.set (value);
2192 864 : }
2193 :
2194 : void
2195 68180 : VisBufferImpl2::setVisCube (const Cube<Complex> & value)
2196 : {
2197 68180 : cache_p->visCube_p.set (value);
2198 68180 : }
2199 :
2200 : const Vector<Cube<Complex>> &
2201 0 : VisBufferImpl2::visCubes () const
2202 : {
2203 0 : return cache_p->visCubes_p.get ();
2204 : }
2205 :
2206 : Vector<Cube<Complex>> &
2207 0 : VisBufferImpl2::visCubesRef ()
2208 : {
2209 0 : return cache_p->visCubes_p.getRef ();
2210 : }
2211 :
2212 : //void
2213 : //VisBufferImpl2::setVisCubes (const Complex & value)
2214 : //{
2215 : // cache_p->visCube_p.set (value);
2216 : //}
2217 :
2218 : void
2219 0 : VisBufferImpl2::setVisCubes (const Vector<Cube<Complex>> & value)
2220 : {
2221 0 : cache_p->visCubes_p.set (value);
2222 0 : }
2223 :
2224 : //const Matrix<CStokesVector> &
2225 : //VisBufferImpl2::vis () const
2226 : //{
2227 : // return cache_p->visibility_p.get ();
2228 : //}
2229 :
2230 : //void
2231 : //VisBufferImpl2::setVis (Matrix<CStokesVector> & value)
2232 : //{
2233 : // cache_p->visibility_p.set (value);
2234 : //}
2235 :
2236 : const Matrix<Float> &
2237 63122268 : VisBufferImpl2::weight () const
2238 : {
2239 63122268 : return cache_p->weight_p.get ();
2240 : }
2241 :
2242 : void
2243 880637 : VisBufferImpl2::setWeight (const Matrix<Float>& value)
2244 : {
2245 880637 : cache_p->weight_p.set (value);
2246 880637 : }
2247 :
2248 : const Vector<Matrix<Float>> &
2249 0 : VisBufferImpl2::weights () const
2250 : {
2251 0 : return cache_p->weights_p.get ();
2252 : }
2253 :
2254 : void
2255 0 : VisBufferImpl2::setWeights (const Vector<Matrix<Float>>& value)
2256 : {
2257 0 : cache_p->weights_p.set (value);
2258 0 : }
2259 :
2260 : //const Matrix<Float> &
2261 : //VisBufferImpl2::weightMat () const
2262 : //{
2263 : // return cache_p->weightMat_p.get ();
2264 : //}
2265 :
2266 : //void
2267 : //VisBufferImpl2::setWeightMat (const Matrix<Float>& value)
2268 : //{
2269 : // cache_p->weightMat_p.set (value);
2270 : //}
2271 :
2272 : const Cube<Float> &
2273 27790926 : VisBufferImpl2::weightSpectrum () const
2274 : {
2275 27790926 : return cache_p->weightSpectrum_p.get ();
2276 : }
2277 :
2278 : Cube<Float> &
2279 0 : VisBufferImpl2::weightSpectrumRef ()
2280 : {
2281 0 : return cache_p->weightSpectrum_p.getRef();
2282 : }
2283 :
2284 :
2285 : void
2286 268237 : VisBufferImpl2::setWeightSpectrum (const Cube<Float>& value)
2287 : {
2288 268237 : cache_p->weightSpectrum_p.set (value);
2289 268237 : }
2290 :
2291 : const Vector<Cube<Float>> &
2292 0 : VisBufferImpl2::weightSpectra () const
2293 : {
2294 0 : return cache_p->weightSpectra_p.get ();
2295 : }
2296 :
2297 : Vector<Cube<Float>> &
2298 0 : VisBufferImpl2::weightSpectraRef ()
2299 : {
2300 0 : return cache_p->weightSpectra_p.getRef();
2301 : }
2302 :
2303 : void
2304 0 : VisBufferImpl2::setWeightSpectra (const Vector<Cube<Float>>& value)
2305 : {
2306 0 : cache_p->weightSpectra_p.set (value);
2307 0 : }
2308 :
2309 : const Cube<Float> &
2310 13834995 : VisBufferImpl2::sigmaSpectrum () const
2311 : {
2312 13834995 : return cache_p->sigmaSpectrum_p.get ();
2313 : }
2314 :
2315 : Cube<Float> &
2316 0 : VisBufferImpl2::sigmaSpectrumRef ()
2317 : {
2318 0 : return cache_p->sigmaSpectrum_p.getRef();
2319 : }
2320 :
2321 : void
2322 672 : VisBufferImpl2::setSigmaSpectrum (const Cube<Float>& value)
2323 : {
2324 672 : cache_p->sigmaSpectrum_p.set (value);
2325 672 : }
2326 :
2327 : const Vector<Cube<Float>> &
2328 0 : VisBufferImpl2::sigmaSpectra () const
2329 : {
2330 0 : return cache_p->sigmaSpectra_p.get ();
2331 : }
2332 :
2333 : Vector<Cube<Float>> &
2334 0 : VisBufferImpl2::sigmaSpectraRef ()
2335 : {
2336 0 : return cache_p->sigmaSpectra_p.getRef();
2337 : }
2338 :
2339 : void
2340 0 : VisBufferImpl2::setSigmaSpectra (const Vector<Cube<Float>>& value)
2341 : {
2342 0 : cache_p->sigmaSpectra_p.set (value);
2343 0 : }
2344 :
2345 :
2346 :
2347 : // +-----------+
2348 : // | |
2349 : // | Fillers |
2350 : // | |
2351 : // +-----------+
2352 :
2353 :
2354 : void
2355 2223324 : VisBufferImpl2::fillAntenna1 (Vector<Int>& value) const
2356 : {
2357 2223324 : CheckVisIter ();
2358 :
2359 2223324 : getViiP()->antenna1 (value);
2360 2223324 : }
2361 :
2362 :
2363 : void
2364 1873988 : VisBufferImpl2::fillAntenna2 (Vector<Int>& value) const
2365 : {
2366 1873988 : CheckVisIter ();
2367 :
2368 1873988 : getViiP()->antenna2 (value);
2369 1873988 : }
2370 :
2371 : void
2372 979987 : VisBufferImpl2::fillArrayId (Vector<Int>& value) const
2373 : {
2374 979987 : CheckVisIter ();
2375 :
2376 979987 : getViiP()->arrayIds (value);
2377 979987 : }
2378 :
2379 : void
2380 749146 : VisBufferImpl2::fillCorrType (Vector<Int>& value) const
2381 : {
2382 749146 : CheckVisIter ();
2383 :
2384 749146 : getViiP()->corrType (value);
2385 749146 : }
2386 :
2387 : void
2388 906516 : VisBufferImpl2::fillCubeCorrected (Cube <Complex> & value) const
2389 : {
2390 906516 : CheckVisIter ();
2391 :
2392 906516 : getViiP()->visibilityCorrected (value);
2393 906516 : }
2394 :
2395 : void
2396 0 : VisBufferImpl2::fillCubesCorrected (Vector<Cube<Complex>> & value) const
2397 : {
2398 0 : CheckVisIter ();
2399 :
2400 0 : getViiP()->visibilityCorrected (value);
2401 0 : }
2402 :
2403 : void
2404 921279 : VisBufferImpl2::fillCubeModel (Cube <Complex> & value) const
2405 : {
2406 921279 : CheckVisIter ();
2407 :
2408 921279 : getViiP()->visibilityModel(value);
2409 921279 : }
2410 :
2411 : void
2412 0 : VisBufferImpl2::fillCubesModel (Vector<Cube <Complex>> & value) const
2413 : {
2414 0 : CheckVisIter ();
2415 :
2416 0 : getViiP()->visibilityModel(value);
2417 0 : }
2418 :
2419 : void
2420 1229023 : VisBufferImpl2::fillCubeObserved (Cube <Complex> & value) const
2421 : {
2422 1229023 : CheckVisIter ();
2423 :
2424 1229023 : getViiP()->visibilityObserved (value);
2425 1229023 : }
2426 :
2427 : void
2428 0 : VisBufferImpl2::fillCubesObserved (Vector<Cube <Complex>> & value) const
2429 : {
2430 0 : CheckVisIter ();
2431 :
2432 0 : getViiP()->visibilityObserved (value);
2433 0 : }
2434 :
2435 : void
2436 0 : VisBufferImpl2::fillDataDescriptionId (Int& value) const
2437 : {
2438 0 : CheckVisIter ();
2439 :
2440 0 : value = getViiP()->dataDescriptionId ();
2441 0 : }
2442 :
2443 : void
2444 389327 : VisBufferImpl2::fillDataDescriptionIds (Vector<Int>& value) const
2445 : {
2446 389327 : CheckVisIter ();
2447 :
2448 389327 : getViiP()->dataDescriptionIds (value);
2449 389327 : }
2450 :
2451 :
2452 : void
2453 10761 : VisBufferImpl2::fillDirection1 (Vector<MDirection>& value) const
2454 : {
2455 10761 : CheckVisIterBase ();
2456 : // fill state_p->feed1_pa cache, antenna, feed and time will be filled automatically
2457 :
2458 10761 : feedPa1 ();
2459 :
2460 10761 : fillDirectionAux (value, antenna1 (), feed1 (), feedPa1 ());
2461 :
2462 10761 : value.resize(nRows());
2463 10761 : }
2464 :
2465 : void
2466 9608 : VisBufferImpl2::fillDirection2 (Vector<MDirection>& value) const
2467 : {
2468 9608 : CheckVisIterBase ();
2469 : // fill state_p->feed1_pa cache, antenna, feed and time will be filled automatically
2470 :
2471 9608 : feedPa2 ();
2472 :
2473 9608 : fillDirectionAux (value, antenna2 (), feed2 (), feedPa2 ());
2474 :
2475 9608 : value.resize(nRows());
2476 9608 : }
2477 :
2478 : void
2479 20369 : VisBufferImpl2::fillDirectionAux (Vector<MDirection>& value,
2480 : const Vector<Int> & antenna,
2481 : const Vector<Int> &feed,
2482 : const Vector<Float> & feedPa) const
2483 : {
2484 20369 : value.resize (nRows());
2485 :
2486 : // const MSPointingColumns & mspc = getViiP()->subtableColumns ().pointing();
2487 : // state_p->pointingTableLastRow_p = mspc.pointingIndex (antenna (0),
2488 : // time()(0), state_p->pointingTableLastRow_p);
2489 :
2490 20369 : if (getViiP()->allBeamOffsetsZero() && state_p->pointingTableLastRow_p < 0) {
2491 :
2492 : // No true pointing information found; use phase center from the field table
2493 :
2494 50 : value.set(phaseCenter());
2495 50 : state_p->pointingTableLastRow_p = 0;
2496 50 : return;
2497 : }
2498 :
2499 :
2500 7143578 : for (uInt row = 0; row < antenna.nelements(); ++row) {
2501 :
2502 7123259 : DebugAssert(antenna (row) >= 0 && feed (row) >= 0, AipsError);
2503 :
2504 : bool ok;
2505 7123259 : std::tie (ok, value (row)) = getViiP()->getPointingAngle (antenna (row), time() (row));
2506 :
2507 7123259 : if (! ok) {
2508 :
2509 0 : value(row) = phaseCenter(); // nothing found, use phase center
2510 : }
2511 :
2512 7123259 : if (!getViiP()->allBeamOffsetsZero()) {
2513 :
2514 0 : RigidVector<Double, 2> beamOffset = getViiP()->getBeamOffsets()(0, antenna (row),
2515 0 : feed (row));
2516 :
2517 0 : if (downcase (getViiP()->antennaMounts()(antenna (row))) == "alt-az") {
2518 :
2519 0 : SquareMatrix<Double, 2> xform(SquareMatrix<Double, 2>::General);
2520 :
2521 0 : Double cpa = cos(feedPa(row));
2522 0 : Double spa = sin(feedPa(row));
2523 :
2524 0 : xform(0, 0) = cpa;
2525 0 : xform(1, 1) = cpa;
2526 0 : xform(0, 1) = -spa;
2527 0 : xform(1, 0) = spa;
2528 :
2529 0 : beamOffset *= xform; // parallactic angle rotation
2530 0 : }
2531 :
2532 0 : value(row).shift(-beamOffset(0), beamOffset(1), true);
2533 : // x direction is flipped to convert az-el type frame to ra-dec
2534 : }
2535 : }
2536 : }
2537 :
2538 : void
2539 904383 : VisBufferImpl2::fillExposure (Vector<Double>& value) const
2540 : {
2541 904383 : CheckVisIter ();
2542 :
2543 904383 : getViiP()->exposure (value);
2544 904383 : }
2545 :
2546 : void
2547 519013 : VisBufferImpl2::fillFeed1 (Vector<Int>& value) const
2548 : {
2549 519013 : CheckVisIter ();
2550 :
2551 519013 : getViiP()->feed1 (value);
2552 519013 : }
2553 :
2554 : void
2555 353892 : VisBufferImpl2::fillFeed2 (Vector<Int>& value) const
2556 : {
2557 353892 : CheckVisIter ();
2558 :
2559 353892 : getViiP()->feed2 (value);
2560 353892 : }
2561 :
2562 : void
2563 10876 : VisBufferImpl2::fillFeedPa1 (Vector <Float> & feedPa) const
2564 : {
2565 10876 : CheckVisIterBase ();
2566 :
2567 : // fill feed, antenna and time caches, if not filled before
2568 :
2569 10876 : feed1 ();
2570 10876 : antenna1 ();
2571 10876 : time ();
2572 :
2573 10876 : feedPa.resize(nRows());
2574 :
2575 10876 : fillFeedPaAux (feedPa, antenna1 (), feed1 ());
2576 10876 : }
2577 :
2578 :
2579 : void
2580 9767 : VisBufferImpl2::fillFeedPa2 (Vector <Float> & feedPa) const
2581 : {
2582 9767 : CheckVisIterBase ();
2583 :
2584 : // Fill feed, antenna and time caches, if not filled before.
2585 :
2586 9767 : feed2();
2587 9767 : antenna2();
2588 9767 : time();
2589 :
2590 9767 : feedPa.resize(nRows());
2591 :
2592 9767 : fillFeedPaAux (feedPa, antenna2(), feed2 ());
2593 9767 : }
2594 :
2595 : void
2596 20643 : VisBufferImpl2::fillFeedPaAux (Vector <Float> & feedPa,
2597 : const Vector <Int> & antenna,
2598 : const Vector <Int> & feed) const
2599 : {
2600 7219408 : for (uInt row = 0; row < feedPa.nelements(); ++row) {
2601 :
2602 7198765 : const Vector<Float>& antennaPointingAngle = this->feedPa (time ()(row));
2603 :
2604 7198765 : Assert(antenna (row) >= 0 && antenna (row) < (int) antennaPointingAngle.nelements());
2605 :
2606 7198765 : feedPa (row) = antennaPointingAngle (antenna (row));
2607 :
2608 7198765 : if (feed (row) != 0){ // Skip when feed(row) is zero
2609 :
2610 : // feedPa returns only the first feed position angle so
2611 : // we need to add an offset if this row correspods to a
2612 : // different feed
2613 :
2614 0 : float feedsAngle = getViiP()->receptorAngles()(0, antenna (row), feed (row));
2615 0 : float feed0Angle = getViiP()->receptorAngles()(0, antenna (row), 0);
2616 :
2617 0 : feedPa (row) += feedsAngle - feed0Angle;
2618 : }
2619 : }
2620 20643 : }
2621 :
2622 : void
2623 2517351 : VisBufferImpl2::fillFieldId (Vector<Int>& value) const
2624 : {
2625 2517351 : CheckVisIter ();
2626 :
2627 2517351 : getViiP()->fieldIds (value);
2628 2517351 : }
2629 :
2630 : void
2631 0 : VisBufferImpl2::fillFlag (Matrix<Bool>& value) const
2632 : {
2633 0 : CheckVisIter ();
2634 :
2635 0 : getViiP()->flag (value);
2636 0 : }
2637 :
2638 : void
2639 0 : VisBufferImpl2::fillFlagCategory (Array<Bool>& value) const
2640 : {
2641 0 : CheckVisIter();
2642 :
2643 0 : getViiP()->flagCategory (value);
2644 0 : }
2645 :
2646 : void
2647 3092361 : VisBufferImpl2::fillFlagCube (Cube<Bool>& value) const
2648 : {
2649 3092361 : CheckVisIter ();
2650 :
2651 3092361 : getViiP()->flag (value);
2652 3092361 : }
2653 :
2654 : void
2655 0 : VisBufferImpl2::fillFlagCubes (Vector<Cube<Bool>>& value) const
2656 : {
2657 0 : CheckVisIter ();
2658 :
2659 0 : getViiP()->flag (value);
2660 0 : }
2661 :
2662 : void
2663 2095933 : VisBufferImpl2::fillFlagRow (Vector<Bool>& value) const
2664 : {
2665 2095933 : CheckVisIter ();
2666 :
2667 2095933 : getViiP()->flagRow (value);
2668 2095933 : }
2669 :
2670 : void
2671 114085 : VisBufferImpl2::fillFloatData (Cube<Float>& value) const
2672 : {
2673 114085 : CheckVisIter ();
2674 :
2675 114085 : getViiP()->floatData (value);
2676 114085 : }
2677 :
2678 : void
2679 0 : VisBufferImpl2::fillFloatCubes (Vector<Cube<Float>>& value) const
2680 : {
2681 0 : CheckVisIter ();
2682 :
2683 0 : getViiP()->floatData (value);
2684 0 : }
2685 :
2686 : void
2687 481892 : VisBufferImpl2::fillImagingWeight (Matrix<Float> & value) const
2688 : {
2689 481892 : const VisImagingWeight & weightGenerator = getViiP()->getImagingWeightGenerator ();
2690 :
2691 481892 : ThrowIf (weightGenerator.getType () == "none",
2692 : "Bug check: Imaging weight generator not set");
2693 :
2694 : //#warning "Rework logic so that called code is not expecting a flag matrix."
2695 :
2696 481892 : value.resize (IPosition (2, nChannels(), nRows()));
2697 :
2698 481892 : Matrix<Bool> flagMat;
2699 481892 : flagMat.assign(flagCube().yzPlane(0));
2700 : std::logical_and<Bool> andOp;
2701 :
2702 : /*
2703 : Vector<Float> wts (nRows (), 0);
2704 : wts = weight().row(0);
2705 : wts += weight().row(nCorrelations() - 1);
2706 : wts *= 0.5f;
2707 : */
2708 :
2709 : // Extract weights correctly
2710 481892 : Matrix<Float> wtm; // [nchan,nrow]
2711 481892 : Cube<Float> wtc; // [ncorr,nchan,nrow]
2712 481892 : if (getViiP()->weightSpectrumExists())
2713 891 : wtc.reference(weightSpectrum());
2714 : else
2715 481001 : wtc.reference(weight().reform(IPosition(3,nCorrelations(),1,nRows())));
2716 :
2717 : // Collapse on correlation axis
2718 481892 : weightGenerator.unPolChanWeight(wtm,wtc);
2719 :
2720 :
2721 972752 : for (Int i = 1; i < nCorrelations(); ++ i){
2722 :
2723 490860 : Matrix<Bool> flagPlane = flagCube().yzPlane(i);
2724 490860 : arrayTransform<Bool,Bool,Bool,std::logical_and<Bool> > (flagMat, flagPlane, flagMat, andOp);
2725 490860 : }
2726 :
2727 481892 : if (weightGenerator.getType () == "uniform") {
2728 :
2729 17348 : weightGenerator.weightUniform (value, flagMat, uvw (), getFrequencies (0), wtm, msId (), fieldId ()(0));
2730 :
2731 464544 : } else if (weightGenerator.getType () == "radial") {
2732 :
2733 1440 : weightGenerator.weightRadial (value, flagMat, uvw (), getFrequencies (0), wtm);
2734 :
2735 : } else {
2736 :
2737 463104 : weightGenerator.weightNatural (value, flagMat, wtm);
2738 : }
2739 :
2740 481892 : if (weightGenerator.doFilter ()) {
2741 :
2742 7200 : weightGenerator.filter (value, flagMat, uvw (), getFrequencies (0), wtm);
2743 : }
2744 481892 : }
2745 :
2746 : void
2747 0 : VisBufferImpl2::fillJonesC (Vector<SquareMatrix<Complex, 2> >& value) const
2748 : {
2749 0 : CheckVisIter ();
2750 :
2751 0 : getViiP()->jonesC (value);
2752 0 : }
2753 :
2754 : void
2755 59350 : VisBufferImpl2::fillNAntennas (Int & value) const
2756 : {
2757 59350 : CheckVisIter ();
2758 :
2759 59350 : value = getViiP()->nAntennas();
2760 59350 : }
2761 :
2762 : void
2763 0 : VisBufferImpl2::fillNChannel (Int &) const
2764 : {
2765 0 : CheckVisIter ();
2766 :
2767 : // This value enters the VB from a route that doesn't involve
2768 : // filling; however the framework requires that this method exist
2769 : // so it's implemented as a no-op.
2770 0 : }
2771 :
2772 : void
2773 0 : VisBufferImpl2::fillNCorr (Int &) const
2774 : {
2775 0 : CheckVisIter ();
2776 :
2777 : // This value enters the VB from a route that doesn't involve
2778 : // filling; however the framework requires that this method exist
2779 : // so it's implemented as a no-op.
2780 0 : }
2781 :
2782 : void
2783 0 : VisBufferImpl2::fillNRow (Int&) const
2784 : {
2785 0 : CheckVisIter ();
2786 :
2787 : // This value enters the VB from a route that doesn't involve
2788 : // filling; however the framework requires that this method exist
2789 : // so it's implemented as a no-op.
2790 0 : }
2791 :
2792 : void
2793 0 : VisBufferImpl2::fillNShapes (Int&) const
2794 : {
2795 0 : CheckVisIter ();
2796 :
2797 : // This value enters the VB from a route that doesn't involve
2798 : // filling; however the framework requires that this method exist
2799 : // so it's implemented as a no-op.
2800 0 : }
2801 :
2802 : void
2803 0 : VisBufferImpl2::fillNRowPerShape (Vector<rownr_t> &) const
2804 : {
2805 0 : CheckVisIter ();
2806 :
2807 : // This value enters the VB from a route that doesn't involve
2808 : // filling; however the framework requires that this method exist
2809 : // so it's implemented as a no-op.
2810 0 : }
2811 :
2812 : void
2813 0 : VisBufferImpl2::fillNChannelPerShape (Vector<Int> &) const
2814 : {
2815 0 : CheckVisIter ();
2816 :
2817 : // This value enters the VB from a route that doesn't involve
2818 : // filling; however the framework requires that this method exist
2819 : // so it's implemented as a no-op.
2820 0 : }
2821 :
2822 : void
2823 0 : VisBufferImpl2::fillNCorrPerShape (Vector<Int> &) const
2824 : {
2825 0 : CheckVisIter ();
2826 :
2827 : // This value enters the VB from a route that doesn't involve
2828 : // filling; however the framework requires that this method exist
2829 : // so it's implemented as a no-op.
2830 0 : }
2831 :
2832 : void
2833 1351570 : VisBufferImpl2::fillObservationId (Vector<Int>& value) const
2834 : {
2835 1351570 : CheckVisIter();
2836 :
2837 1351570 : getViiP()->observationId (value);
2838 1351570 : }
2839 :
2840 : void
2841 9051 : VisBufferImpl2::fillPhaseCenter (MDirection& value) const
2842 : {
2843 9051 : CheckVisIter ();
2844 :
2845 9051 : value = getViiP()->phaseCenter ();
2846 9051 : }
2847 :
2848 : void
2849 95006 : VisBufferImpl2::fillPolFrame (Int& value) const
2850 : {
2851 95006 : CheckVisIter ();
2852 :
2853 95006 : value = getViiP()->polFrame ();
2854 95006 : }
2855 :
2856 : void
2857 14544 : VisBufferImpl2::fillPolarizationId (Int& value) const
2858 : {
2859 14544 : CheckVisIter ();
2860 :
2861 14544 : value = getViiP()->polarizationId ();
2862 14544 : }
2863 :
2864 : void
2865 339152 : VisBufferImpl2::fillProcessorId (Vector<Int>& value) const
2866 : {
2867 339152 : CheckVisIter();
2868 :
2869 339152 : getViiP()->processorId (value);
2870 339152 : }
2871 :
2872 : void
2873 22651 : VisBufferImpl2::fillRowIds (Vector<rownr_t>& value) const
2874 : {
2875 22651 : CheckVisIter ();
2876 :
2877 22651 : getViiP()->getRowIds(value);
2878 22651 : }
2879 :
2880 :
2881 : void
2882 1567842 : VisBufferImpl2::fillScan (Vector<Int>& value) const
2883 : {
2884 1567842 : CheckVisIter ();
2885 :
2886 1567842 : getViiP()->scan (value);
2887 1567842 : }
2888 :
2889 : void
2890 1436072 : VisBufferImpl2::fillSigma (Matrix<Float>& value) const
2891 : {
2892 1436072 : CheckVisIter ();
2893 1436072 : getViiP()->sigma (value);
2894 1436072 : }
2895 :
2896 : void
2897 0 : VisBufferImpl2::fillSigmas (Vector<Matrix<Float>>& value) const
2898 : {
2899 0 : CheckVisIter ();
2900 :
2901 0 : getViiP()->sigma (value);
2902 0 : }
2903 :
2904 : //void
2905 : //VisBufferImpl2::fillSigmaMat (Matrix<Float>& value) const
2906 : //{
2907 : // CheckVisIter ();
2908 : //
2909 : // getViiP()->sigmaMat (value);
2910 : //}
2911 :
2912 : void
2913 2770790 : VisBufferImpl2::fillSpectralWindows (Vector<Int>& value) const
2914 : {
2915 2770790 : CheckVisIter ();
2916 :
2917 2770790 : getViiP()->spectralWindows (value);
2918 2770790 : }
2919 :
2920 : void
2921 805831 : VisBufferImpl2::fillStateId (Vector<Int>& value) const
2922 : {
2923 805831 : CheckVisIter();
2924 :
2925 805831 : getViiP()->stateId (value);
2926 805831 : }
2927 :
2928 :
2929 : void
2930 2161410 : VisBufferImpl2::fillTime (Vector<Double>& value) const
2931 : {
2932 2161410 : CheckVisIter ();
2933 :
2934 2161410 : getViiP()->time (value);
2935 2161410 : }
2936 :
2937 : void
2938 936167 : VisBufferImpl2::fillTimeCentroid (Vector<Double>& value) const
2939 : {
2940 936167 : CheckVisIter ();
2941 :
2942 936167 : getViiP()->timeCentroid (value);
2943 936167 : }
2944 :
2945 : void
2946 1083927 : VisBufferImpl2::fillTimeInterval (Vector<Double>& value) const
2947 : {
2948 1083927 : CheckVisIter ();
2949 :
2950 1083927 : getViiP()->timeInterval (value);
2951 1083927 : }
2952 :
2953 : void
2954 1420230 : VisBufferImpl2::fillUvw (Matrix<Double>& value) const
2955 : {
2956 1420230 : CheckVisIter ();
2957 :
2958 1420230 : getViiP()->uvw (value);
2959 1420230 : }
2960 :
2961 : //void
2962 : //VisBufferImpl2::fillVisibilityCorrected (Matrix<CStokesVector>& value) const
2963 : //{
2964 : // CheckVisIter ();
2965 : //
2966 : // getViiP()->visibilityCorrected (value);
2967 : //}
2968 :
2969 : //void
2970 : //VisBufferImpl2::fillVisibilityModel (Matrix<CStokesVector>& value) const
2971 : //{
2972 : // CheckVisIter ();
2973 : //
2974 : // getViiP()->visibilityModel (value);
2975 : //}
2976 :
2977 : //void
2978 : //VisBufferImpl2::fillVisibilityObserved (Matrix<CStokesVector>& value) const
2979 : //{
2980 : // CheckVisIter ();
2981 : //
2982 : // getViiP()->visibilityObserved (value);
2983 : //}
2984 :
2985 :
2986 : void
2987 1437157 : VisBufferImpl2::fillWeight (Matrix<Float>& value) const
2988 : {
2989 1437157 : CheckVisIter ();
2990 :
2991 1437157 : getViiP()->weight (value);
2992 1437157 : }
2993 :
2994 : void
2995 0 : VisBufferImpl2::fillWeights (Vector<Matrix<Float>>& value) const
2996 : {
2997 0 : CheckVisIter ();
2998 :
2999 0 : getViiP()->weight (value);
3000 0 : }
3001 :
3002 : void
3003 919200 : VisBufferImpl2::fillWeightSpectrum (Cube<Float>& value) const
3004 : {
3005 919200 : CheckVisIter ();
3006 :
3007 919200 : if (getViiP()->weightSpectrumExists()){
3008 :
3009 505053 : getViiP()->weightSpectrum (value);
3010 : }
3011 : else{
3012 :
3013 : // Weight spectrum doesn't exist so create on using the weight column.
3014 :
3015 414147 : Matrix<Float> theWeights;
3016 414147 : theWeights = weight(); // need a mutable copy so ensure no sharing.
3017 :
3018 : // The weight is the sum of the weight across all channels
3019 : // so divide it evenly between the channels.
3020 :
3021 : // jagonzal (new WEIGHT/SIGMA convention in CASA 4.2.2)
3022 : // theWeights = theWeights / nChannels();
3023 :
3024 414147 : value.resize (IPosition (3, nCorrelations (), nChannels (), nRows()));
3025 :
3026 : // Copy the apportioned weight value into the weight spectrum
3027 :
3028 : // jagonzal (TODO): Review this filling code (it should be row/channel/correlation)
3029 : // Or even better direct array assignment
3030 4129374 : for (rownr_t row = 0; row < nRows(); row ++){
3031 :
3032 13411724 : for (Int correlation = 0; correlation < nCorrelations (); correlation ++){
3033 :
3034 9696497 : Int nChan = nChannels();
3035 9696497 : float theWeight = theWeights (correlation, row);
3036 :
3037 732406273 : for (Int channel = 0; channel < nChan; channel ++){
3038 :
3039 722709776 : value (correlation, channel, row) = theWeight;
3040 : }
3041 :
3042 : }
3043 : }
3044 414147 : }
3045 919200 : }
3046 :
3047 : void
3048 0 : VisBufferImpl2::fillWeightSpectra (Vector<Cube<Float>>& value) const
3049 : {
3050 0 : CheckVisIter ();
3051 :
3052 0 : if (getViiP()->weightSpectrumExists()){
3053 :
3054 0 : getViiP()->weightSpectrum (value);
3055 : }
3056 : else{
3057 0 : value.resize(this->nShapes());
3058 :
3059 0 : auto nRowsPerShape = this->nRowsPerShape();
3060 0 : auto nCorrelationsPerShape = this->nCorrelationsPerShape();
3061 0 : auto nChannelsPerShape = this->nChannelsPerShape();
3062 :
3063 : // Weight spectrum doesn't exist so create on using the weight column.
3064 0 : auto theWeights = weights();
3065 :
3066 0 : for (rownr_t ishape = 0; ishape < nShapes(); ishape ++){
3067 :
3068 0 : auto nRows = nRowsPerShape[ishape];
3069 0 : auto nCorrelations = nCorrelationsPerShape[ishape];
3070 0 : auto nChannels = nChannelsPerShape[ishape];
3071 :
3072 0 : value[ishape].resize (IPosition (3, nCorrelations, nChannels, nRows));
3073 :
3074 0 : for (rownr_t row = 0; row < nRows; row ++){
3075 :
3076 0 : for (Int correlation = 0; correlation < nCorrelations; correlation ++){
3077 :
3078 0 : float theWeight = theWeights[ishape] (correlation, row);
3079 :
3080 0 : for (Int channel = 0; channel < nChannels; channel ++){
3081 :
3082 0 : value[ishape] (correlation, channel, row) = theWeight;
3083 : }
3084 :
3085 : }
3086 : }
3087 : }
3088 0 : }
3089 0 : }
3090 :
3091 : void
3092 752206 : VisBufferImpl2::fillSigmaSpectrum (Cube<Float>& value) const
3093 : {
3094 752206 : CheckVisIter ();
3095 :
3096 752206 : if (getViiP()->sigmaSpectrumExists()){
3097 :
3098 229624 : getViiP()->sigmaSpectrum (value);
3099 : }
3100 : else{
3101 :
3102 522582 : auto nRows = this->nRows();
3103 522582 : auto nCorrelations = this->nCorrelations ();
3104 522582 : auto nChannels = this->nChannels();
3105 :
3106 : // Sigma spectrum doesn't exist so create on using the sigma column.
3107 :
3108 522582 : const Matrix<Float> & theSigmas = sigma();
3109 : /////theSigmas = sigma(); // need a mutable copy so ensure no sharing.
3110 :
3111 522582 : value.resize (IPosition (3, nCorrelations, nChannels, nRows));
3112 :
3113 : // Copy the apportioned weight value into the sigma spectrum
3114 :
3115 : // jagonzal (TODO): Review this filling code (it should be row/channel/correlation)
3116 : // Or even better direct array assignment
3117 :
3118 13403633 : for (rownr_t row = 0; row < nRows; row ++){
3119 :
3120 57442140 : for (Int correlation = 0; correlation < nCorrelations; correlation ++){
3121 :
3122 44561089 : float theSigma = theSigmas (correlation, row);
3123 :
3124 1275673935 : for (Int channel = 0; channel < nChannels; channel ++){
3125 :
3126 1231112846 : value (correlation, channel, row) = theSigma;
3127 : }
3128 :
3129 : }
3130 : }
3131 : }
3132 752206 : }
3133 :
3134 : void
3135 0 : VisBufferImpl2::fillSigmaSpectra (Vector<Cube<Float>>& value) const
3136 : {
3137 0 : CheckVisIter ();
3138 :
3139 0 : if (getViiP()->sigmaSpectrumExists()){
3140 :
3141 0 : getViiP()->sigmaSpectrum (value);
3142 : }
3143 : else{
3144 0 : value.resize(this->nShapes());
3145 :
3146 0 : auto nRowsPerShape = this->nRowsPerShape();
3147 0 : auto nCorrelationsPerShape = this->nCorrelationsPerShape();
3148 0 : auto nChannelsPerShape = this->nChannelsPerShape();
3149 :
3150 : // Sigma spectrum doesn't exist so create on using the sigma column.
3151 0 : auto theSigmas = sigmas();
3152 :
3153 0 : for (rownr_t ishape = 0; ishape < nShapes(); ishape ++){
3154 :
3155 0 : auto nRows = nRowsPerShape[ishape];
3156 0 : auto nCorrelations = nCorrelationsPerShape[ishape];
3157 0 : auto nChannels = nChannelsPerShape[ishape];
3158 :
3159 0 : value[ishape].resize (IPosition (3, nCorrelations, nChannels, nRows));
3160 :
3161 0 : for (rownr_t row = 0; row < nRows; row ++){
3162 :
3163 0 : for (Int correlation = 0; correlation < nCorrelations; correlation ++){
3164 :
3165 0 : float theSigma = theSigmas[ishape] (correlation, row);
3166 :
3167 0 : for (Int channel = 0; channel < nChannels; channel ++){
3168 :
3169 0 : value[ishape] (correlation, channel, row) = theSigma;
3170 : }
3171 :
3172 : }
3173 : }
3174 : }
3175 0 : }
3176 0 : }
3177 :
3178 : Float
3179 0 : VisBufferImpl2::getWeightScaled (Int row) const
3180 : {
3181 0 : Float sum = 0;
3182 0 : Int n = nCorrelations();
3183 :
3184 0 : for (Int correlation = 0; correlation < n; ++ correlation){
3185 :
3186 0 : sum += getWeightScaled (correlation, row);
3187 : }
3188 :
3189 0 : return sum / n;
3190 : }
3191 :
3192 : Float
3193 0 : VisBufferImpl2::getWeightScaled (Int correlation, Int row) const
3194 : {
3195 0 : if (flagRow () (row)){
3196 0 : return 0;
3197 : }
3198 :
3199 0 : if (weightSpectrumPresent()){
3200 :
3201 0 : Float sum = 0;
3202 0 : Int n = nChannels ();
3203 :
3204 0 : for (Int channel = 0; channel < n; ++ channel){
3205 :
3206 0 : sum += getWeightScaled (correlation, channel, row);
3207 :
3208 : }
3209 :
3210 0 : return sum / n;
3211 : }
3212 : else {
3213 :
3214 0 : Float theWeight = weight () (correlation, row);
3215 :
3216 0 : if (! state_p->weightScaling_p.null()){
3217 0 : theWeight = (* state_p->weightScaling_p) (theWeight);
3218 : }
3219 :
3220 0 : return theWeight;
3221 : }
3222 : }
3223 :
3224 : Float
3225 0 : VisBufferImpl2::getWeightScaled (Int correlation, Int channel, Int row) const
3226 : {
3227 : // Get the weight from the weightSpectrum if it is present (either it was
3228 : // read from the MS or it was set by the user); otherwise get the weight
3229 : // from the weight column.
3230 :
3231 0 : Float theWeight = 0;
3232 :
3233 0 : if (weightSpectrumPresent ()){
3234 :
3235 0 : theWeight = weightSpectrum () (correlation, channel, row);
3236 : }
3237 : else{
3238 0 : theWeight = weight () (correlation, row);
3239 : }
3240 :
3241 : // If there is a scaling function, the apply that to the weight
3242 :
3243 0 : if (! state_p->weightScaling_p.null()){
3244 0 : theWeight = (* state_p->weightScaling_p) (theWeight);
3245 : }
3246 :
3247 0 : return theWeight;
3248 : }
3249 :
3250 : Float
3251 0 : VisBufferImpl2::getSigmaScaled (Int row) const
3252 : {
3253 0 : Float sum = 0;
3254 0 : Int n = nCorrelations();
3255 :
3256 0 : for (Int correlation = 0; correlation < n; ++ correlation){
3257 :
3258 0 : sum += getWeightScaled (correlation, row);
3259 : }
3260 :
3261 0 : return sum / n;
3262 : }
3263 :
3264 : Float
3265 0 : VisBufferImpl2::getSigmaScaled (Int correlation, Int row) const
3266 : {
3267 0 : if (flagRow () (row)){
3268 0 : return 0;
3269 : }
3270 :
3271 0 : if (weightSpectrumPresent()){
3272 :
3273 0 : Float sum = 0;
3274 0 : Int n = nChannels ();
3275 :
3276 0 : for (Int channel = 0; channel < n; ++ channel){
3277 :
3278 0 : sum += getWeightScaled (correlation, channel, row);
3279 :
3280 : }
3281 :
3282 0 : return sum / n;
3283 : }
3284 : else {
3285 :
3286 0 : Float theWeight = weight () (correlation, row);
3287 :
3288 0 : if (! state_p->weightScaling_p.null()){
3289 0 : theWeight = (* state_p->weightScaling_p) (theWeight);
3290 : }
3291 :
3292 0 : return theWeight;
3293 : }
3294 : }
3295 :
3296 : Float
3297 0 : VisBufferImpl2::getSigmaScaled (Int correlation, Int channel, Int row) const
3298 : {
3299 : // Get the weight from the weightSpectrum if it is present (either it was
3300 : // read from the MS or it was set by the user); otherwise get the weight
3301 : // from the weight column.
3302 :
3303 0 : Float theWeight = 0;
3304 :
3305 0 : if (weightSpectrumPresent ()){
3306 :
3307 0 : theWeight = weightSpectrum () (correlation, channel, row);
3308 : }
3309 : else{
3310 0 : theWeight = weight () (correlation, row);
3311 : }
3312 :
3313 : // If there is a scaling function, the apply that to the weight
3314 :
3315 0 : if (! state_p->weightScaling_p.null()){
3316 0 : theWeight = (* state_p->weightScaling_p) (theWeight);
3317 : }
3318 :
3319 0 : return theWeight;
3320 : }
3321 :
3322 : CountedPtr<WeightScaling>
3323 47196 : VisBufferImpl2::getWeightScaling () const
3324 : {
3325 47196 : return state_p->weightScaling_p;
3326 : }
3327 :
3328 : Bool
3329 0 : VisBufferImpl2::weightSpectrumPresent () const
3330 : {
3331 0 : Bool present = cache_p->weightSpectrum_p.isPresent() ||
3332 0 : (isAttached() && getViiP()->weightSpectrumExists());
3333 :
3334 0 : return present;
3335 : }
3336 :
3337 : Bool
3338 0 : VisBufferImpl2::sigmaSpectrumPresent () const
3339 : {
3340 0 : Bool present = cache_p->sigmaSpectrum_p.isPresent() ||
3341 0 : (isAttached() && getViiP()->sigmaSpectrumExists());
3342 :
3343 0 : return present;
3344 : }
3345 :
3346 :
3347 : } // end namespace vi
3348 :
3349 : using namespace casacore;
3350 : } // end namespace casa
|
