Line data Source code
1 : #include "VisibilityIterator.h"
2 : #include "VisibilityIteratorImpl.h"
3 : #include "VisibilityIteratorImplAsync.h"
4 : #include <stdcasa/UtilJ.h>
5 : #include <casacore/casa/System/AipsrcValue.h>
6 :
7 : //#include <measures/Measures/MDoppler.h>
8 : //#include <measures/Measures/MRadialVelocity.h>
9 :
10 :
11 : #define CheckImplementationPointerR() Assert (readImpl_p != NULL);
12 : #define CheckImplementationPointerW() Assert (writeImpl_p != NULL);
13 :
14 : using namespace casacore;
15 : namespace casa {
16 :
17 : namespace asyncio {
18 :
19 : PrefetchColumns
20 0 : PrefetchColumns::prefetchColumnsAll ()
21 : {
22 : // Create the set of all columns
23 :
24 0 : PrefetchColumns pc;
25 :
26 0 : for (int i = 0; i < VisBufferComponents::N_VisBufferComponents; ++ i){
27 0 : pc.insert ((VisBufferComponents::EnumType) i);
28 : }
29 :
30 0 : return pc;
31 : }
32 :
33 : PrefetchColumns
34 0 : PrefetchColumns::prefetchAllColumnsExcept (Int firstColumn, ...)
35 : {
36 : // Build a set of Prefetch columns named except.
37 : // The last arg must be either negative or
38 : // greater than or equal to N_PrefetchColumnIds
39 :
40 : va_list vaList;
41 :
42 0 : va_start (vaList, firstColumn);
43 :
44 0 : int id = firstColumn;
45 0 : PrefetchColumns except;
46 :
47 0 : while (id >= 0 && id < VisBufferComponents::N_VisBufferComponents){
48 0 : except.insert ((VisBufferComponents::EnumType)id);
49 0 : id = va_arg (vaList, int);
50 : }
51 :
52 0 : va_end (vaList);
53 :
54 : // Get the set of all columns and then subtract off the
55 : // caller specified columns. Return the result
56 :
57 0 : PrefetchColumns allColumns = prefetchColumnsAll();
58 0 : PrefetchColumns result;
59 :
60 : set_difference (allColumns.begin(), allColumns.end(),
61 : except.begin(), except.end(),
62 0 : inserter (result, result.begin()));
63 :
64 0 : return result;
65 :
66 : }
67 :
68 : String
69 0 : PrefetchColumns::columnName (Int id)
70 : {
71 0 : assert (id >= 0 && id < VisBufferComponents::N_VisBufferComponents);
72 :
73 : // This method is called only occasionally for debuggin so at this time a
74 : // brute-force implmentation is acceptable.
75 :
76 0 : map<Int,String> names;
77 :
78 0 : names [VisBufferComponents::Ant1] = "Ant1";
79 0 : names [VisBufferComponents::Ant2] = "Ant2";
80 0 : names [VisBufferComponents::ArrayId] = "ArrayId";
81 0 : names [VisBufferComponents::Channel] = "Channel";
82 0 : names [VisBufferComponents::Cjones] = "Cjones";
83 0 : names [VisBufferComponents::CorrType] = "CorrType";
84 0 : names [VisBufferComponents::Corrected] = "Corrected";
85 0 : names [VisBufferComponents::CorrectedCube] = "CorrectedCube";
86 0 : names [VisBufferComponents::Direction1] = "Direction1";
87 0 : names [VisBufferComponents::Direction2] = "Direction2";
88 0 : names [VisBufferComponents::Exposure] = "Exposure";
89 0 : names [VisBufferComponents::Feed1] = "Feed1";
90 0 : names [VisBufferComponents::Feed1_pa] = "Feed1_pa";
91 0 : names [VisBufferComponents::Feed2] = "Feed2";
92 0 : names [VisBufferComponents::Feed2_pa] = "Feed2_pa";
93 0 : names [VisBufferComponents::FieldId] = "FieldId";
94 0 : names [VisBufferComponents::Flag] = "Flag";
95 0 : names [VisBufferComponents::FlagCategory] = "FlagCategory";
96 0 : names [VisBufferComponents::FlagCube] = "FlagCube";
97 0 : names [VisBufferComponents::FlagRow] = "FlagRow";
98 0 : names [VisBufferComponents::Freq] = "Freq";
99 0 : names [VisBufferComponents::ImagingWeight] = "ImagingWeight";
100 0 : names [VisBufferComponents::Model] = "Model";
101 0 : names [VisBufferComponents::ModelCube] = "ModelCube";
102 0 : names [VisBufferComponents::NChannel] = "NChannel";
103 0 : names [VisBufferComponents::NCorr] = "NCorr";
104 0 : names [VisBufferComponents::NRow] = "NRow";
105 0 : names [VisBufferComponents::ObservationId] = "ObservationId";
106 0 : names [VisBufferComponents::Observed] = "Observed";
107 0 : names [VisBufferComponents::ObservedCube] = "ObservedCube";
108 0 : names [VisBufferComponents::PhaseCenter] = "PhaseCenter";
109 0 : names [VisBufferComponents::PolFrame] = "PolFrame";
110 0 : names [VisBufferComponents::ProcessorId] = "ProcessorId";
111 0 : names [VisBufferComponents::Scan] = "Scan";
112 0 : names [VisBufferComponents::Sigma] = "Sigma";
113 0 : names [VisBufferComponents::SigmaMat] = "SigmaMat";
114 0 : names [VisBufferComponents::SpW] = "SpW";
115 0 : names [VisBufferComponents::StateId] = "StateId";
116 0 : names [VisBufferComponents::Time] = "Time";
117 0 : names [VisBufferComponents::TimeCentroid] = "TimeCentroid";
118 0 : names [VisBufferComponents::TimeInterval] = "TimeInterval";
119 0 : names [VisBufferComponents::Weight] = "Weight";
120 0 : names [VisBufferComponents::WeightMat] = "WeightMat";
121 0 : names [VisBufferComponents::WeightSpectrum] = "WeightSpectrum";
122 0 : names [VisBufferComponents::Uvw] = "Uvw";
123 0 : names [VisBufferComponents::UvwMat] = "UvwMat";
124 :
125 0 : return names [id];
126 : }
127 :
128 :
129 : PrefetchColumns
130 0 : PrefetchColumns::prefetchColumns (Int firstColumn, ...)
131 : {
132 : // Returns a set of Prefetch columns. The last arg must be either negative or
133 : // greater than or equal to N_PrefetchColumnIds
134 :
135 : va_list vaList;
136 :
137 0 : va_start (vaList, firstColumn);
138 :
139 0 : Int id = firstColumn;
140 0 : PrefetchColumns pc;
141 :
142 0 : while (id >= 0 && id < VisBufferComponents::N_VisBufferComponents){
143 0 : pc.insert ((VisBufferComponents::EnumType) id);
144 0 : id = va_arg (vaList, Int);
145 : }
146 :
147 0 : va_end (vaList);
148 :
149 0 : return pc;
150 : }
151 : };
152 :
153 :
154 0 : ROVisibilityIterator::ROVisibilityIterator ()
155 0 : : readImpl_p (NULL)
156 0 : {}
157 :
158 88 : ROVisibilityIterator::ROVisibilityIterator (const MeasurementSet& ms,
159 : const Block<Int>& sortColumns,
160 : Double timeInterval,
161 88 : const Factory & factory)
162 : {
163 88 : construct (NULL, Block<MeasurementSet> (1, ms), sortColumns, true,
164 : timeInterval, false, factory);
165 88 : }
166 :
167 0 : ROVisibilityIterator::ROVisibilityIterator (const MeasurementSet& ms,
168 : const Block<Int>& sortColumns,
169 : const Bool addDefaultSortCols,
170 0 : Double timeInterval)
171 : {
172 0 : construct (NULL, Block<MeasurementSet> (1, ms), sortColumns, addDefaultSortCols,
173 0 : timeInterval, false, Factory ());
174 0 : }
175 :
176 :
177 0 : ROVisibilityIterator::ROVisibilityIterator (const Block<MeasurementSet>& mss,
178 : const Block<Int>& sortColumns,
179 0 : Double timeInterval)
180 : {
181 0 : construct (NULL, mss, sortColumns, true, timeInterval, false, Factory ());
182 0 : }
183 :
184 0 : ROVisibilityIterator::ROVisibilityIterator (const Block<MeasurementSet>& mss,
185 : const Block<Int>& sortColumns,
186 : const Bool addDefaultSortCols,
187 0 : Double timeInterval)
188 : {
189 0 : construct (NULL, mss, sortColumns, addDefaultSortCols, timeInterval, false, Factory());
190 0 : }
191 :
192 0 : ROVisibilityIterator::ROVisibilityIterator(const asyncio::PrefetchColumns * prefetchColumns,
193 : const MeasurementSet& ms,
194 : const Block<Int>& sortColumns,
195 : const Bool addDefaultSortCols,
196 0 : Double timeInterval)
197 : {
198 0 : construct (prefetchColumns, Block<MeasurementSet> (1, ms), sortColumns, addDefaultSortCols,
199 0 : timeInterval, false, Factory ());
200 0 : }
201 :
202 0 : ROVisibilityIterator::ROVisibilityIterator (const asyncio::PrefetchColumns * prefetchColumns,
203 : const Block<MeasurementSet>& mss,
204 : const Block<Int>& sortColumns,
205 : const Bool addDefaultSortCols,
206 0 : Double timeInterval)
207 : {
208 0 : construct (prefetchColumns, mss, sortColumns, addDefaultSortCols, timeInterval, false, Factory());
209 0 : }
210 :
211 :
212 :
213 :
214 1712 : ROVisibilityIterator::ROVisibilityIterator (const asyncio::PrefetchColumns * prefetchColumns,
215 : const Block<MeasurementSet>& mss,
216 : const Block<Int>& sortColumns,
217 : const Bool addDefaultSortCols,
218 : Double timeInterval,
219 1712 : Bool writable)
220 : {
221 1712 : construct (prefetchColumns, mss, sortColumns, addDefaultSortCols, timeInterval, writable, Factory());
222 1712 : }
223 :
224 :
225 0 : ROVisibilityIterator::ROVisibilityIterator (const asyncio::PrefetchColumns * prefetchColumns,
226 0 : const ROVisibilityIterator & other)
227 : {
228 : // For potentially creating an asynchronous ROVI from a synchronous one
229 :
230 0 : Bool createAsAsynchronous = prefetchColumns != NULL && isAsynchronousIoEnabled ();
231 :
232 0 : if (createAsAsynchronous){
233 :
234 0 : Bool writable = dynamic_cast <const VisibilityIterator *> (& other) != NULL;
235 :
236 0 : readImpl_p = new ViReadImplAsync (* prefetchColumns, * other.readImpl_p, writable);
237 : }
238 : else{
239 0 : readImpl_p = new VisibilityIteratorReadImpl (* other.readImpl_p, this);
240 : }
241 0 : }
242 :
243 0 : ROVisibilityIterator::ROVisibilityIterator (const ROVisibilityIterator & other)
244 : {
245 0 : if (other.readImpl_p == NULL){
246 0 : readImpl_p = NULL;
247 : }
248 : else {
249 0 : readImpl_p = other.readImpl_p -> clone(this);
250 : }
251 0 : }
252 :
253 :
254 3600 : ROVisibilityIterator::~ROVisibilityIterator ()
255 : {
256 1800 : delete readImpl_p;
257 1800 : }
258 :
259 : void
260 1800 : ROVisibilityIterator::construct (const asyncio::PrefetchColumns * prefetchColumns,
261 : const Block<MeasurementSet>& mss,
262 : const Block<Int>& sortColumns,
263 : const Bool addDefaultSortCols,
264 : Double timeInterval,
265 : Bool writable,
266 : const Factory & factory)
267 : {
268 1800 : readImpl_p = factory (prefetchColumns, mss, sortColumns, addDefaultSortCols, timeInterval);
269 :
270 1800 : if (readImpl_p == NULL) {
271 :
272 : // Factory didn't create the read implementation so decide whether to create a
273 : // synchronous or asynchronous read implementation.
274 :
275 1797 : Bool createAsAsynchronous = prefetchColumns != NULL && isAsynchronousIoEnabled ();
276 :
277 1797 : if (createAsAsynchronous){
278 0 : readImpl_p = new ViReadImplAsync (mss, * prefetchColumns, sortColumns,
279 0 : addDefaultSortCols, timeInterval, writable);
280 : }
281 : else{
282 1797 : readImpl_p = new VisibilityIteratorReadImpl (this, mss, sortColumns,
283 1797 : addDefaultSortCols, timeInterval);
284 : }
285 : }
286 :
287 1800 : if (! writable){
288 88 : readImpl_p->originChunks();
289 : }
290 1800 : }
291 :
292 : ROVisibilityIterator &
293 0 : ROVisibilityIterator::operator= (const ROVisibilityIterator &other)
294 : {
295 : // Kill off the current read implementation
296 :
297 0 : if (readImpl_p != NULL){
298 0 : delete readImpl_p;
299 0 : readImpl_p = NULL;
300 : }
301 :
302 : // If the other's read implementation is not null then
303 : // put a clone of it into this object's read implementation.
304 :
305 0 : if (other.readImpl_p != NULL){
306 :
307 0 : readImpl_p = other.readImpl_p->clone (this);
308 : }
309 0 : return * this;
310 : }
311 :
312 : ROVisibilityIterator &
313 6568 : ROVisibilityIterator::operator++ (int)
314 : {
315 6568 : advance ();
316 :
317 6568 : return * this;
318 : }
319 :
320 : ROVisibilityIterator &
321 0 : ROVisibilityIterator::operator++ ()
322 : {
323 0 : advance ();
324 :
325 0 : return * this;
326 : }
327 :
328 : void
329 39149 : ROVisibilityIterator::advance ()
330 : {
331 39149 : CheckImplementationPointerR ();
332 39149 : readImpl_p->advance ();
333 39149 : }
334 :
335 : Bool
336 0 : ROVisibilityIterator::allBeamOffsetsZero () const
337 : {
338 0 : CheckImplementationPointerR ();
339 0 : return readImpl_p->allBeamOffsetsZero ();
340 : }
341 :
342 : void
343 350 : ROVisibilityIterator::allSelectedSpectralWindows (Vector<Int>& spws, Vector<Int>& nvischan)
344 : {
345 350 : CheckImplementationPointerR ();
346 350 : readImpl_p->allSelectedSpectralWindows (spws, nvischan);
347 350 : }
348 :
349 : Vector<Int>&
350 21375 : ROVisibilityIterator::antenna1 (Vector<Int>& ant1) const
351 : {
352 21375 : CheckImplementationPointerR ();
353 21375 : return readImpl_p->antenna1 (ant1);
354 : }
355 :
356 : Vector<Int>&
357 18872 : ROVisibilityIterator::antenna2 (Vector<Int>& ant2) const
358 : {
359 18872 : CheckImplementationPointerR ();
360 18872 : return readImpl_p->antenna2 (ant2);
361 : }
362 :
363 : const Vector<String>&
364 0 : ROVisibilityIterator::antennaMounts () const
365 : {
366 0 : CheckImplementationPointerR ();
367 0 : return readImpl_p->antennaMounts ();
368 : }
369 :
370 0 : const Block<Int>& ROVisibilityIterator::getSortColumns() const
371 : {
372 0 : CheckImplementationPointerR();
373 0 : return readImpl_p->getSortColumns();
374 : }
375 :
376 : const MeasurementSet &
377 0 : ROVisibilityIterator::getMeasurementSet () const
378 : {
379 0 : CheckImplementationPointerR ();
380 0 : return readImpl_p->getMeasurementSet ();
381 : }
382 :
383 :
384 : const MeasurementSet&
385 6579 : ROVisibilityIterator::ms () const
386 : {
387 6579 : CheckImplementationPointerR ();
388 6579 : return readImpl_p->ms ();
389 : }
390 :
391 : Int
392 629 : ROVisibilityIterator::arrayId () const
393 : {
394 629 : CheckImplementationPointerR ();
395 629 : return readImpl_p->arrayId ();
396 : }
397 :
398 :
399 : void
400 2746 : ROVisibilityIterator::attachColumns (const Table &t)
401 : {
402 2746 : CheckImplementationPointerR ();
403 2746 : readImpl_p->attachColumns (t);
404 2746 : }
405 :
406 : const Table
407 0 : ROVisibilityIterator::attachTable () const
408 : {
409 0 : CheckImplementationPointerR ();
410 0 : return readImpl_p->attachTable ();
411 : }
412 :
413 : void
414 827 : ROVisibilityIterator::attachVisBuffer (VisBuffer& vb)
415 : {
416 827 : CheckImplementationPointerR ();
417 827 : readImpl_p->attachVisBuffer (vb);
418 827 : }
419 :
420 : Vector<MDirection>
421 168 : ROVisibilityIterator::azel (Double time) const
422 : {
423 168 : CheckImplementationPointerR ();
424 168 : return readImpl_p->azel (time);
425 : }
426 :
427 : MDirection
428 0 : ROVisibilityIterator::azel0 (Double time) const
429 : {
430 0 : CheckImplementationPointerR ();
431 0 : return readImpl_p->azel0 (time);
432 : }
433 :
434 : void
435 0 : ROVisibilityIterator::azelCalculate (Double time, MSDerivedValues & msd, Vector<MDirection> & azel,
436 : Int nAnt, const MEpoch & mEpoch0)
437 : {
438 0 : VisibilityIteratorReadImpl::azelCalculate (time, msd, azel, nAnt, mEpoch0);
439 0 : }
440 :
441 : void
442 0 : ROVisibilityIterator::azel0Calculate (Double time, MSDerivedValues & msd,
443 : MDirection & azel0, const MEpoch & mEpoch0)
444 : {
445 0 : VisibilityIteratorReadImpl::azel0Calculate (time, msd, azel0, mEpoch0);
446 0 : }
447 :
448 : Vector<Int>&
449 18933 : ROVisibilityIterator::channel (Vector<Int>& chan) const
450 : {
451 18933 : CheckImplementationPointerR ();
452 18933 : return readImpl_p->channel (chan);
453 : }
454 :
455 : Int
456 0 : ROVisibilityIterator::channelGroupSize () const
457 : {
458 0 : CheckImplementationPointerR ();
459 0 : return readImpl_p->channelGroupSize ();
460 : }
461 :
462 : Int
463 0 : ROVisibilityIterator::channelIndex () const
464 : {
465 0 : CheckImplementationPointerR ();
466 0 : return readImpl_p->channelIndex ();
467 : }
468 :
469 : Vector<SquareMatrix<Complex,2> >&
470 0 : ROVisibilityIterator::CJones (Vector<SquareMatrix<Complex,2> >& cjones) const
471 : {
472 0 : CheckImplementationPointerR ();
473 0 : return readImpl_p->CJones (cjones);
474 : }
475 :
476 :
477 : Vector<Int>&
478 19637 : ROVisibilityIterator::corrType (Vector<Int>& corrTypes) const
479 : {
480 19637 : CheckImplementationPointerR ();
481 19637 : return readImpl_p->corrType (corrTypes);
482 : }
483 :
484 : Int
485 264 : ROVisibilityIterator::dataDescriptionId () const
486 : {
487 264 : CheckImplementationPointerR ();
488 264 : return readImpl_p->dataDescriptionId ();
489 : }
490 :
491 : void
492 827 : ROVisibilityIterator::detachVisBuffer (VisBuffer& vb)
493 : {
494 827 : CheckImplementationPointerR ();
495 827 : readImpl_p->detachVisBuffer (vb);
496 827 : }
497 :
498 : void
499 0 : ROVisibilityIterator::doChannelSelection ()
500 : {
501 0 : CheckImplementationPointerR ();
502 0 : readImpl_p->doChannelSelection ();
503 0 : }
504 :
505 : Bool
506 0 : ROVisibilityIterator::existsColumn (VisBufferComponents::EnumType id) const
507 : {
508 0 : CheckImplementationPointerR ();
509 :
510 0 : return readImpl_p->existsColumn (id);
511 : }
512 :
513 0 : Bool ROVisibilityIterator::existsFlagCategory() const
514 : {
515 0 : CheckImplementationPointerR ();
516 0 : return readImpl_p->existsFlagCategory();
517 : }
518 :
519 : Bool
520 110 : ROVisibilityIterator::existsWeightSpectrum () const
521 : {
522 110 : CheckImplementationPointerR ();
523 110 : return readImpl_p->existsWeightSpectrum ();
524 : }
525 :
526 : Vector<Double>&
527 0 : ROVisibilityIterator::exposure (Vector<Double>& expo) const
528 : {
529 0 : CheckImplementationPointerR ();
530 0 : return readImpl_p->exposure (expo);
531 : }
532 :
533 : Vector<Float>
534 0 : ROVisibilityIterator::feed_paCalculate(Double time, MSDerivedValues & msd,
535 : Int nAntennas, const MEpoch & mEpoch0,
536 : const Vector<Float> & receptor0Angle)
537 : {
538 0 : return VisibilityIteratorReadImpl::feed_paCalculate (time, msd, nAntennas, mEpoch0, receptor0Angle);
539 : }
540 :
541 :
542 :
543 : Vector<Int>&
544 379 : ROVisibilityIterator::feed1 (Vector<Int>& fd1) const
545 : {
546 379 : CheckImplementationPointerR ();
547 379 : return readImpl_p->feed1 (fd1);
548 : }
549 :
550 : Vector<Int>&
551 379 : ROVisibilityIterator::feed2 (Vector<Int>& fd2) const
552 : {
553 379 : CheckImplementationPointerR ();
554 379 : return readImpl_p->feed2 (fd2);
555 : }
556 :
557 : Vector<Float>
558 584678 : ROVisibilityIterator::feed_pa (Double time) const
559 : {
560 584678 : CheckImplementationPointerR ();
561 584678 : return readImpl_p->feed_pa (time);
562 : }
563 :
564 : Int
565 23872 : ROVisibilityIterator::fieldId () const
566 : {
567 23872 : CheckImplementationPointerR ();
568 23872 : return readImpl_p->fieldId ();
569 : }
570 :
571 : String
572 4 : ROVisibilityIterator::fieldName () const
573 : {
574 4 : CheckImplementationPointerR ();
575 4 : return readImpl_p->fieldName ();
576 : }
577 :
578 : Cube<Bool>&
579 7376 : ROVisibilityIterator::flag (Cube<Bool>& flags) const
580 : {
581 7376 : CheckImplementationPointerR ();
582 7376 : return readImpl_p->flag (flags);
583 : }
584 :
585 : Matrix<Bool>&
586 15491 : ROVisibilityIterator::flag (Matrix<Bool>& flags) const
587 : {
588 15491 : CheckImplementationPointerR ();
589 15491 : return readImpl_p->flag (flags);
590 : }
591 :
592 : Array<Bool>&
593 0 : ROVisibilityIterator::flagCategory (Array<Bool>& flagCategories) const
594 : {
595 0 : CheckImplementationPointerR ();
596 0 : return readImpl_p->flagCategory (flagCategories);
597 : }
598 :
599 : Vector<Bool>&
600 15969 : ROVisibilityIterator::flagRow (Vector<Bool>& rowflags) const
601 : {
602 15969 : CheckImplementationPointerR ();
603 15969 : return readImpl_p->flagRow (rowflags);
604 : }
605 :
606 : Cube<Float>&
607 0 : ROVisibilityIterator::floatData (Cube<Float>& fcube) const
608 : {
609 0 : CheckImplementationPointerR ();
610 0 : return readImpl_p->floatData (fcube);
611 : }
612 :
613 : Vector<Double>&
614 24188 : ROVisibilityIterator::frequency (Vector<Double>& freq) const
615 : {
616 24188 : CheckImplementationPointerR ();
617 24188 : return readImpl_p->frequency (freq);
618 : }
619 :
620 : const Cube<RigidVector<Double, 2> >&
621 0 : ROVisibilityIterator::getBeamOffsets () const
622 : {
623 0 : CheckImplementationPointerR ();
624 0 : return readImpl_p->getBeamOffsets ();
625 : }
626 :
627 : //ArrayColumn
628 : //<Double> &
629 : //ROVisibilityIterator::getChannelFrequency () const
630 : //{
631 : // CheckImplementationPointerR ();
632 : // return readImpl_p->getChannelFrequency ();
633 : //}
634 : //
635 : //Block<Int>
636 : //ROVisibilityIterator::getChannelGroupNumber () const
637 : //{
638 : // CheckImplementationPointerR ();
639 : // return readImpl_p->getChannelGroupNumber ();
640 : //}
641 : //
642 : //Block<Int>
643 : //ROVisibilityIterator::getChannelIncrement () const
644 : //{
645 : // CheckImplementationPointerR ();
646 : // return readImpl_p->getChannelIncrement ();
647 : //}
648 :
649 : void
650 130 : ROVisibilityIterator::getChannelSelection (Block< Vector<Int> >& blockNGroup,
651 : Block< Vector<Int> >& blockStart,
652 : Block< Vector<Int> >& blockWidth,
653 : Block< Vector<Int> >& blockIncr,
654 : Block< Vector<Int> >& blockSpw)
655 : {
656 130 : CheckImplementationPointerR ();
657 130 : readImpl_p->getChannelSelection (blockNGroup, blockStart, blockWidth, blockIncr, blockSpw);
658 130 : }
659 :
660 : //Block<Int>
661 : //ROVisibilityIterator::getChannelStart () const
662 : //{
663 : // CheckImplementationPointerR ();
664 : // return readImpl_p->getChannelStart ();
665 : //}
666 : //
667 : //Block<Int>
668 : //ROVisibilityIterator::getChannelWidth () const
669 : //{
670 : // CheckImplementationPointerR ();
671 : // return readImpl_p->getChannelWidth ();
672 : //}
673 :
674 : void
675 0 : ROVisibilityIterator::getCol (const ScalarColumn<Bool> &column, Vector<Bool> &array, Bool resize ) const
676 : {
677 0 : CheckImplementationPointerR ();
678 0 : readImpl_p->getCol (column, array, resize);
679 0 : }
680 :
681 : void
682 0 : ROVisibilityIterator::getCol (const ScalarColumn<Int> &column, Vector<Int> &array, Bool resize ) const
683 : {
684 0 : CheckImplementationPointerR ();
685 0 : readImpl_p->getCol (column, array, resize);
686 0 : }
687 :
688 : void
689 0 : ROVisibilityIterator::getCol (const ScalarColumn<Double> &column, Vector<Double> &array, Bool resize ) const
690 : {
691 0 : CheckImplementationPointerR ();
692 0 : readImpl_p->getCol (column, array, resize);
693 0 : }
694 :
695 : void
696 0 : ROVisibilityIterator::getCol (const ArrayColumn<Bool> &column, Array<Bool> &array, Bool resize ) const
697 : {
698 0 : CheckImplementationPointerR ();
699 0 : readImpl_p->getCol (column, array, resize);
700 0 : }
701 :
702 : void
703 0 : ROVisibilityIterator::getCol (const ArrayColumn<Float> &column, Array<Float> &array, Bool resize ) const
704 : {
705 0 : CheckImplementationPointerR ();
706 0 : readImpl_p->getCol (column, array, resize);
707 0 : }
708 :
709 : void
710 0 : ROVisibilityIterator::getCol (const ArrayColumn<Double> &column, Array<Double> &array, Bool resize ) const
711 : {
712 0 : CheckImplementationPointerR ();
713 0 : readImpl_p->getCol (column, array, resize);
714 0 : }
715 :
716 : void
717 0 : ROVisibilityIterator::getCol (const ArrayColumn<Complex> &column, Array<Complex> &array, Bool resize ) const
718 : {
719 0 : CheckImplementationPointerR ();
720 0 : readImpl_p->getCol (column, array, resize);
721 0 : }
722 :
723 : void
724 0 : ROVisibilityIterator::getCol (const ArrayColumn<Bool> &column, const Slicer &slicer, Array<Bool> &array, Bool resize ) const
725 : {
726 0 : CheckImplementationPointerR ();
727 0 : readImpl_p->getCol (column, slicer, array, resize);
728 0 : }
729 :
730 : void
731 0 : ROVisibilityIterator::getCol (const ArrayColumn<Float> &column, const Slicer &slicer, Array<Float> &array, Bool resize ) const
732 : {
733 0 : CheckImplementationPointerR ();
734 0 : readImpl_p->getCol (column, slicer, array, resize);
735 0 : }
736 :
737 : void
738 0 : ROVisibilityIterator::getCol (const ArrayColumn<Complex> &column, const Slicer &slicer, Array<Complex> &array, Bool resize ) const
739 : {
740 0 : CheckImplementationPointerR ();
741 0 : readImpl_p->getCol (column, slicer, array, resize);
742 0 : }
743 :
744 : void
745 0 : ROVisibilityIterator::getDataColumn (DataColumn whichOne, const Slicer& slicer,
746 : Cube<Complex>& data) const
747 : {
748 0 : CheckImplementationPointerR ();
749 0 : readImpl_p->getDataColumn (whichOne, slicer, data);
750 0 : }
751 :
752 : void
753 0 : ROVisibilityIterator::getDataColumn (DataColumn whichOne, Cube<Complex>& data) const
754 : {
755 0 : CheckImplementationPointerR ();
756 0 : readImpl_p->getDataColumn (whichOne, data);
757 0 : }
758 :
759 : Int
760 0 : ROVisibilityIterator::getDataDescriptionId () const
761 : {
762 0 : CheckImplementationPointerR ();
763 0 : return readImpl_p->getDataDescriptionId ();
764 : }
765 :
766 : void
767 0 : ROVisibilityIterator::getFloatDataColumn (const Slicer& slicer, Cube<Float>& data) const
768 : {
769 0 : CheckImplementationPointerR ();
770 0 : readImpl_p->getFloatDataColumn (slicer, data);
771 0 : }
772 :
773 : void
774 0 : ROVisibilityIterator::getFloatDataColumn (Cube<Float>& data) const
775 : {
776 0 : CheckImplementationPointerR ();
777 0 : readImpl_p->getFloatDataColumn (data);
778 0 : }
779 :
780 : //void
781 : //ROVisibilityIterator::getInterpolatedFloatDataFlagWeight () const
782 : //{
783 : // CheckImplementationPointerR ();
784 : // readImpl_p->getInterpolatedFloatDataFlagWeight ();
785 : //}
786 :
787 : //void
788 : //ROVisibilityIterator::getInterpolatedVisFlagWeight (DataColumn whichOne) const
789 : //{
790 : // CheckImplementationPointerR ();
791 : // readImpl_p->getInterpolatedVisFlagWeight (whichOne);
792 : //}
793 :
794 : void
795 0 : ROVisibilityIterator::getLsrInfo (Block<Int> & channelGroupNumber,
796 : Block<Int> & channelIncrement,
797 : Block<Int> & channelStart,
798 : Block<Int> & channelWidth,
799 : MPosition & observatoryPositon,
800 : MDirection & phaseCenter,
801 : Bool & velocitySelection) const
802 : {
803 0 : CheckImplementationPointerR ();
804 0 : readImpl_p->getLsrInfo (channelGroupNumber, channelIncrement, channelStart, channelWidth, observatoryPositon, phaseCenter, velocitySelection);
805 0 : }
806 :
807 : MEpoch
808 0 : ROVisibilityIterator::getEpoch () const
809 : {
810 0 : CheckImplementationPointerR ();
811 0 : return readImpl_p->getEpoch ();
812 : }
813 :
814 : const MSDerivedValues &
815 0 : ROVisibilityIterator::getMSD () const
816 : {
817 0 : CheckImplementationPointerR ();
818 0 : return readImpl_p->getMSD ();
819 : }
820 :
821 : Int
822 0 : ROVisibilityIterator::getMeasurementSetId () const
823 : {
824 0 : CheckImplementationPointerR ();
825 0 : return readImpl_p->getMeasurementSetId ();
826 : }
827 :
828 : vector<MeasurementSet>
829 0 : ROVisibilityIterator::getMeasurementSets () const
830 : {
831 0 : CheckImplementationPointerR ();
832 0 : return readImpl_p->getMeasurementSets ();
833 : }
834 :
835 : Int
836 0 : ROVisibilityIterator::getNAntennas () const
837 : {
838 0 : CheckImplementationPointerR ();
839 0 : return readImpl_p->getNAntennas ();
840 : }
841 :
842 : //MFrequency::Types
843 : //ROVisibilityIterator::getObservatoryFrequencyType () const
844 : //{
845 : // CheckImplementationPointerR ();
846 : // return readImpl_p->getObservatoryFrequencyType ();
847 : //}
848 :
849 : //MPosition
850 : //ROVisibilityIterator::getObservatoryPosition () const
851 : //{
852 : // CheckImplementationPointerR ();
853 : //
854 : // return readImpl_p->getObservatoryPosition ();
855 : //}
856 :
857 : //MDirection
858 : //ROVisibilityIterator::getPhaseCenter () const
859 : //{
860 : // CheckImplementationPointerR ();
861 : //
862 : // return readImpl_p->getPhaseCenter ();
863 : //}
864 :
865 : VisibilityIteratorReadImpl *
866 136608 : ROVisibilityIterator::getReadImpl () const
867 : {
868 136608 : return readImpl_p;
869 : }
870 :
871 : void
872 0 : ROVisibilityIterator::getSpwInFreqRange (Block<Vector<Int> >& spw,
873 : Block<Vector<Int> >& start,
874 : Block<Vector<Int> >& nchan,
875 : Double freqStart,
876 : Double freqEnd,
877 : Double freqStep,
878 : MFrequency::Types freqFrame)
879 : {
880 0 : CheckImplementationPointerR ();
881 0 : readImpl_p->getSpwInFreqRange (spw, start, nchan, freqStart, freqEnd, freqStep, freqFrame);
882 0 : }
883 :
884 14 : void ROVisibilityIterator::getFreqInSpwRange(Double& freqStart, Double& freqEnd, MFrequency::Types freqframe){
885 14 : CheckImplementationPointerR ();
886 14 : readImpl_p->getFreqInSpwRange(freqStart, freqEnd, freqframe);
887 14 : }
888 :
889 :
890 : SubChunkPair
891 0 : ROVisibilityIterator::getSubchunkId () const
892 : {
893 0 : CheckImplementationPointerR ();
894 0 : return readImpl_p->getSubchunkId ();
895 : }
896 :
897 : void
898 0 : ROVisibilityIterator::getTopoFreqs ()
899 : {
900 0 : CheckImplementationPointerR ();
901 0 : readImpl_p->getTopoFreqs ();
902 0 : }
903 :
904 : void
905 0 : ROVisibilityIterator::getTopoFreqs (Vector<Double> & lsrFreq, Vector<Double> & selFreq)
906 : {
907 0 : CheckImplementationPointerR ();
908 0 : readImpl_p->getTopoFreqs (lsrFreq, selFreq);
909 0 : }
910 :
911 : VisBuffer *
912 1448 : ROVisibilityIterator::getVisBuffer ()
913 : {
914 1448 : CheckImplementationPointerR ();
915 1448 : return readImpl_p->getVisBuffer ();
916 : }
917 :
918 : Double
919 0 : ROVisibilityIterator::hourang (Double time) const
920 : {
921 0 : CheckImplementationPointerR ();
922 0 : return readImpl_p->hourang (time);
923 : }
924 :
925 : Double
926 0 : ROVisibilityIterator::hourangCalculate (Double time, MSDerivedValues & msd, const MEpoch & mEpoch0)
927 : {
928 0 : return VisibilityIteratorReadImpl::hourangCalculate (time, msd, mEpoch0);
929 : }
930 :
931 : //Matrix<Float>&
932 : //ROVisibilityIterator::imagingWeight (Matrix<Float>& wt) const
933 : //{
934 : // CheckImplementationPointerR ();
935 : // return readImpl_p->imagingWeight (wt);
936 : //}
937 :
938 : const VisImagingWeight &
939 263 : ROVisibilityIterator::getImagingWeightGenerator () const
940 : {
941 263 : CheckImplementationPointerR ();
942 263 : return readImpl_p->getImagingWeightGenerator ();
943 : }
944 :
945 :
946 : //Bool
947 : //ROVisibilityIterator::isAsyncEnabled () const
948 : //{
949 : // CheckImplementationPointerR ();
950 : //
951 : // return readImpl_p->isAsyncEnabled ();
952 : //}
953 :
954 :
955 : Bool
956 2288 : ROVisibilityIterator::isAsynchronous () const
957 : {
958 2288 : Bool isAsync = readImpl_p != NULL && dynamic_cast<const ViReadImplAsync *> (readImpl_p) != NULL;
959 :
960 2288 : return isAsync;
961 : }
962 :
963 :
964 : Bool
965 0 : ROVisibilityIterator::isAsynchronousIoEnabled()
966 : {
967 : // Determines whether asynchronous I/O is enabled by looking for the
968 : // expected AipsRc value. If not found then async i/o is disabled.
969 :
970 : Bool isEnabled;
971 0 : AipsrcValue<Bool>::find (isEnabled, getAsyncRcBase () + ".enabled", false);
972 :
973 0 : return isEnabled;
974 : }
975 :
976 : Bool
977 0 : ROVisibilityIterator::isInSelectedSPW (const Int& spw)
978 : {
979 0 : CheckImplementationPointerR ();
980 0 : return readImpl_p->isInSelectedSPW (spw);
981 : }
982 :
983 : Bool
984 0 : ROVisibilityIterator::isWritable () const
985 : {
986 0 : CheckImplementationPointerR ();
987 0 : return readImpl_p->isWritable ();
988 : }
989 :
990 : Vector<Double>&
991 0 : ROVisibilityIterator::lsrFrequency (Vector<Double>& freq) const
992 : {
993 0 : CheckImplementationPointerR ();
994 0 : return readImpl_p->lsrFrequency (freq);
995 : }
996 :
997 : void
998 1841 : ROVisibilityIterator::lsrFrequency (const Int& spw, Vector<Double>& freq, Bool& convert, const Bool ignoreconv)
999 : {
1000 1841 : CheckImplementationPointerR ();
1001 1841 : readImpl_p->lsrFrequency (spw, freq, convert, ignoreconv);
1002 1841 : }
1003 :
1004 : void
1005 0 : ROVisibilityIterator::lsrFrequency (const Int& spw,
1006 : Vector<Double>& freq,
1007 : Bool & convert,
1008 : const Block<Int> & chanStart,
1009 : const Block<Int> & chanWidth,
1010 : const Block<Int> & chanInc,
1011 : const Block<Int> & numChanGroup,
1012 : const ArrayColumn <Double> & chanFreqs,
1013 : const ScalarColumn<Int> & obsMFreqTypes,
1014 : const MEpoch & ep,
1015 : const MPosition & obsPos,
1016 : const MDirection & dir)
1017 : {
1018 0 : VisibilityIteratorReadImpl::lsrFrequency (spw, freq, convert, chanStart, chanWidth, chanInc,
1019 : numChanGroup, chanFreqs, obsMFreqTypes, ep, obsPos, dir);
1020 0 : }
1021 :
1022 :
1023 : Bool
1024 49960 : ROVisibilityIterator::more () const
1025 : {
1026 49960 : CheckImplementationPointerR ();
1027 49960 : return readImpl_p->more ();
1028 : }
1029 :
1030 : Bool
1031 21322 : ROVisibilityIterator::moreChunks () const
1032 : {
1033 21322 : CheckImplementationPointerR ();
1034 21322 : return readImpl_p->moreChunks ();
1035 : }
1036 :
1037 : const MSColumns &
1038 243893 : ROVisibilityIterator::msColumns () const
1039 : {
1040 243893 : CheckImplementationPointerR ();
1041 243893 : return readImpl_p->msColumns ();
1042 : }
1043 :
1044 : Int
1045 22672 : ROVisibilityIterator::msId () const
1046 : {
1047 22672 : CheckImplementationPointerR ();
1048 22672 : return readImpl_p->msId ();
1049 : }
1050 :
1051 : Int
1052 2 : ROVisibilityIterator::nCorr () const
1053 : {
1054 2 : CheckImplementationPointerR ();
1055 2 : return readImpl_p->nCorr ();
1056 : }
1057 :
1058 : Int
1059 44619 : ROVisibilityIterator::nRow () const
1060 : {
1061 44619 : CheckImplementationPointerR ();
1062 44619 : return readImpl_p->nRow ();
1063 : }
1064 :
1065 : Int
1066 1295 : ROVisibilityIterator::nRowChunk () const
1067 : {
1068 1295 : CheckImplementationPointerR ();
1069 1295 : return readImpl_p->nRowChunk ();
1070 : }
1071 :
1072 : Int
1073 0 : ROVisibilityIterator::nSubInterval () const
1074 : {
1075 0 : CheckImplementationPointerR ();
1076 0 : return readImpl_p->nSubInterval ();
1077 : }
1078 :
1079 : Bool
1080 0 : ROVisibilityIterator::newArrayId () const
1081 : {
1082 0 : CheckImplementationPointerR ();
1083 0 : return readImpl_p->newArrayId ();
1084 : }
1085 :
1086 : Bool
1087 0 : ROVisibilityIterator::newFieldId () const
1088 : {
1089 0 : CheckImplementationPointerR ();
1090 0 : return readImpl_p->newFieldId ();
1091 : }
1092 :
1093 : Bool
1094 6311 : ROVisibilityIterator::newMS () const
1095 : {
1096 6311 : CheckImplementationPointerR ();
1097 6311 : return readImpl_p->newMS ();
1098 : }
1099 :
1100 : Bool
1101 0 : ROVisibilityIterator::newSpectralWindow () const
1102 : {
1103 0 : CheckImplementationPointerR ();
1104 0 : return readImpl_p->newSpectralWindow ();
1105 : }
1106 :
1107 : ROVisibilityIterator&
1108 15720 : ROVisibilityIterator::nextChunk ()
1109 : {
1110 15720 : CheckImplementationPointerR ();
1111 15720 : readImpl_p->nextChunk ();
1112 :
1113 15720 : return * this;
1114 : }
1115 :
1116 : Int
1117 0 : ROVisibilityIterator::numberAnt ()
1118 : {
1119 0 : CheckImplementationPointerR ();
1120 0 : return readImpl_p->numberAnt ();
1121 : }
1122 :
1123 : Int
1124 37 : ROVisibilityIterator::numberCoh ()
1125 : {
1126 37 : CheckImplementationPointerR ();
1127 37 : return readImpl_p->numberCoh ();
1128 : }
1129 :
1130 : Int
1131 0 : ROVisibilityIterator::numberDDId ()
1132 : {
1133 0 : CheckImplementationPointerR ();
1134 0 : return readImpl_p->numberDDId ();
1135 : }
1136 :
1137 : Int
1138 0 : ROVisibilityIterator::numberPol ()
1139 : {
1140 0 : CheckImplementationPointerR ();
1141 0 : return readImpl_p->numberPol ();
1142 : }
1143 :
1144 : Int
1145 78 : ROVisibilityIterator::numberSpw ()
1146 : {
1147 78 : CheckImplementationPointerR ();
1148 78 : return readImpl_p->numberSpw ();
1149 : }
1150 :
1151 : Vector<Int>&
1152 5160 : ROVisibilityIterator::observationId (Vector<Int>& obsids) const
1153 : {
1154 5160 : CheckImplementationPointerR ();
1155 5160 : return readImpl_p->observationId (obsids);
1156 : }
1157 :
1158 : void
1159 16420 : ROVisibilityIterator::origin ()
1160 : {
1161 16420 : CheckImplementationPointerR ();
1162 16420 : readImpl_p->origin ();
1163 16420 : }
1164 :
1165 : void
1166 1512 : ROVisibilityIterator::originChunks ()
1167 : {
1168 1512 : CheckImplementationPointerR ();
1169 1512 : readImpl_p->originChunks ();
1170 1512 : }
1171 :
1172 : void
1173 0 : ROVisibilityIterator::originChunks (Bool forceRewind)
1174 : {
1175 0 : CheckImplementationPointerR ();
1176 0 : readImpl_p->originChunks (forceRewind);
1177 0 : }
1178 :
1179 : Vector<Float>
1180 0 : ROVisibilityIterator::parang (Double time) const
1181 : {
1182 0 : CheckImplementationPointerR ();
1183 0 : return readImpl_p->parang (time);
1184 : }
1185 :
1186 : const Float&
1187 0 : ROVisibilityIterator::parang0 (Double time) const
1188 : {
1189 0 : CheckImplementationPointerR ();
1190 0 : return readImpl_p->parang0 (time);
1191 : }
1192 :
1193 :
1194 : Float
1195 0 : ROVisibilityIterator::parang0Calculate (Double time, MSDerivedValues & msd, const MEpoch & epoch0)
1196 : {
1197 0 : return VisibilityIteratorReadImpl::parang0Calculate (time, msd, epoch0);
1198 : }
1199 :
1200 : Vector<Float>
1201 0 : ROVisibilityIterator::parangCalculate (Double time, MSDerivedValues & msd,
1202 : int nAntennas, const MEpoch mEpoch0)
1203 : {
1204 0 : return VisibilityIteratorReadImpl::parangCalculate (time, msd, nAntennas, mEpoch0);
1205 : }
1206 :
1207 : const MDirection&
1208 338 : ROVisibilityIterator::phaseCenter () const
1209 : {
1210 338 : CheckImplementationPointerR ();
1211 338 : return readImpl_p->phaseCenter ();
1212 : }
1213 : const MDirection
1214 5821 : ROVisibilityIterator::phaseCenter (const Int fieldid, const Double time) const
1215 : {
1216 5821 : CheckImplementationPointerR ();
1217 5821 : return readImpl_p->phaseCenter (fieldid, time);
1218 : }
1219 : Int
1220 12245 : ROVisibilityIterator::polFrame () const
1221 : {
1222 12245 : CheckImplementationPointerR ();
1223 12245 : return readImpl_p->polFrame ();
1224 : }
1225 :
1226 : Int
1227 0 : ROVisibilityIterator::polarizationId () const
1228 : {
1229 0 : CheckImplementationPointerR ();
1230 0 : return readImpl_p->polarizationId ();
1231 : }
1232 :
1233 : Vector<Int>&
1234 0 : ROVisibilityIterator::processorId (Vector<Int>& procids) const
1235 : {
1236 0 : CheckImplementationPointerR ();
1237 0 : return readImpl_p->processorId (procids);
1238 : }
1239 :
1240 : const Cube<Double>&
1241 0 : ROVisibilityIterator::receptorAngles () const
1242 : {
1243 0 : CheckImplementationPointerR ();
1244 0 : return readImpl_p->receptorAngles ();
1245 : }
1246 :
1247 : Vector<Float>
1248 0 : ROVisibilityIterator::getReceptor0Angle ()
1249 : {
1250 0 : CheckImplementationPointerR ();
1251 0 : return readImpl_p->getReceptor0Angle();
1252 : }
1253 :
1254 : //Vector<uInt> getRowIds ();
1255 :
1256 : Vector<rownr_t>&
1257 2704 : ROVisibilityIterator::rowIds (Vector<rownr_t>& rowids) const
1258 : {
1259 2704 : CheckImplementationPointerR ();
1260 2704 : return readImpl_p->rowIds (rowids);
1261 : }
1262 :
1263 : Vector<rownr_t>
1264 0 : ROVisibilityIterator::getRowIds() const
1265 : {
1266 0 : CheckImplementationPointerR();
1267 0 : return readImpl_p->getRowIds();
1268 : }
1269 :
1270 : Vector<Int>&
1271 5024 : ROVisibilityIterator::scan (Vector<Int>& scans) const
1272 : {
1273 5024 : CheckImplementationPointerR ();
1274 5024 : return readImpl_p->scan (scans);
1275 : }
1276 :
1277 : ROVisibilityIterator&
1278 3867 : ROVisibilityIterator::selectChannel (Int nGroup,
1279 : Int start,
1280 : Int width,
1281 : Int increment,
1282 : Int spectralWindow)
1283 : {
1284 3867 : CheckImplementationPointerR ();
1285 3867 : readImpl_p->selectChannel (nGroup, start, width, increment, spectralWindow);
1286 3867 : readImpl_p->originChunks ();
1287 :
1288 3867 : return * this;
1289 : }
1290 :
1291 : ROVisibilityIterator&
1292 570 : ROVisibilityIterator::selectChannel (Block< Vector<Int> >& blockNGroup,
1293 : Block< Vector<Int> >& blockStart,
1294 : Block< Vector<Int> >& blockWidth,
1295 : Block< Vector<Int> >& blockIncr,
1296 : Block< Vector<Int> >& blockSpw)
1297 : {
1298 570 : CheckImplementationPointerR ();
1299 570 : readImpl_p->selectChannel (blockNGroup, blockStart, blockWidth, blockIncr, blockSpw);
1300 :
1301 570 : return * this;
1302 : }
1303 :
1304 : ROVisibilityIterator&
1305 0 : ROVisibilityIterator::selectVelocity (Int nChan,
1306 : const MVRadialVelocity& vStart,
1307 : const MVRadialVelocity& vInc,
1308 : MRadialVelocity::Types rvType,
1309 : MDoppler::Types dType,
1310 : Bool precise)
1311 : {
1312 0 : CheckImplementationPointerR ();
1313 :
1314 0 : readImpl_p->selectVelocity (nChan, vStart, vInc, rvType, dType, precise);
1315 :
1316 0 : return * this;
1317 : }
1318 :
1319 : void
1320 0 : ROVisibilityIterator::setAsyncEnabled (Bool enable)
1321 : {
1322 0 : CheckImplementationPointerR ();
1323 0 : readImpl_p->setAsyncEnabled (enable);
1324 0 : }
1325 :
1326 0 : Double ROVisibilityIterator::getInterval() const
1327 : {
1328 0 : CheckImplementationPointerR ();
1329 0 : return readImpl_p->getInterval();
1330 : }
1331 :
1332 : void
1333 0 : ROVisibilityIterator::setInterval (Double timeInterval)
1334 : {
1335 0 : CheckImplementationPointerR ();
1336 0 : readImpl_p->setInterval (timeInterval);
1337 0 : }
1338 :
1339 : void
1340 446 : ROVisibilityIterator::setRowBlocking (Int nRows) // for use by Async I/O *ONLY
1341 : {
1342 446 : CheckImplementationPointerR ();
1343 446 : readImpl_p->setRowBlocking (nRows);
1344 446 : }
1345 :
1346 : void
1347 0 : ROVisibilityIterator::setSelTable ()
1348 : {
1349 0 : CheckImplementationPointerR ();
1350 0 : readImpl_p->setSelTable ();
1351 0 : }
1352 :
1353 : void
1354 0 : ROVisibilityIterator::setState ()
1355 : {
1356 0 : CheckImplementationPointerR ();
1357 0 : readImpl_p->setState ();
1358 0 : }
1359 :
1360 : void
1361 0 : ROVisibilityIterator::setTileCache ()
1362 : {
1363 0 : CheckImplementationPointerR ();
1364 0 : readImpl_p->setTileCache ();
1365 0 : }
1366 :
1367 : Vector<Float>&
1368 0 : ROVisibilityIterator::sigma (Vector<Float>& sig) const
1369 : {
1370 0 : CheckImplementationPointerR ();
1371 0 : return readImpl_p->sigma (sig);
1372 : }
1373 :
1374 : Matrix<Float>&
1375 6104 : ROVisibilityIterator::sigmaMat (Matrix<Float>& sigmat) const
1376 : {
1377 6104 : CheckImplementationPointerR ();
1378 6104 : return readImpl_p->sigmaMat (sigmat);
1379 : }
1380 :
1381 : void
1382 3 : ROVisibilityIterator::slicesToMatrices (Vector<Matrix<Int> >& matv,
1383 : const Vector<Vector<Slice> >& slicesv,
1384 : const Vector<Int>& widthsv) const
1385 : {
1386 3 : CheckImplementationPointerR ();
1387 3 : readImpl_p->slicesToMatrices (matv, slicesv, widthsv);
1388 3 : }
1389 :
1390 : void
1391 0 : ROVisibilityIterator::slurp () const
1392 : {
1393 0 : CheckImplementationPointerR ();
1394 0 : readImpl_p->slurp ();
1395 0 : }
1396 :
1397 : String
1398 0 : ROVisibilityIterator::sourceName () const
1399 : {
1400 0 : CheckImplementationPointerR ();
1401 0 : return readImpl_p->sourceName ();
1402 : }
1403 :
1404 : Int
1405 35102 : ROVisibilityIterator::spectralWindow () const
1406 : {
1407 35102 : CheckImplementationPointerR ();
1408 35102 : return readImpl_p->spectralWindow ();
1409 : }
1410 :
1411 : Vector<Int>&
1412 0 : ROVisibilityIterator::stateId (Vector<Int>& stateids) const
1413 : {
1414 0 : CheckImplementationPointerR ();
1415 0 : return readImpl_p->stateId (stateids);
1416 : }
1417 :
1418 : Vector<Double>&
1419 34578 : ROVisibilityIterator::time (Vector<Double>& t) const
1420 : {
1421 34578 : CheckImplementationPointerR ();
1422 34578 : return readImpl_p->time (t);
1423 : }
1424 :
1425 : Vector<Double>&
1426 0 : ROVisibilityIterator::timeCentroid (Vector<Double>& t) const
1427 : {
1428 0 : CheckImplementationPointerR ();
1429 0 : return readImpl_p->timeCentroid (t);
1430 : }
1431 :
1432 : Vector<Double>&
1433 2499 : ROVisibilityIterator::timeInterval (Vector<Double>& ti) const
1434 : {
1435 2499 : CheckImplementationPointerR ();
1436 2499 : return readImpl_p->timeInterval (ti);
1437 : }
1438 :
1439 : void
1440 0 : ROVisibilityIterator::updateSlicer ()
1441 : {
1442 0 : CheckImplementationPointerR ();
1443 0 : readImpl_p->updateSlicer ();
1444 0 : }
1445 :
1446 : void
1447 0 : ROVisibilityIterator::update_rowIds () const
1448 : {
1449 0 : CheckImplementationPointerR ();
1450 0 : readImpl_p->update_rowIds ();
1451 0 : }
1452 :
1453 : void
1454 1559 : ROVisibilityIterator::useImagingWeight (const VisImagingWeight& imWgt)
1455 : {
1456 1559 : CheckImplementationPointerR ();
1457 1559 : readImpl_p->useImagingWeight (imWgt);
1458 1559 : }
1459 :
1460 : Vector<RigidVector<Double, 3> >&
1461 14923 : ROVisibilityIterator::uvw (Vector<RigidVector<Double, 3> >& uvwvec) const
1462 : {
1463 14923 : CheckImplementationPointerR ();
1464 14923 : return readImpl_p->uvw (uvwvec);
1465 : }
1466 :
1467 : Matrix<Double>&
1468 0 : ROVisibilityIterator::uvwMat (Matrix<Double>& uvwmat) const
1469 : {
1470 0 : CheckImplementationPointerR ();
1471 0 : return readImpl_p->uvwMat (uvwmat);
1472 : }
1473 :
1474 : ROVisibilityIterator&
1475 0 : ROVisibilityIterator::velInterpolation (const String& type)
1476 : {
1477 0 : CheckImplementationPointerR ();
1478 :
1479 0 : readImpl_p->velInterpolation (type);
1480 :
1481 0 : return * this;
1482 : }
1483 :
1484 : Cube<Complex>&
1485 27513 : ROVisibilityIterator::visibility (Cube<Complex>& vis,
1486 : DataColumn whichOne) const
1487 : {
1488 27513 : CheckImplementationPointerR ();
1489 27513 : return readImpl_p->visibility (vis, whichOne);
1490 : }
1491 :
1492 : Matrix<CStokesVector>&
1493 0 : ROVisibilityIterator::visibility (Matrix<CStokesVector>& vis,
1494 : DataColumn whichOne) const
1495 : {
1496 0 : CheckImplementationPointerR ();
1497 0 : return readImpl_p->visibility (vis, whichOne);
1498 : }
1499 :
1500 : IPosition
1501 21640 : ROVisibilityIterator::visibilityShape () const
1502 : {
1503 21640 : CheckImplementationPointerR ();
1504 21640 : return readImpl_p->visibilityShape ();
1505 : }
1506 :
1507 : Vector<Float>&
1508 6488 : ROVisibilityIterator::weight (Vector<Float>& wt) const
1509 : {
1510 6488 : CheckImplementationPointerR ();
1511 6488 : return readImpl_p->weight (wt);
1512 : }
1513 :
1514 : Matrix<Float>&
1515 9003 : ROVisibilityIterator::weightMat (Matrix<Float>& wtmat) const
1516 : {
1517 9003 : CheckImplementationPointerR ();
1518 9003 : return readImpl_p->weightMat (wtmat);
1519 : }
1520 :
1521 : Cube<Float>&
1522 6621 : ROVisibilityIterator::weightSpectrum (Cube<Float>& wtsp) const
1523 : {
1524 6621 : CheckImplementationPointerR ();
1525 6621 : return readImpl_p->weightSpectrum (wtsp);
1526 : }
1527 :
1528 :
1529 :
1530 0 : VisibilityIterator::VisibilityIterator ()
1531 : : ROVisibilityIterator (),
1532 0 : writeImpl_p (NULL)
1533 0 : {}
1534 :
1535 1575 : VisibilityIterator::VisibilityIterator (MeasurementSet & ms,
1536 : const Block<Int>& sortColumns,
1537 1575 : Double timeInterval)
1538 1575 : : ROVisibilityIterator (NULL, Block<MeasurementSet> (1, ms), sortColumns,
1539 1575 : true, timeInterval, true)
1540 :
1541 : {
1542 1575 : construct ();
1543 1575 : }
1544 :
1545 0 : VisibilityIterator::VisibilityIterator (MeasurementSet & ms,
1546 : const Block<Int>& sortColumns,
1547 : const Bool addDefaultSortCols,
1548 0 : Double timeInterval)
1549 0 : : ROVisibilityIterator (NULL, Block<MeasurementSet> (1, ms), sortColumns,
1550 0 : addDefaultSortCols, timeInterval, true)
1551 : {
1552 0 : construct ();
1553 0 : }
1554 :
1555 43 : VisibilityIterator::VisibilityIterator (const Block<MeasurementSet>& mss,
1556 : const Block<Int>& sortColumns,
1557 43 : Double timeInterval)
1558 43 : : ROVisibilityIterator (NULL, mss, sortColumns, true, timeInterval, true)
1559 : {
1560 43 : construct ();
1561 43 : }
1562 :
1563 0 : VisibilityIterator::VisibilityIterator (const Block<MeasurementSet>& mss,
1564 : const Block<Int>& sortColumns,
1565 : const Bool addDefaultSortCols,
1566 0 : Double timeInterval)
1567 0 : : ROVisibilityIterator (NULL, mss, sortColumns, addDefaultSortCols, timeInterval, true)
1568 : {
1569 0 : construct ();
1570 0 : }
1571 :
1572 94 : VisibilityIterator::VisibilityIterator (const asyncio::PrefetchColumns * prefetchColumns,
1573 : MeasurementSet & ms,
1574 : const Block<Int>& sortColumns,
1575 : const Bool addDefaultSortCols,
1576 94 : Double timeInterval)
1577 94 : : ROVisibilityIterator (prefetchColumns, Block<MeasurementSet> (1, ms), sortColumns,
1578 94 : addDefaultSortCols, timeInterval, true)
1579 : {
1580 94 : construct ();
1581 94 : }
1582 :
1583 :
1584 0 : VisibilityIterator::VisibilityIterator (const asyncio::PrefetchColumns * prefetchColumns,
1585 : const Block<MeasurementSet>& mss,
1586 : const Block<Int>& sortColumns,
1587 : const Bool addDefaultSortCols,
1588 0 : Double timeInterval)
1589 : : ROVisibilityIterator (prefetchColumns, mss, sortColumns,
1590 0 : addDefaultSortCols, timeInterval, true)
1591 : {
1592 0 : construct ();
1593 0 : }
1594 :
1595 :
1596 0 : VisibilityIterator::VisibilityIterator (const VisibilityIterator & other)
1597 0 : : ROVisibilityIterator (other)
1598 : {
1599 0 : if (other.writeImpl_p == NULL){
1600 0 : writeImpl_p = NULL;
1601 : }
1602 : else{
1603 0 : writeImpl_p = other.writeImpl_p->clone(this);
1604 : }
1605 0 : }
1606 :
1607 0 : VisibilityIterator::VisibilityIterator (const asyncio::PrefetchColumns * prefetchColumns,
1608 0 : const VisibilityIterator & other)
1609 0 : : ROVisibilityIterator (prefetchColumns, other)
1610 : {
1611 0 : Bool createAsAsynchronous = prefetchColumns != NULL && isAsynchronousIoEnabled ();
1612 :
1613 0 : if (createAsAsynchronous){
1614 0 : writeImpl_p = new ViWriteImplAsync (* prefetchColumns, * other.writeImpl_p, this);
1615 : }
1616 : else{
1617 0 : writeImpl_p = other.writeImpl_p -> clone(this);
1618 : }
1619 0 : }
1620 :
1621 :
1622 3263 : VisibilityIterator::~VisibilityIterator ()
1623 : {
1624 1712 : delete writeImpl_p;
1625 3263 : }
1626 :
1627 : VisibilityIterator &
1628 0 : VisibilityIterator::operator= (const VisibilityIterator & other)
1629 : {
1630 : // Let the superclass handle its part of the assignment
1631 :
1632 0 : ROVisibilityIterator::operator= (other);
1633 :
1634 : // Kill off the current write implementation
1635 :
1636 0 : if (writeImpl_p != NULL){
1637 0 : delete writeImpl_p;
1638 0 : writeImpl_p = NULL;
1639 : }
1640 :
1641 : // If the other's read implementation is not null then
1642 : // put a clone of it into this object's read implementation.
1643 :
1644 0 : if (other.writeImpl_p != NULL){
1645 :
1646 0 : writeImpl_p = other.writeImpl_p->clone (this);
1647 : }
1648 0 : return * this;
1649 : }
1650 :
1651 : VisibilityIterator &
1652 29857 : VisibilityIterator::operator++ (int)
1653 : {
1654 29857 : advance ();
1655 :
1656 29857 : return * this;
1657 : }
1658 :
1659 : VisibilityIterator &
1660 2712 : VisibilityIterator::operator++ ()
1661 : {
1662 2712 : advance();
1663 :
1664 2712 : return * this;
1665 : }
1666 :
1667 : void
1668 34988 : VisibilityIterator::attachColumns (const Table &t)
1669 : {
1670 34988 : CheckImplementationPointerW ();
1671 :
1672 34988 : writeImpl_p->attachColumns (t);
1673 34988 : }
1674 :
1675 : void
1676 1712 : VisibilityIterator::construct ()
1677 : {
1678 1712 : if (isAsynchronous ()){
1679 0 : writeImpl_p = new ViWriteImplAsync (this);
1680 : }
1681 : else{
1682 1712 : writeImpl_p = new VisibilityIteratorWriteImpl (this);
1683 : }
1684 :
1685 : ///////////////// readImpl_p->originChunks();
1686 1712 : }
1687 :
1688 : VisibilityIteratorWriteImpl *
1689 0 : VisibilityIterator::getWriteImpl () const
1690 : {
1691 0 : return writeImpl_p;
1692 : }
1693 :
1694 : Bool
1695 0 : VisibilityIterator::isWritable () const
1696 : {
1697 0 : return true;
1698 : }
1699 :
1700 : void
1701 0 : VisibilityIterator::setFlag (const Matrix<Bool>& flag)
1702 : {
1703 0 : CheckImplementationPointerW ();
1704 0 : writeImpl_p->setFlag (flag);
1705 0 : }
1706 :
1707 : void
1708 1995 : VisibilityIterator::setFlag (const Cube<Bool>& flag)
1709 : {
1710 1995 : CheckImplementationPointerW ();
1711 1995 : writeImpl_p->setFlag (flag);
1712 1995 : }
1713 : void
1714 0 : VisibilityIterator::setFlagCategory(const Array<Bool>& flagCategory)
1715 : {
1716 0 : CheckImplementationPointerW ();
1717 0 : writeImpl_p->setFlagCategory (flagCategory);
1718 0 : }
1719 :
1720 : void
1721 0 : VisibilityIterator::setFlagRow (const Vector<Bool>& rowflags)
1722 : {
1723 0 : CheckImplementationPointerW ();
1724 0 : writeImpl_p->setFlagRow (rowflags);
1725 0 : }
1726 :
1727 : void
1728 0 : VisibilityIterator::setSigma (const Vector<Float>& sig)
1729 : {
1730 0 : CheckImplementationPointerW ();
1731 0 : writeImpl_p->setSigma (sig);
1732 0 : }
1733 :
1734 : void
1735 1995 : VisibilityIterator::setSigmaMat (const Matrix<Float>& sigmat)
1736 : {
1737 1995 : CheckImplementationPointerW ();
1738 1995 : writeImpl_p->setSigmaMat (sigmat);
1739 1995 : }
1740 :
1741 : void
1742 0 : VisibilityIterator::setVis (const Matrix<CStokesVector>& vis, DataColumn whichOne)
1743 : {
1744 0 : CheckImplementationPointerW ();
1745 0 : writeImpl_p->setVis (vis, whichOne);
1746 0 : }
1747 :
1748 : void
1749 28241 : VisibilityIterator::setVis (const Cube<Complex>& vis, DataColumn whichOne)
1750 : {
1751 28241 : CheckImplementationPointerW ();
1752 28241 : writeImpl_p->setVis (vis, whichOne);
1753 28241 : }
1754 :
1755 : void
1756 60 : VisibilityIterator::setVisAndFlag (const Cube<Complex>& vis, const Cube<Bool>& flag,
1757 : DataColumn whichOne)
1758 : {
1759 60 : CheckImplementationPointerW ();
1760 60 : writeImpl_p->setVisAndFlag (vis, flag, whichOne);
1761 60 : }
1762 :
1763 : void
1764 0 : VisibilityIterator::setWeight (const Vector<Float>& wt)
1765 : {
1766 0 : CheckImplementationPointerW ();
1767 0 : writeImpl_p->setWeight (wt);
1768 0 : }
1769 :
1770 : void
1771 6527 : VisibilityIterator::setWeightMat (const Matrix<Float>& wtmat)
1772 : {
1773 6527 : CheckImplementationPointerW ();
1774 6527 : writeImpl_p->setWeightMat (wtmat);
1775 6527 : }
1776 :
1777 : void
1778 1976 : VisibilityIterator::setWeightSpectrum (const Cube<Float>& wtsp)
1779 : {
1780 1976 : CheckImplementationPointerW ();
1781 1976 : writeImpl_p->setWeightSpectrum (wtsp);
1782 1976 : }
1783 :
1784 25 : void VisibilityIterator::putModel(const RecordInterface& rec, Bool iscomponentlist, Bool incremental){
1785 25 : CheckImplementationPointerW ();
1786 25 : writeImpl_p->putModel(rec, iscomponentlist, incremental);
1787 :
1788 25 : }
1789 :
1790 :
1791 :
1792 0 : void VisibilityIterator::writeBack (VisBuffer * vb)
1793 : {
1794 0 : CheckImplementationPointerW ();
1795 0 : writeImpl_p->writeBack (vb);
1796 0 : }
1797 :
1798 : using namespace casacore;
1799 : } // end namespace casa
|
