Line data Source code
1 : /*
2 : * VisibilityBufferAsync.cc
3 : *
4 : * Created on: Nov 1, 2010
5 : * Author: jjacobs
6 : */
7 : #include <stdcasa/UtilJ.h>
8 :
9 : using namespace casacore;
10 : #include <regex> // >>>----------------> no compile failure
11 : using namespace casa::utilj;
12 : // include <regex> >>>----------------> causes compile failure
13 : #include <casacore/casa/Containers/Record.h>
14 :
15 : #include <msvis/MSVis/VisBufferAsync.h>
16 : #include <msvis/MSVis/VisBufferAsyncWrapper.h>
17 : #include <msvis/MSVis/VisibilityIterator.h>
18 : #include <msvis/MSVis/AsynchronousInterface.h>
19 : #include <msvis/MSVis/VLAT.h>
20 :
21 : #include <algorithm>
22 :
23 : using std::transform;
24 :
25 : #include <casacore/ms/MeasurementSets/MSColumns.h>
26 : #include <typeinfo>
27 :
28 : #define Log(level, ...) \
29 : {if (casa::asyncio::AsynchronousInterface::logThis (level)) \
30 : casa::async::Logger::get()->log (__VA_ARGS__);};
31 :
32 : using namespace casacore;
33 : namespace casa {
34 :
35 : namespace asyncio {
36 :
37 : template <typename MeasureType, typename AsMeasure>
38 : MeasureType
39 0 : unsharedCopyMeasure (const MeasureType & measure, AsMeasure asMeasure)
40 : {
41 : // MeasureType is a derived type of MeasBase<> (e.g., MDirection, MEpoch, etc.)
42 : // AsMeasure is the MeasureHolder converter for the desired type (e.g., asMDirection, asMEpoch, etc.)
43 :
44 : // Make a completely distinct copy of this measure. The
45 : // methods provided by a Measure always result in the sharing
46 : // of the measurement reference object so this roundabout
47 : // approach is necessary.
48 :
49 : // Using a MeasureHolder object, transform the contents of the
50 : // measure into a generic record.
51 :
52 0 : MeasureHolder original (measure);
53 0 : Record record;
54 0 : String err;
55 :
56 0 : original.toRecord(err, record);
57 :
58 : // Now use the record to create another MMeasure object using
59 : // the record created to hold the original's information.
60 :
61 0 : MeasureHolder copy;
62 0 : copy.fromRecord (err, record);
63 :
64 0 : MeasureType result = (copy .* asMeasure) ();
65 :
66 0 : return result;
67 : }
68 :
69 : } // end namespace asyncio
70 :
71 0 : VisBufferAsync::VisBufferAsync ()
72 0 : : VisBuffer ()
73 : {
74 0 : construct();
75 0 : }
76 :
77 0 : VisBufferAsync::VisBufferAsync (const VisBufferAsync & vb)
78 0 : : VisBuffer ()
79 : {
80 : // const VisBufferAsync * vb = dynamic_cast<const VisBufferAsync *> (& vb0);
81 : // ThrowIf (vb == NULL, "Cannot copy VisBuffer into VisBufferAsync");
82 :
83 0 : construct ();
84 :
85 0 : * this = vb;
86 0 : }
87 :
88 0 : VisBufferAsync::VisBufferAsync (ROVisibilityIterator & iter)
89 0 : : VisBuffer ()
90 : {
91 0 : construct ();
92 :
93 0 : Log (2, "VisBufferAsync::VisBufferAsync: attaching in constructor this=%08x\n", this);
94 0 : attachToVisIter (iter);
95 0 : }
96 :
97 :
98 0 : VisBufferAsync::~VisBufferAsync ()
99 : {
100 0 : Log (2, "Destroying VisBufferAsync; addr=0x%016x\n", this);
101 :
102 : // Should never be attached at the synchronous level
103 :
104 0 : Assert (visIter_p == NULL || ! twoWayConnection_p);
105 :
106 0 : delete msColumns_p;
107 0 : delete msd_p;
108 0 : }
109 :
110 : VisBufferAsync &
111 0 : VisBufferAsync::operator= (const VisBufferAsync & other)
112 : {
113 0 : if (this != & other){
114 :
115 0 : assign (other, true);
116 : }
117 :
118 0 : return * this;
119 : }
120 :
121 : void
122 0 : VisBufferAsync::allSelectedSpectralWindows(Vector<Int> & spectralWindows,
123 : Vector<Int>& nVisibilityChannels)
124 : {
125 0 : spectralWindows.assign (selectedSpectralWindows_p);
126 0 : nVisibilityChannels.assign (selectedNVisibilityChannels_p);
127 0 : }
128 :
129 : VisBufferAsync &
130 0 : VisBufferAsync::assign (const VisBuffer & other, Bool copy)
131 : {
132 0 : if (this != & other){
133 :
134 : // assert (copy); // The copy parameter is ignored since it makes no sense to
135 : // // assign a VBA without copying its values
136 :
137 0 : Log (2, "Assign from VisBufferAsync @ 0x%08x to VisBufferAsync @ 0x%08x\n", & other, this);
138 :
139 0 : Assert (dynamic_cast<const VisBufferAsync *> (& other) != NULL);
140 0 : Assert (visIter_p == NULL); // shouldn't be attached at sync level
141 :
142 0 : if (other.corrSorted_p)
143 0 : throw(AipsError("Cannot assign a VisBuffer that has had correlations sorted!"));
144 :
145 0 : azelCachedTime_p = 0; // flush this cached value
146 0 : feedpaCachedTime_p = 0; // flush this cached value
147 0 : parangCachedTime_p = 0; // flush this cached value
148 :
149 0 : if (copy){
150 :
151 : // Let the standard VisBuffer do the copying of values
152 : // from the old VisBuffer
153 :
154 0 : copyCache (other, false);
155 :
156 : // Copy over the async values
157 :
158 0 : copyAsyncValues (dynamic_cast<const VisBufferAsync &> (other));
159 :
160 : }
161 : }
162 :
163 0 : return * this;
164 : }
165 :
166 : void
167 0 : VisBufferAsync::attachToVisIter(ROVisibilityIterator & iter)
168 : {
169 0 : Assert (isFilling_p == true); // Only allowed while being filled
170 0 : Assert (visIter_p == NULL); // Shouldn't already be attached
171 :
172 0 : VisBuffer::attachToVisIter(iter);
173 0 : }
174 :
175 : Vector<MDirection>
176 0 : VisBufferAsync::azel(Double time) const
177 : {
178 0 : if (time != azelCachedTime_p){
179 :
180 0 : azelCachedTime_p = time;
181 :
182 0 : ROVisibilityIterator::azelCalculate (time, * msd_p, azelCached_p, nAntennas_p, mEpoch_p);
183 : }
184 :
185 0 : return azelCached_p;
186 : }
187 :
188 : MDirection
189 0 : VisBufferAsync::azel0(Double time) const
190 : {
191 0 : MDirection azel0;
192 : //MSDerivedValues msd;
193 : //msd.setMeasurementSet (* measurementSet_p);
194 :
195 :
196 0 : ROVisibilityIterator::azel0Calculate (time, * msd_p, azel0, mEpoch_p);
197 :
198 0 : return azel0;
199 : }
200 :
201 : void
202 0 : VisBufferAsync::checkVisIter (const char * func, const char * file, int line, const char * extra) const
203 : {
204 : // This is called from a VisBuffer fill method. Throw an error if the this is not
205 : // part of the VLAT filling operation or if there is not visibility iterator attached
206 :
207 0 : if (visIter_p == NULL){
208 0 : Log (1, "VisBufferAsync: request for column not in prefetched set (in call to %s (%s))\n)",
209 : func, extra);
210 : throw AipsErrorTrace ("VisBufferAsync: request for column not in prefetched set (in call to "
211 0 : + String (func) + String (extra) + ")", file, line);
212 : }
213 0 : }
214 :
215 :
216 : void
217 0 : VisBufferAsync::clear ()
218 : {
219 0 : Log (2, "Clearing VisBufferAsync; addr=0x%016x\n", this);
220 :
221 : // Put scalars to deterministic values
222 :
223 0 : dataDescriptionId_p = -1;
224 0 : measurementSet_p = NULL;
225 0 : nAntennas_p = 0;
226 :
227 0 : invalidateAsync (); // set all the flags to indicate caches are empty
228 :
229 : // Since VBA was created using a shallow copy of shared data
230 : // it is necessary to break the linkage with the shared data
231 : // while the shared data is locked. Otherwise there could be
232 : // some interaction between the base and lookahead threads
233 : // because of the reference counted data structures, etc.
234 :
235 : // Wipe the fields that are part of VisBuffer proper
236 :
237 0 : if (antenna1OK_p)
238 0 : antenna1_p.resize();
239 0 : if (antenna2OK_p)
240 0 : antenna2_p.resize();
241 0 : chanAveBounds_p.resize();
242 : //chanFreqs_p = NULL;
243 0 : if (channelOK_p)
244 0 : channel_p.resize();
245 0 : if (cjonesOK_p)
246 0 : cjones_p.resize();
247 0 : if (corrTypeOK_p)
248 0 : corrType_p.resize();
249 0 : if (correctedVisCubeOK_p)
250 0 : correctedVisCube_p.resize();
251 0 : if (correctedVisibilityOK_p)
252 0 : correctedVisibility_p.resize();
253 0 : if (direction1OK_p)
254 0 : direction1_p.resize();
255 0 : if (direction2OK_p)
256 0 : direction2_p.resize();
257 0 : if (feed1OK_p)
258 0 : feed1_p.resize();
259 0 : if (feed1_paOK_p)
260 0 : feed1_pa_p.resize();
261 0 : if (feed2OK_p)
262 0 : feed2_p.resize();
263 0 : if (feed2_paOK_p)
264 0 : feed2_pa_p.resize();
265 0 : if (flagCubeOK_p)
266 0 : flagCube_p.resize();
267 0 : if (flagRowOK_p)
268 0 : flagRow_p.resize();
269 0 : if (flagOK_p)
270 0 : flag_p.resize();
271 0 : if (frequencyOK_p)
272 0 : frequency_p.resize();
273 0 : if (imagingWeightOK_p)
274 0 : imagingWeight_p.resize();
275 : // if (lsrFrequencyOK_p)
276 : // lsrFrequency_p.resize();
277 0 : measurementSet_p = NULL;
278 0 : if (modelVisCubeOK_p)
279 0 : modelVisCube_p.resize();
280 0 : if (modelVisibilityOK_p)
281 0 : modelVisibility_p.resize();
282 0 : delete msColumns_p;
283 0 : msColumns_p = NULL;
284 0 : nAntennas_p = -1;
285 0 : nCoh_p = -1;
286 0 : phaseCenter_p = MDirection ();
287 0 : if (rowIdsOK_p)
288 0 : rowIds_p.resize();
289 0 : if (scanOK_p)
290 0 : scan_p.resize();
291 0 : if (sigmaMatOK_p)
292 0 : sigmaMat_p.resize();
293 0 : if (sigmaOK_p)
294 0 : sigma_p.resize();
295 0 : if (timeIntervalOK_p)
296 0 : timeInterval_p.resize();
297 0 : if (timeOK_p)
298 0 : time_p.resize();
299 0 : if (uvwMatOK_p)
300 0 : uvwMat_p.resize();
301 0 : if (uvwOK_p)
302 0 : uvw_p.resize();
303 0 : if (visCubeOK_p)
304 0 : visCube_p.resize();
305 0 : if (visibilityOK_p)
306 0 : visibility_p.resize();
307 0 : weightCube_p.resize();
308 0 : if (weightMatOK_p)
309 0 : weightMat_p.resize();
310 0 : if (weightSpectrumOK_p)
311 0 : weightSpectrum_p.resize();
312 0 : if (weightOK_p)
313 0 : weight_p.resize();
314 :
315 : // Wipe fields that are part of VisBufferAsync only
316 :
317 : //delete msd_p;
318 : //msd_p = new MSDerivedValues();
319 :
320 0 : channelGroupNumber_p.resize (0);
321 0 : channelIncrement_p.resize (0);
322 0 : channelStart_p.resize (0);
323 0 : channelWidth_p.resize (0);
324 0 : lsrFrequency_p.resize (0);
325 0 : mEpoch_p = MEpoch();
326 0 : observatoryPosition_p = MPosition();
327 0 : phaseCenter_p = MDirection();
328 0 : receptor0Angle_p.resize (0);
329 0 : rowIds_p.resize (0);
330 0 : selFreq_p.resize (0);
331 0 : selectedNVisibilityChannels_p.resize (0);
332 0 : selectedSpectralWindows_p.resize (0);
333 0 : visibilityShape_p.resize (0, false);
334 0 : }
335 :
336 : VisBuffer *
337 0 : VisBufferAsync::clone () const
338 : {
339 0 : return new VisBufferAsync (* this);
340 : }
341 :
342 :
343 : void
344 0 : VisBufferAsync::construct ()
345 : {
346 0 : Log (2, "Constructing VisBufferAsync; addr=0x%016x\n", this);
347 :
348 0 : initializeScalars ();
349 :
350 0 : azelCachedTime_p = 0; // tag azel as currently uncached
351 0 : feedpaCachedTime_p = 0; // tag azel as currently uncached
352 0 : parangCachedTime_p = 0; // tag azel as currently uncached
353 0 : msColumns_p = NULL;
354 0 : visIter_p = NULL;
355 0 : isFilling_p = false;
356 0 : msd_p = new MSDerivedValues();
357 :
358 0 : clear ();
359 0 : }
360 :
361 : void
362 0 : VisBufferAsync::copyCache (const VisBuffer & other, Bool force)
363 : {
364 0 : assert (! force);
365 : UnusedVariable (force);
366 :
367 0 : VisBuffer::copyCache (other, false);
368 0 : }
369 :
370 :
371 : void
372 0 : VisBufferAsync::copyAsyncValues (const VisBufferAsync & other)
373 : {
374 :
375 0 : channelGroupNumber_p = other.channelGroupNumber_p;
376 0 : channelIncrement_p = other.channelIncrement_p;
377 0 : channelStart_p = other.channelStart_p;
378 0 : channelWidth_p = other.channelWidth_p;
379 :
380 0 : dataDescriptionId_p = other.dataDescriptionId_p;
381 0 : lsrFrequency_p = other.lsrFrequency_p;
382 0 : measurementSet_p = other.measurementSet_p;
383 0 : mEpoch_p = other.mEpoch_p;
384 :
385 :
386 0 : delete msColumns_p; // kill the current one
387 0 : msColumns_p = NULL;
388 :
389 0 : nAntennas_p = other.nAntennas_p;
390 0 : newArrayId_p = other.newArrayId_p;
391 0 : newFieldId_p = other.newFieldId_p;
392 0 : newSpectralWindow_p = other.newSpectralWindow_p;
393 0 : nRowChunk_p = other.nRowChunk_p;
394 : // obsMFreqTypes_p = other.obsMFreqTypes_p;
395 0 : observatoryPosition_p = other.observatoryPosition_p;
396 0 : phaseCenter_p = other.phaseCenter_p;
397 0 : receptor0Angle_p = other.receptor0Angle_p;
398 0 : rowIds_p = other.rowIds_p;
399 0 : selectedNVisibilityChannels_p = other.selectedNVisibilityChannels_p;
400 0 : selectedSpectralWindows_p = other.selectedSpectralWindows_p;
401 0 : selFreq_p = other.selFreq_p;
402 0 : velSelection_p = other.velSelection_p;
403 0 : visibilityShape_p = other.visibilityShape_p;
404 :
405 0 : setMSD (* other.msd_p);
406 0 : }
407 :
408 :
409 : //VisBuffer *
410 : //VisBufferAsync::create (const VisBuffer & other)
411 : //{
412 : //
413 : // VisBuffer * result;
414 : //
415 : // if (ROVisibilityIteratorAsync::isAsynchronousIoEnabled ()){
416 : //
417 : // result = new VisBufferAsync (other);
418 : //
419 : // }
420 : // else {
421 : //
422 : //
423 : // result = new VisBuffer (other);
424 : // }
425 : //
426 : // return result;
427 : //}
428 :
429 :
430 : //VisBuffer *
431 : //VisBufferAsync::create (ROVisibilityIterator & iter)
432 : //{
433 : // return create (& iter);
434 : //}
435 : //
436 : //VisBuffer *
437 : //VisBufferAsync::create (ROVisibilityIterator * iter)
438 : //{
439 : // VisBuffer * result = NULL;
440 : // ROVisibilityIteratorAsync * via = dynamic_cast<ROVisibilityIteratorAsync *> (iter);
441 : //
442 : // bool createAsynchronous = ROVisibilityIteratorAsync::isAsynchronousIoEnabled () &&
443 : // via != NULL;
444 : //
445 : // if (createAsynchronous){
446 : //
447 : // // Asynchronous I/O is enabled so return a
448 : // // VisBufferAsync
449 : //
450 : // Assert (via != NULL); // mixing VB with other than a ROVIA is not good
451 : // result = new VisBufferAsync (* via);
452 : // }
453 : // else {
454 : //
455 : // // By default return a normal VisBuffer
456 : //
457 : // Assert (via == NULL); // mixing VB with a ROVIA is not good
458 : //
459 : // result = new VisBuffer (* iter);
460 : // }
461 : //
462 : // String reason;
463 : // if (ROVisibilityIteratorAsync::isAsynchronousIoEnabled ()){
464 : // if (via == NULL){
465 : // reason = format (" (synchronous iterator received: %s)", typeid (* iter).name());
466 : // }
467 : // else{
468 : // reason = format ("Async; addr=0x%016x", result);
469 : // }
470 : //
471 : // }
472 : // else{
473 : // reason = " (async I/O disabled)";
474 : // }
475 : //
476 : // Log (2, "Created VisBuffer%s\n", reason.c_str());
477 : // //printBacktrace (cerr, "VisBufferAsync creation");
478 : //
479 : // return result;
480 : //}
481 :
482 :
483 : //Int
484 : //VisBufferAsync::dataDescriptionId() const
485 : //{
486 : // return dataDescriptionId_p;
487 : //}
488 :
489 : void
490 0 : VisBufferAsync::detachFromVisIter ()
491 : {
492 :
493 0 : if (isFilling_p){
494 0 : VisBuffer::detachFromVisIter();
495 : }
496 0 : }
497 :
498 :
499 : Vector<Float>
500 0 : VisBufferAsync::feed_pa(Double time) const
501 : {
502 0 : if (time != feedpaCachedTime_p){
503 :
504 0 : feedpaCachedTime_p = time;
505 :
506 0 : if (visIter_p != NULL){
507 :
508 : // This method can be called during filling; if so then let it
509 : // work the original way (possible hole for detached VBAs).
510 :
511 0 : feedpaCached_p = VisBuffer::feed_pa (time);
512 : }
513 : else{
514 :
515 : //MSDerivedValues msd;
516 : //msd.setMeasurementSet (* measurementSet_p);
517 :
518 0 : feedpaCached_p.assign (ROVisibilityIterator::feed_paCalculate (time, * msd_p, nAntennas_p,
519 0 : mEpoch_p, receptor0Angle_p));
520 : }
521 :
522 : }
523 :
524 0 : return feedpaCached_p;
525 : }
526 :
527 : Bool
528 0 : VisBufferAsync::fillAllBeamOffsetsZero ()
529 : {
530 0 : allBeamOffsetsZero_p = visIter_p->allBeamOffsetsZero();
531 :
532 0 : return allBeamOffsetsZero_p;
533 : }
534 :
535 : Vector <String>
536 0 : VisBufferAsync::fillAntennaMounts ()
537 : {
538 0 : antennaMounts_p = visIter_p->antennaMounts();
539 :
540 0 : return antennaMounts_p;
541 : }
542 :
543 : Cube <RigidVector <Double, 2> >
544 0 : VisBufferAsync::fillBeamOffsets ()
545 : {
546 0 : beamOffsets_p = visIter_p->getBeamOffsets ();
547 :
548 0 : return beamOffsets_p;
549 : }
550 :
551 : Cube <Double>
552 0 : VisBufferAsync::fillReceptorAngles ()
553 : {
554 0 : receptorAngles_p = visIter_p->receptorAngles();
555 :
556 0 : return receptorAngles_p;
557 : }
558 :
559 :
560 : void
561 0 : VisBufferAsync::fillFrom (const VisBufferAsync & other)
562 : {
563 : // Almost like assignment except that the attachment to the
564 : // Visibility iterator is preserved. Only used for copying
565 : // data from the buffer ring into the user's VB
566 :
567 0 : Log (2, "Fill from VisBufferAsync @ 0x%08x to VisBufferAsync @ 0x%08x\n", & other, this);
568 :
569 0 : copyCache (other, false);
570 0 : copyAsyncValues (other);
571 :
572 0 : }
573 :
574 : Vector<MDirection>&
575 0 : VisBufferAsync::fillDirection1()
576 : {
577 : // Perform filling in the normal way
578 :
579 0 : VisBuffer::fillDirection1();
580 :
581 0 : if (isFilling_p) {
582 :
583 : // Now install unshared copies of the direction objects
584 :
585 0 : unsharedCopyDirectionVector (direction1_p);
586 :
587 : }
588 :
589 0 : return direction1_p;
590 : }
591 :
592 :
593 :
594 : Vector<MDirection>&
595 0 : VisBufferAsync::fillDirection2()
596 : {
597 : // Perform filling in the normal way
598 :
599 0 : VisBuffer::fillDirection2();
600 :
601 0 : if (isFilling_p){
602 :
603 : // Now install unshared copies of the direction objects
604 :
605 0 : unsharedCopyDirectionVector (direction2_p);
606 :
607 : }
608 :
609 0 : return direction2_p;
610 : }
611 :
612 : MDirection &
613 0 : VisBufferAsync::fillPhaseCenter()
614 : {
615 : // Perform filling in the normal way
616 :
617 0 : VisBuffer::fillPhaseCenter();
618 :
619 : // Now convert the value to an unshared one.
620 :
621 0 : phaseCenter_p = unsharedCopyDirection (phaseCenter_p);
622 0 : phaseCenterOK_p = true;
623 :
624 0 : return phaseCenter_p;
625 : }
626 :
627 : Bool
628 0 : VisBufferAsync::getAllBeamOffsetsZero () const
629 : {
630 0 : return allBeamOffsetsZero_p;
631 : }
632 :
633 : const Vector <String> &
634 0 : VisBufferAsync::getAntennaMounts () const
635 : {
636 0 : return antennaMounts_p;
637 : }
638 :
639 : const Cube <RigidVector <Double, 2> > &
640 0 : VisBufferAsync::getBeamOffsets () const
641 : {
642 0 : return beamOffsets_p;
643 : }
644 :
645 :
646 : const MeasurementSet &
647 0 : VisBufferAsync::getMs () const
648 : {
649 0 : return * measurementSet_p;
650 : }
651 :
652 : Int
653 0 : VisBufferAsync::getNSpw () const
654 : {
655 0 : return nSpw_p;
656 : }
657 :
658 :
659 : MDirection
660 0 : VisBufferAsync::getPhaseCenter () const
661 : {
662 0 : return phaseCenter_p;
663 : }
664 :
665 :
666 : const Cube <Double> &
667 0 : VisBufferAsync::getReceptorAngles () const
668 : {
669 0 : return receptorAngles_p;
670 : }
671 :
672 : Double
673 0 : VisBufferAsync::hourang(Double time) const
674 : {
675 : //MSDerivedValues msd;
676 : //msd.setMeasurementSet (* measurementSet_p);
677 :
678 0 : Double hourang = ROVisibilityIterator::hourangCalculate (time, * msd_p, mEpoch_p);
679 :
680 0 : return hourang;
681 : }
682 :
683 : void
684 0 : VisBufferAsync::initializeScalars ()
685 : {
686 : // Set all VBA specific scalars to known values to prevent
687 : // nondeterminism.
688 :
689 0 : dataDescriptionId_p = -1;
690 0 : feedpaCachedTime_p = -1;
691 0 : isFilling_p = false;
692 0 : measurementSet_p = NULL;
693 0 : msColumns_p = NULL;
694 0 : msd_p = NULL;
695 0 : nAntennas_p = -1;
696 0 : nCoh_p = -1;
697 0 : newArrayId_p = false;
698 0 : newFieldId_p = false;
699 0 : newSpectralWindow_p = false;
700 0 : nRowChunk_p = -1;
701 0 : nSpw_p = -1;
702 0 : parangCachedTime_p = -1;
703 0 : polarizationId_p = -1;
704 0 : velSelection_p = false;
705 0 : }
706 :
707 : void
708 0 : VisBufferAsync::invalidate ()
709 : {
710 : // This is called by synchronous code. Just ignore it since
711 : // the cache validity is being managed by async code. To really
712 : // invalidate use invalidateAsync.
713 0 : }
714 :
715 : void
716 0 : VisBufferAsync::invalidateAsync ()
717 : {
718 : // A way for the new code to invalidate the buffer that
719 : // can be distinguished from the old way.
720 :
721 0 : VisBuffer::invalidate ();
722 0 : }
723 :
724 : void
725 0 : VisBufferAsync::lsrFrequency (const Int& spw, Vector<Double>& freq, Bool& convert) const
726 : {
727 0 : if (velSelection_p) {
728 0 : freq.assign (lsrFrequency_p);
729 0 : convert = false;
730 0 : return;
731 : }
732 :
733 0 : const ArrayColumn <Double> & chanFreqs = msColumns().spectralWindow().chanFreq();
734 0 : const ScalarColumn<Int> & obsMFreqTypes= msColumns().spectralWindow().measFreqRef();
735 :
736 0 : MPosition obsPos = observatoryPosition_p;
737 0 : MDirection dir = phaseCenter_p;
738 :
739 0 : ROVisibilityIterator::lsrFrequency (spw, freq, convert, channelStart_p, channelWidth_p, channelIncrement_p,
740 0 : channelGroupNumber_p, chanFreqs, obsMFreqTypes, mEpoch_p, obsPos, dir);
741 : }
742 :
743 : const MSColumns &
744 0 : VisBufferAsync::msColumns() const
745 : {
746 0 : if (isFilling_p){
747 :
748 0 : Assert (visIter_p != NULL);
749 :
750 0 : return visIter_p->msColumns ();
751 : }
752 : else {
753 :
754 0 : Assert (measurementSet_p != NULL);
755 :
756 0 : if (msColumns_p == NULL){
757 0 : msColumns_p = new MSColumns (* measurementSet_p);
758 : }
759 :
760 0 : return * msColumns_p;
761 : }
762 : }
763 :
764 : Int
765 0 : VisBufferAsync::msId () const
766 : {
767 0 : return oldMSId_p;
768 : }
769 :
770 : Bool
771 0 : VisBufferAsync::newArrayId () const
772 : {
773 0 : return newArrayId_p;
774 : }
775 :
776 : Bool
777 0 : VisBufferAsync::newFieldId () const
778 : {
779 0 : return newFieldId_p;
780 : }
781 :
782 : Bool
783 0 : VisBufferAsync::newSpectralWindow () const
784 : {
785 0 : return newSpectralWindow_p;
786 : }
787 :
788 :
789 : Bool
790 0 : VisBufferAsync::newMS() const
791 : {
792 0 : return newMS_p;
793 : }
794 :
795 :
796 : Int
797 0 : VisBufferAsync::numberAnt () const
798 : {
799 0 : return nAntennas_p;
800 : }
801 :
802 : Int
803 0 : VisBufferAsync::numberCoh () const
804 : {
805 0 : return nCoh_p;
806 : }
807 :
808 :
809 : Vector<Float>
810 0 : VisBufferAsync::parang(Double time) const
811 : {
812 0 : if (time != parangCachedTime_p){
813 :
814 0 : parangCachedTime_p = time;
815 :
816 0 : parangCached_p = ROVisibilityIterator::parangCalculate (time, * msd_p, nAntennas_p, mEpoch_p);
817 : }
818 :
819 0 : return parangCached_p;
820 : }
821 :
822 : Float
823 0 : VisBufferAsync::parang0(Double time) const
824 : {
825 : //MSDerivedValues msd;
826 : //msd.setMeasurementSet (* measurementSet_p);
827 :
828 0 : Float parang0 = ROVisibilityIterator::parang0Calculate (time, * msd_p, mEpoch_p);
829 :
830 0 : return parang0;
831 : }
832 :
833 : Int
834 0 : VisBufferAsync::polarizationId() const
835 : {
836 0 : return polarizationId_p;
837 : }
838 :
839 :
840 :
841 : //Vector<uInt>&
842 : //VisBufferAsync::rowIds()
843 : //{
844 : // return rowIds_p;
845 : //}
846 :
847 : //void
848 : //VisBufferAsync::setDataDescriptionId (Int id)
849 : //{
850 : // dataDescriptionId_p = id;
851 : //}
852 :
853 : void
854 0 : VisBufferAsync::setCorrectedVisCube(Complex c)
855 : {
856 0 : correctedVisCube_p.resize(visibilityShape_p);
857 0 : correctedVisCube_p.set(c);
858 0 : correctedVisCubeOK_p=true;
859 0 : }
860 :
861 : void
862 0 : VisBufferAsync::setCorrectedVisCube (const Cube<Complex> & vis)
863 : {
864 0 : VisBuffer::setCorrectedVisCube (vis);
865 0 : }
866 :
867 :
868 : void
869 0 : VisBufferAsync::setModelVisCube (const Cube<Complex> & vis)
870 : {
871 0 : VisBuffer::setModelVisCube (vis);
872 0 : }
873 :
874 : void
875 0 : VisBufferAsync::setModelVisCube (const Vector<Float> & stokes)
876 : {
877 0 : VisBuffer::setModelVisCube (stokes);
878 0 : }
879 :
880 : void
881 0 : VisBufferAsync::setNRowChunk (Int nRowChunk)
882 : {
883 0 : nRowChunk_p = nRowChunk;
884 0 : }
885 :
886 :
887 : void
888 0 : VisBufferAsync::setFilling (Bool isFilling)
889 : {
890 0 : isFilling_p = isFilling;
891 0 : }
892 :
893 : void
894 0 : VisBufferAsync::setLsrInfo (const Block <Int> & channelGroupNumber,
895 : const Block <Int> & channelIncrement,
896 : const Block <Int> & channelStart,
897 : const Block <Int> & channelWidth,
898 : const MPosition & observatoryPosition,
899 : const MDirection & phaseCenter,
900 : Bool velocitySelection)
901 : {
902 0 : channelGroupNumber_p = channelGroupNumber;
903 0 : channelIncrement_p = channelIncrement;
904 0 : channelStart_p = channelStart;
905 0 : channelWidth_p = channelWidth;
906 0 : observatoryPosition_p = unsharedCopyPosition (observatoryPosition);
907 0 : phaseCenter_p = unsharedCopyDirection (phaseCenter);
908 0 : velSelection_p = velocitySelection;
909 0 : }
910 :
911 :
912 : void
913 0 : VisBufferAsync::setMeasurementSet (const MeasurementSet & ms)
914 : {
915 0 : measurementSet_p = & ms;
916 : //msd_p->setMeasurementSet (ms);
917 0 : }
918 :
919 : void
920 0 : VisBufferAsync::setMeasurementSetId (Int id, Bool isNew)
921 : {
922 0 : oldMSId_p = id;
923 0 : msOK_p = true;
924 0 : newMS_p = isNew;
925 0 : }
926 :
927 :
928 : void
929 0 : VisBufferAsync::setMEpoch (const MEpoch & mEpoch)
930 : {
931 0 : mEpoch_p = unsharedCopyEpoch (mEpoch);
932 0 : }
933 :
934 : void
935 0 : VisBufferAsync::setModelVisCube(Complex c)
936 : {
937 0 : modelVisCube_p.resize(visibilityShape_p);
938 0 : modelVisCube_p.set(c);
939 0 : modelVisCubeOK_p=true;
940 0 : }
941 :
942 : void
943 0 : VisBufferAsync::setMSD (const MSDerivedValues & msd)
944 : {
945 0 : * msd_p = msd;
946 :
947 0 : msd_p->setEpoch (mEpoch_p);
948 :
949 : // set antennas
950 :
951 0 : const Vector<MPosition> & antennaPositions = msd.getAntennaPositions();
952 0 : Vector<MPosition> unsharedAntennaPositions (antennaPositions.nelements());
953 :
954 0 : for (Vector<MPosition>::const_iterator ap = antennaPositions.begin();
955 0 : ap != antennaPositions.end();
956 : ap ++){
957 :
958 0 : unsharedAntennaPositions = unsharedCopyPosition (* ap);
959 : }
960 :
961 0 : msd_p->setAntennaPositions (unsharedAntennaPositions);
962 :
963 0 : msd_p->setObservatoryPosition (observatoryPosition_p);
964 :
965 0 : msd_p->setFieldCenter (phaseCenter_p);
966 :
967 0 : msd_p->setVelocityFrame (msd.getRadialVelocityType ());
968 0 : }
969 :
970 :
971 : void
972 0 : VisBufferAsync::setNAntennas (Int nAntennas)
973 : {
974 0 : nAntennas_p = nAntennas;
975 0 : }
976 :
977 : void
978 0 : VisBufferAsync::setNCoh (Int nCoh)
979 : {
980 0 : nCoh_p = nCoh;
981 0 : }
982 :
983 : void
984 0 : VisBufferAsync::setNewEntityFlags (bool newArrayId, bool newFieldId, bool newSpectralWindow)
985 : {
986 0 : newArrayId_p = newArrayId;
987 0 : newFieldId_p = newFieldId;
988 0 : newSpectralWindow_p = newSpectralWindow;
989 0 : }
990 :
991 : void
992 0 : VisBufferAsync::setNSpw (Int nSpw)
993 : {
994 0 : nSpw_p = nSpw;
995 0 : }
996 :
997 :
998 : void
999 0 : VisBufferAsync::setPolarizationId (Int pId)
1000 : {
1001 0 : polarizationId_p = pId;
1002 0 : }
1003 :
1004 : void
1005 0 : VisBufferAsync::setReceptor0Angle (const Vector<Float> & angles)
1006 : {
1007 0 : receptor0Angle_p = angles;
1008 0 : }
1009 :
1010 : void
1011 0 : VisBufferAsync::setRowIds (const Vector<rownr_t> & rowIds)
1012 : {
1013 0 : rowIds_p = rowIds;
1014 0 : }
1015 :
1016 : void
1017 0 : VisBufferAsync::setSelectedNVisibilityChannels (const Vector<Int> & nVisibilityChannels)
1018 : {
1019 0 : selectedNVisibilityChannels_p.assign (nVisibilityChannels);
1020 0 : }
1021 :
1022 : void
1023 0 : VisBufferAsync::setSelectedSpectralWindows (const Vector<Int> & spectralWindows)
1024 : {
1025 0 : selectedSpectralWindows_p.assign (spectralWindows);
1026 0 : }
1027 :
1028 :
1029 : void
1030 0 : VisBufferAsync::setTopoFreqs (const Vector<Double> & lsrFreq, const Vector<Double> & selFreq)
1031 : {
1032 0 : lsrFrequency_p.assign (lsrFreq);
1033 0 : selFreq_p.assign (selFreq);
1034 0 : }
1035 :
1036 : void
1037 0 : VisBufferAsync::setVisCube(Complex c)
1038 : {
1039 0 : visCube_p.resize(visibilityShape_p);
1040 0 : visCube_p.set(c);
1041 0 : visCubeOK_p=true;
1042 0 : }
1043 :
1044 : void
1045 0 : VisBufferAsync::setVisCube (const Cube<Complex>& vis)
1046 : {
1047 0 : VisBuffer::setVisCube (vis);
1048 0 : }
1049 :
1050 :
1051 : void
1052 0 : VisBufferAsync::setVisibilityShape (const IPosition & visibilityShape)
1053 : {
1054 0 : visibilityShape_p = visibilityShape;
1055 0 : }
1056 :
1057 : MDirection
1058 0 : VisBufferAsync::unsharedCopyDirection (const MDirection & direction)
1059 : {
1060 0 : return asyncio::unsharedCopyMeasure (direction, & MeasureHolder::asMDirection);
1061 : }
1062 :
1063 : void
1064 0 : VisBufferAsync::unsharedCopyDirectionVector (Vector<MDirection> & direction)
1065 : {
1066 : // The MDirection object consists of the actual direction a frame of reference
1067 : // object. The direction component follows copy semnatics while the frame of
1068 : // reference uses a counter pointer and is shared across multiple MDirections.
1069 : // This causes problems now that values are being shared across threads. Modify
1070 : // the direction vector so that the frame of reference object is only shared
1071 : // within this vector. N.B., this could cause a problem if there is comparison
1072 : // between the reference frames of the two direction. Each element doesn't get
1073 : // its own copy because the unsharing operation is klugy and somewhat compute
1074 : // intensive.
1075 :
1076 0 : int nElements = direction.shape () [0];
1077 :
1078 0 : if (nElements > 0){
1079 :
1080 : // Take the first reference frame object, make an unshared copy and provide it to
1081 : // any of the other direction components which use the same reference. If a
1082 : // direction uses a different reference give it its own unshared copy.
1083 :
1084 0 : MeasRef<MDirection> uncleanRef = direction[0].getRef ();
1085 0 : MDirection cleanDirection = unsharedCopyDirection (direction[0]);
1086 0 : MeasRef<MDirection> cleanRef = cleanDirection.getRef ();
1087 : // Since cleanRef uses a counted pointer to an underlying object
1088 : // the above construction does not cause a dangling pointer problem.
1089 :
1090 0 : for (int i = 0; i < nElements; i++){
1091 :
1092 : // If this element of the direction uses the same reference as the
1093 : // original, then just install a reference to our "clean" reference.
1094 : // N.B., the == comparasion just compares the pointer to the underlying
1095 : // reference frame object!
1096 :
1097 0 : if (uncleanRef == direction[i].getRef()){
1098 :
1099 0 : direction[i].set (cleanRef);
1100 : }
1101 : else {
1102 0 : direction[i] = unsharedCopyDirection (direction[i]);
1103 : }
1104 : }
1105 : }
1106 0 : }
1107 :
1108 : MEpoch
1109 0 : VisBufferAsync::unsharedCopyEpoch (const MEpoch & epoch)
1110 : {
1111 0 : return asyncio::unsharedCopyMeasure (epoch, & MeasureHolder::asMEpoch);
1112 : }
1113 :
1114 : MPosition
1115 0 : VisBufferAsync::unsharedCopyPosition (const MPosition & position)
1116 : {
1117 0 : return asyncio::unsharedCopyMeasure (position, & MeasureHolder::asMPosition);
1118 : }
1119 :
1120 : void
1121 0 : VisBufferAsync::updateCoordInfo(const VisBuffer * other, const Bool dirDepend)
1122 : {
1123 0 : clear ();
1124 0 : copyVector (other->antenna1_p, antenna1_p);
1125 0 : antenna1OK_p = true;
1126 0 : copyVector (other->antenna2_p, antenna2_p);
1127 0 : antenna2OK_p = true;
1128 0 : copyVector (other->time_p, time_p);
1129 0 : timeOK_p = true;
1130 0 : copyVector (other->frequency_p, frequency_p);
1131 0 : frequencyOK_p = true;
1132 0 : copyVector (other->feed1_p, feed1_p);
1133 0 : feed1OK_p = true;
1134 0 : copyVector (other->feed2_p, feed2_p);
1135 0 : feed2OK_p = true;
1136 0 : if(dirDepend){
1137 0 : copyVector (other->feed1_pa_p, feed1_pa_p);
1138 0 : feed1_paOK_p = true;
1139 0 : copyVector (other->feed2_pa_p, feed2_pa_p);
1140 0 : feed2_paOK_p = true;
1141 : //copyVector (direction1_p);
1142 : //copyVector (direction2_p);
1143 : }
1144 : else{
1145 0 : feed1_paOK_p=false;
1146 0 : feed2_paOK_p=false;
1147 0 : direction1OK_p=false;
1148 0 : direction2OK_p=false;
1149 : }
1150 0 : }
1151 :
1152 :
1153 :
1154 :
1155 : using namespace casacore;
1156 : } // end namespace casa
1157 :
1158 :
|
