Line data Source code
1 : /*
2 : * VisibilityIterator2.cc
3 : *
4 : * Created on: Jun 4, 2012
5 : * Author: jjacobs
6 : */
7 :
8 : #include <msvis/MSVis/VisibilityIterator2.h>
9 :
10 : #include <casacore/casa/Arrays/Cube.h>
11 : #include <casacore/casa/Arrays/Matrix.h>
12 : #include <casacore/casa/Arrays/Slicer.h>
13 : #include <casacore/casa/BasicSL/String.h>
14 : #include <casacore/casa/Quanta/MVDoppler.h>
15 : #include <casacore/casa/aips.h>
16 : #include <casacore/casa/System/AipsrcValue.h>
17 : #include <casacore/measures/Measures/MCDoppler.h>
18 : #include <casacore/measures/Measures/MDoppler.h>
19 : #include <casacore/measures/Measures/MeasConvert.h>
20 : #include <casacore/measures/Measures/Stokes.h>
21 : #include <casacore/ms/MSOper/MSDerivedValues.h>
22 : #include <casacore/ms/MeasurementSets/MSIter.h>
23 : #include <casacore/ms/MeasurementSets/MeasurementSet.h>
24 : #include <casacore/scimath/Mathematics/RigidVector.h>
25 : #include <casacore/scimath/Mathematics/SquareMatrix.h>
26 : #include <stdcasa/UtilJ.h>
27 : #include <msvis/MSVis/AveragingTvi2.h>
28 : #include <msvis/MSVis/ViFrequencySelection.h>
29 : #include <msvis/MSVis/StokesVector.h>
30 : #include <msvis/MSVis/VisBuffer2.h>
31 : #include <msvis/MSVis/VisBufferComponents2.h>
32 : #include <msvis/MSVis/VisImagingWeight.h>
33 : #include <msvis/MSVis/VisibilityIteratorImpl2.h>
34 : #include <msvis/MSVis/VisibilityIteratorImplAsync2.h>
35 : #include <casacore/tables/Tables/ArrayColumn.h>
36 : #include <casacore/tables/Tables/ScalarColumn.h>
37 :
38 : #include <cstdarg>
39 : #include <map>
40 : #include <set>
41 : #include <utility>
42 : #include <vector>
43 :
44 : using namespace std;
45 :
46 : #define CheckImplementationPointer() Assert (impl_p != NULL);
47 :
48 : using namespace casacore;
49 : namespace casa {
50 :
51 : namespace vi {
52 :
53 19 : SortColumns::SortColumns (const Block<Int> & columnIds, Bool addDefaultColumns)
54 19 : : addDefaultColumns_p (addDefaultColumns),
55 19 : columnIds_p (columnIds),
56 19 : usingDefaultSortingFunctions_p (true)
57 : {
58 91 : for (auto colId : columnIds)
59 72 : sortingDefinition_p.push_back(
60 144 : std::make_pair(MS::columnName(casacore::MS::PredefinedColumns(colId)), nullptr));
61 19 : }
62 :
63 19 : SortColumns::SortColumns (Bool usingDefaultSortingFunctions)
64 19 : : usingDefaultSortingFunctions_p (usingDefaultSortingFunctions)
65 : {
66 19 : }
67 :
68 0 : SortColumns::SortColumns (const std::vector<std::pair<casacore::MS::PredefinedColumns, std::shared_ptr<casacore::BaseCompare>>> sortingDefinition)
69 0 : : addDefaultColumns_p (false),
70 0 : usingDefaultSortingFunctions_p (false)
71 : {
72 0 : for (auto pair : sortingDefinition)
73 0 : sortingDefinition_p.push_back(
74 0 : std::make_pair(MS::columnName(pair.first), pair.second));
75 0 : }
76 :
77 0 : SortColumns::SortColumns (const std::vector<std::pair<casacore::String, std::shared_ptr<casacore::BaseCompare>>> sortingDefinition)
78 0 : : addDefaultColumns_p (false),
79 0 : sortingDefinition_p(sortingDefinition),
80 0 : usingDefaultSortingFunctions_p (false)
81 : {
82 0 : }
83 :
84 19 : void SortColumns::addSortingColumn(casacore::MS::PredefinedColumns colId,
85 : std::shared_ptr<casacore::BaseCompare> sortingFunction)
86 : {
87 19 : if (usingDefaultSortingFunctions_p)
88 0 : throw AipsError("SortColumns invalid construction. "
89 0 : "Cannot add generic sorting functions.");
90 19 : sortingDefinition_p.push_back(
91 38 : std::make_pair(MS::columnName(colId), sortingFunction));
92 19 : usingDefaultSortingFunctions_p = false;
93 19 : }
94 :
95 0 : void SortColumns::addSortingColumn(casacore::String colName,
96 : std::shared_ptr<casacore::BaseCompare> sortingFunction)
97 : {
98 0 : if (usingDefaultSortingFunctions_p)
99 0 : throw AipsError("SortColumns invalid construction. "
100 0 : "Cannot add generic sorting functions.");
101 0 : sortingDefinition_p.push_back(
102 0 : std::make_pair(colName, sortingFunction));
103 0 : usingDefaultSortingFunctions_p = false;
104 0 : }
105 :
106 : Bool
107 38 : SortColumns::shouldAddDefaultColumns () const
108 : {
109 38 : return addDefaultColumns_p;
110 : }
111 :
112 : bool
113 19 : SortColumns::usingDefaultSortingFunctions () const
114 : {
115 19 : return usingDefaultSortingFunctions_p;
116 : }
117 :
118 : const Block<Int> &
119 37 : SortColumns::getColumnIds () const
120 : {
121 37 : return columnIds_p;
122 : }
123 :
124 : const std::vector<std::pair<casacore::String, std::shared_ptr<casacore::BaseCompare>>> &
125 2196 : SortColumns::sortingDefinition() const
126 : {
127 2196 : return sortingDefinition_p;
128 : }
129 :
130 : CountedPtr <WeightScaling>
131 0 : WeightScaling::generateUnityWeightScaling ()
132 : {
133 0 : return generateWeightScaling (WeightScaling::unity);
134 : }
135 :
136 : CountedPtr <WeightScaling>
137 0 : WeightScaling::generateIdentityWeightScaling ()
138 : {
139 0 : return generateWeightScaling (WeightScaling::identity);
140 : }
141 :
142 : CountedPtr <WeightScaling>
143 0 : WeightScaling::generateSquareWeightScaling ()
144 : {
145 0 : return generateWeightScaling (WeightScaling::square);
146 : }
147 :
148 0 : Float WeightScaling::unity (Float) { return 1.0;}
149 0 : Float WeightScaling::identity (Float x) { return x;}
150 0 : Float WeightScaling::square (Float x) { return x * x;}
151 :
152 0 : VisibilityIterator2::VisibilityIterator2()
153 0 : : impl_p (0)
154 : {
155 0 : }
156 :
157 19 : VisibilityIterator2::VisibilityIterator2(const MeasurementSet& ms,
158 : const SortColumns & sortColumns,
159 : Bool isWritable,
160 : const VisBufferComponents2 * prefetchColumns,
161 19 : Double timeInterval)
162 : {
163 19 : Block<const MeasurementSet *> mss (1, & ms);
164 19 : construct (prefetchColumns, mss, sortColumns,
165 : timeInterval, isWritable);
166 19 : }
167 :
168 0 : VisibilityIterator2::VisibilityIterator2 (const Block<const MeasurementSet *>& mss,
169 : const SortColumns & sortColumns,
170 : Bool isWritable,
171 : const VisBufferComponents2 * prefetchColumns,
172 0 : Double timeInterval)
173 : {
174 0 : construct (prefetchColumns, mss, sortColumns, timeInterval, isWritable);
175 0 : }
176 :
177 0 : VisibilityIterator2::VisibilityIterator2 (const ViFactory & factory)
178 0 : : impl_p (0)
179 : {
180 0 : ViImplementation2 * newImpl = factory.createVi ();
181 :
182 0 : impl_p = newImpl;
183 0 : }
184 :
185 0 : VisibilityIterator2::VisibilityIterator2 (const Vector<ViiLayerFactory*> & factories)
186 0 : : impl_p (0)
187 : {
188 :
189 0 : Int nfactory=factories.nelements();
190 :
191 0 : if(factories(nfactory-1) == nullptr)
192 0 : throw(AipsError("ViiLayerFactory in factories is null"));
193 :
194 0 : ViImplementation2 * newImpl = factories(nfactory-1)->createViImpl2(factories(Slice(0,nfactory-1,1)));
195 :
196 0 : impl_p = newImpl;
197 0 : }
198 :
199 :
200 : void
201 19 : VisibilityIterator2::construct (const VisBufferComponents2 * prefetchColumns,
202 : const Block<const MeasurementSet *>& mss,
203 : const SortColumns & sortColumns,
204 : Double timeInterval,
205 : Bool writable)
206 : {
207 :
208 : // Factory didn't create the read implementation so decide whether to create a
209 : // synchronous or asynchronous read implementation.
210 :
211 19 : Bool createAsAsynchronous = prefetchColumns != NULL && isAsynchronousIoEnabled ();
212 :
213 19 : if (createAsAsynchronous){
214 : // impl_p = new ViImplAsync2 (mss, * prefetchColumns, sortColumns,
215 : // addDefaultSortCols, timeInterval, writable);
216 : }
217 : else{
218 19 : impl_p = new VisibilityIteratorImpl2 (mss, sortColumns, timeInterval, writable);
219 : }
220 19 : }
221 :
222 37 : VisibilityIterator2::~VisibilityIterator2 ()
223 : {
224 19 : delete impl_p;
225 37 : }
226 :
227 : String
228 0 : VisibilityIterator2::ViiType() const
229 : {
230 0 : return impl_p->ViiType ();
231 : }
232 :
233 :
234 : void
235 3222 : VisibilityIterator2::next()
236 : {
237 3222 : CheckImplementationPointer ();
238 3222 : impl_p->next ();
239 3222 : }
240 :
241 :
242 : const MeasurementSet&
243 0 : VisibilityIterator2::ms () const
244 : {
245 0 : CheckImplementationPointer ();
246 0 : return impl_p->ms ();
247 : }
248 :
249 : Bool
250 18 : VisibilityIterator2::existsColumn (VisBufferComponent2 id) const
251 : {
252 18 : CheckImplementationPointer ();
253 :
254 18 : return impl_p->existsColumn (id);
255 : }
256 :
257 : Bool
258 0 : VisibilityIterator2::weightSpectrumExists () const
259 : {
260 0 : CheckImplementationPointer ();
261 0 : return impl_p->weightSpectrumExists();
262 : }
263 :
264 : ViImplementation2 *
265 0 : VisibilityIterator2::getImpl () const
266 : {
267 0 : return impl_p;
268 : }
269 :
270 : Int
271 0 : VisibilityIterator2::getReportingFrameOfReference () const
272 : {
273 0 : return impl_p->getReportingFrameOfReference ();
274 : }
275 :
276 : void
277 0 : VisibilityIterator2::setReportingFrameOfReference (Int frame)
278 : {
279 0 : impl_p->setReportingFrameOfReference (frame);
280 0 : }
281 :
282 :
283 : Subchunk
284 0 : VisibilityIterator2::getSubchunkId () const
285 : {
286 0 : CheckImplementationPointer ();
287 0 : return impl_p->getSubchunkId ();
288 : }
289 :
290 : VisBuffer2 *
291 4063 : VisibilityIterator2::getVisBuffer ()
292 : {
293 4063 : CheckImplementationPointer ();
294 4063 : return impl_p->getVisBuffer(this);
295 : }
296 :
297 : Bool
298 0 : VisibilityIterator2::isAsynchronous () const
299 : {
300 : // Bool isAsync = impl_p != NULL && dynamic_cast<const ViImplAsync2 *> (impl_p) != NULL;
301 : //
302 : // return isAsync;
303 :
304 0 : return false; // for now
305 : }
306 :
307 :
308 : Bool
309 0 : VisibilityIterator2::isAsynchronousIoEnabled()
310 : {
311 : // Determines whether asynchronous I/O is enabled by looking for the
312 : // expected AipsRc value. If not found then async i/o is disabled.
313 :
314 : Bool isEnabled;
315 0 : AipsrcValue<Bool>::find (isEnabled, getAipsRcBase () + "async.enabled", false);
316 :
317 0 : return isEnabled;
318 : }
319 :
320 : Bool
321 3390 : VisibilityIterator2::more () const
322 : {
323 3390 : CheckImplementationPointer ();
324 3390 : return impl_p->more ();
325 : }
326 :
327 : Bool
328 4110 : VisibilityIterator2::moreChunks () const
329 : {
330 4110 : CheckImplementationPointer ();
331 4110 : return impl_p->moreChunks ();
332 : }
333 :
334 :
335 : void
336 1992 : VisibilityIterator2::nextChunk ()
337 : {
338 1992 : CheckImplementationPointer ();
339 1992 : impl_p->nextChunk ();
340 1992 : }
341 :
342 : void
343 0 : VisibilityIterator2::result(casacore::Record& res) const
344 : {
345 0 : impl_p->result(res);
346 0 : }
347 :
348 : // Report Name of slowest column that changes at end of current iteration
349 2040 : String VisibilityIterator2::keyChange() const
350 : {
351 2040 : return impl_p->keyChange();
352 : }
353 :
354 :
355 :
356 :
357 :
358 : Int
359 0 : VisibilityIterator2::nDataDescriptionIds () const
360 : {
361 0 : CheckImplementationPointer ();
362 0 : return impl_p->nDataDescriptionIds ();
363 : }
364 : //
365 : Int
366 0 : VisibilityIterator2::nPolarizationIds () const
367 : {
368 0 : CheckImplementationPointer ();
369 0 : return impl_p->nPolarizationIds ();
370 : }
371 : //
372 : Int
373 0 : VisibilityIterator2::nSpectralWindows () const
374 : {
375 0 : CheckImplementationPointer ();
376 0 : return impl_p->nSpectralWindows ();
377 : }
378 :
379 : void
380 2052 : VisibilityIterator2::origin ()
381 : {
382 2052 : CheckImplementationPointer ();
383 2052 : impl_p->origin ();
384 2052 : }
385 :
386 : void
387 84 : VisibilityIterator2::originChunks ()
388 : {
389 84 : CheckImplementationPointer ();
390 84 : originChunks (false);
391 84 : }
392 :
393 : void
394 84 : VisibilityIterator2::originChunks (Bool forceRewind)
395 : {
396 84 : CheckImplementationPointer ();
397 84 : impl_p->originChunks (forceRewind);
398 84 : }
399 :
400 : void
401 0 : VisibilityIterator2::setRowBlocking (rownr_t nRows) // for use by Async I/O *ONLY
402 : {
403 0 : CheckImplementationPointer ();
404 0 : impl_p->setRowBlocking (nRows);
405 0 : }
406 :
407 : void
408 0 : VisibilityIterator2::slurp () const
409 : {
410 0 : CheckImplementationPointer ();
411 0 : impl_p->slurp ();
412 0 : }
413 :
414 : rownr_t
415 0 : VisibilityIterator2::nRowsInChunk () const
416 : {
417 0 : CheckImplementationPointer ();
418 0 : return impl_p->nRowsInChunk ();
419 : }
420 :
421 : void
422 18 : VisibilityIterator2::setFrequencySelection (const FrequencySelection & selection)
423 : {
424 18 : FrequencySelections selections;
425 18 : selections.add (selection);
426 18 : setFrequencySelection (selections);
427 18 : }
428 :
429 : void
430 18 : VisibilityIterator2::setFrequencySelection (const FrequencySelections & selections)
431 : {
432 18 : ThrowIf (selections.size () != impl_p->getNMs (),
433 : String::format ("Frequency selection size, %d, does not VisibilityIterator # of MSs, %d.",
434 : impl_p->getNMs (), selections.size()));
435 :
436 18 : CheckImplementationPointer ();
437 18 : impl_p->setFrequencySelections (selections);
438 18 : }
439 :
440 :
441 :
442 : const vi::SubtableColumns &
443 0 : VisibilityIterator2::subtableColumns () const
444 : {
445 0 : CheckImplementationPointer ();
446 0 : return impl_p->subtableColumns ();
447 : }
448 :
449 : void
450 1 : VisibilityIterator2::useImagingWeight (const VisImagingWeight & viw)
451 : {
452 1 : CheckImplementationPointer ();
453 1 : impl_p->useImagingWeight(viw);
454 1 : }
455 :
456 : const VisImagingWeight &
457 0 : VisibilityIterator2::getImagingWeightGenerator () const
458 : {
459 0 : CheckImplementationPointer ();
460 0 : return impl_p->getImagingWeightGenerator ();
461 : }
462 :
463 : void
464 0 : VisibilityIterator2::writeFlag (const Cube<Bool>& flag)
465 : {
466 0 : CheckImplementationPointer ();
467 0 : impl_p->writeFlag (flag);
468 0 : }
469 :
470 : void
471 0 : VisibilityIterator2::writeFlagRow (const Vector<Bool>& rowflags)
472 : {
473 0 : CheckImplementationPointer ();
474 0 : impl_p->writeFlagRow (rowflags);
475 0 : }
476 :
477 : void
478 0 : VisibilityIterator2::writeWeightSpectrum (const Cube<Float>& wtsp)
479 : {
480 0 : CheckImplementationPointer ();
481 0 : impl_p->writeWeightSpectrum (wtsp);
482 0 : }
483 :
484 : void
485 0 : VisibilityIterator2::writeVisModel (const Cube<Complex>& modelCube)
486 : {
487 0 : CheckImplementationPointer ();
488 0 : impl_p->writeVisModel (modelCube);
489 0 : }
490 :
491 : void
492 0 : VisibilityIterator2::writeVisCorrected (const Cube<Complex>& CorrectedCube)
493 : {
494 0 : CheckImplementationPointer ();
495 0 : impl_p->writeVisCorrected (CorrectedCube);
496 0 : }
497 :
498 : void
499 0 : VisibilityIterator2::writeModel(const RecordInterface& record,
500 : bool isComponentList,
501 : bool addToExistingModel)
502 : {
503 0 : CheckImplementationPointer ();
504 0 : impl_p->writeModel (record, isComponentList, addToExistingModel);
505 0 : }
506 :
507 : void
508 0 : VisibilityIterator2::writeVisObserved (const Cube<Complex>& ObservedCube)
509 : {
510 0 : CheckImplementationPointer ();
511 0 : impl_p->writeVisObserved (ObservedCube);
512 0 : }
513 :
514 : //
515 : void
516 0 : VisibilityIterator2::initWeightSpectrum (const Cube<Float>& wtsp)
517 : {
518 0 : CheckImplementationPointer ();
519 0 : impl_p->initWeightSpectrum (wtsp);
520 0 : }
521 :
522 : void
523 0 : VisibilityIterator2::setWeightScaling (CountedPtr<WeightScaling> weightScaling)
524 : {
525 0 : CheckImplementationPointer ();
526 :
527 0 : impl_p->setWeightScaling (weightScaling);
528 0 : }
529 :
530 : Bool
531 0 : VisibilityIterator2::hasWeightScaling () const
532 : {
533 0 : CheckImplementationPointer ();
534 :
535 0 : return impl_p->hasWeightScaling ();
536 : }
537 :
538 0 : const casacore::MSAntennaColumns& VisibilityIterator2::antennaSubtablecols() const
539 : {
540 0 : CheckImplementationPointer ();
541 :
542 0 : return impl_p->antennaSubtablecols ();
543 : }
544 :
545 0 : const casacore::MSDataDescColumns& VisibilityIterator2::dataDescriptionSubtablecols() const
546 : {
547 0 : CheckImplementationPointer ();
548 :
549 0 : return impl_p->dataDescriptionSubtablecols ();
550 : }
551 :
552 0 : const casacore::MSFeedColumns& VisibilityIterator2::feedSubtablecols() const
553 : {
554 0 : CheckImplementationPointer ();
555 :
556 0 : return impl_p->feedSubtablecols ();
557 : }
558 :
559 0 : const casacore::MSFieldColumns& VisibilityIterator2::fieldSubtablecols() const
560 : {
561 0 : CheckImplementationPointer ();
562 :
563 0 : return impl_p->fieldSubtablecols ();
564 : }
565 :
566 0 : const casacore::MSFlagCmdColumns& VisibilityIterator2::flagCmdSubtablecols() const
567 : {
568 0 : CheckImplementationPointer ();
569 :
570 0 : return impl_p->flagCmdSubtablecols ();
571 : }
572 :
573 0 : const casacore::MSHistoryColumns& VisibilityIterator2::historySubtablecols() const
574 : {
575 0 : CheckImplementationPointer ();
576 :
577 0 : return impl_p->historySubtablecols ();
578 : }
579 :
580 0 : const casacore::MSObservationColumns& VisibilityIterator2::observationSubtablecols() const
581 : {
582 0 : CheckImplementationPointer ();
583 :
584 0 : return impl_p->observationSubtablecols ();
585 : }
586 :
587 0 : const casacore::MSPointingColumns& VisibilityIterator2::pointingSubtablecols() const
588 : {
589 0 : CheckImplementationPointer ();
590 :
591 0 : return impl_p->pointingSubtablecols ();
592 : }
593 :
594 0 : const casacore::MSPolarizationColumns& VisibilityIterator2::polarizationSubtablecols() const
595 : {
596 0 : CheckImplementationPointer ();
597 :
598 0 : return impl_p->polarizationSubtablecols ();
599 : }
600 :
601 0 : const casacore::MSProcessorColumns& VisibilityIterator2::processorSubtablecols() const
602 : {
603 0 : CheckImplementationPointer ();
604 :
605 0 : return impl_p->processorSubtablecols ();
606 : }
607 :
608 0 : const casacore::MSSpWindowColumns& VisibilityIterator2::spectralWindowSubtablecols() const
609 : {
610 0 : CheckImplementationPointer ();
611 :
612 0 : return impl_p->spectralWindowSubtablecols ();
613 : }
614 :
615 0 : const casacore::MSStateColumns& VisibilityIterator2::stateSubtablecols() const
616 : {
617 0 : CheckImplementationPointer ();
618 :
619 0 : return impl_p->stateSubtablecols ();
620 : }
621 :
622 0 : const casacore::MSDopplerColumns& VisibilityIterator2::dopplerSubtablecols() const
623 : {
624 0 : CheckImplementationPointer ();
625 :
626 0 : return impl_p->dopplerSubtablecols ();
627 : }
628 :
629 0 : const casacore::MSFreqOffsetColumns& VisibilityIterator2::freqOffsetSubtablecols() const
630 : {
631 0 : CheckImplementationPointer ();
632 :
633 0 : return impl_p->freqOffsetSubtablecols ();
634 : }
635 :
636 0 : const casacore::MSSourceColumns& VisibilityIterator2::sourceSubtablecols() const
637 : {
638 0 : CheckImplementationPointer ();
639 :
640 0 : return impl_p->sourceSubtablecols ();
641 : }
642 :
643 0 : const casacore::MSSysCalColumns& VisibilityIterator2::sysCalSubtablecols() const
644 : {
645 0 : CheckImplementationPointer ();
646 :
647 0 : return impl_p->sysCalSubtablecols ();
648 : }
649 :
650 0 : const casacore::MSWeatherColumns& VisibilityIterator2::weatherSubtablecols() const
651 : {
652 0 : CheckImplementationPointer ();
653 :
654 0 : return impl_p->weatherSubtablecols ();
655 : }
656 :
657 19 : SubtableColumns::SubtableColumns (CountedPtr <MSIter> msIter)
658 19 : : msIter_p (msIter)
659 19 : {}
660 :
661 : const MSAntennaColumns&
662 0 : SubtableColumns::antenna() const
663 : {
664 0 : return msIter_p->msColumns().antenna();
665 : }
666 :
667 : const MSDataDescColumns&
668 3294039 : SubtableColumns::dataDescription() const
669 : {
670 3294039 : return msIter_p->msColumns().dataDescription();
671 : }
672 :
673 : const MSFeedColumns&
674 0 : SubtableColumns::feed() const
675 : {
676 0 : return msIter_p->msColumns().feed();
677 : }
678 :
679 : const MSFieldColumns&
680 2394 : SubtableColumns::field() const
681 : {
682 2394 : return msIter_p->msColumns().field();
683 : }
684 :
685 : const MSFlagCmdColumns&
686 0 : SubtableColumns::flagCmd() const
687 : {
688 0 : return msIter_p->msColumns().flagCmd();
689 : }
690 :
691 : const MSHistoryColumns&
692 0 : SubtableColumns::history() const
693 : {
694 0 : return msIter_p->msColumns().history();
695 : }
696 :
697 : const MSObservationColumns&
698 1206 : SubtableColumns::observation() const
699 : {
700 1206 : return msIter_p->msColumns().observation();
701 : }
702 :
703 : const MSPointingColumns&
704 0 : SubtableColumns::pointing() const
705 : {
706 0 : return msIter_p->msColumns().pointing();
707 : }
708 :
709 : const MSPolarizationColumns&
710 6517 : SubtableColumns::polarization() const
711 : {
712 :
713 6517 : return msIter_p->msColumns().polarization();
714 : }
715 :
716 : const MSProcessorColumns&
717 0 : SubtableColumns::processor() const
718 : {
719 0 : return msIter_p->msColumns().processor();
720 : }
721 :
722 : const MSSpWindowColumns&
723 7245 : SubtableColumns::spectralWindow() const
724 : {
725 :
726 7245 : return msIter_p->msColumns().spectralWindow();
727 : }
728 :
729 : const MSStateColumns&
730 0 : SubtableColumns::state() const
731 : {
732 0 : return msIter_p->msColumns().state();
733 : }
734 :
735 : const MSDopplerColumns&
736 0 : SubtableColumns::doppler() const
737 : {
738 0 : return msIter_p->msColumns().doppler();
739 : }
740 :
741 : const MSFreqOffsetColumns&
742 0 : SubtableColumns::freqOffset() const
743 : {
744 0 : return msIter_p->msColumns().freqOffset();
745 : }
746 :
747 : const MSSourceColumns&
748 0 : SubtableColumns::source() const
749 : {
750 0 : return msIter_p->msColumns().source();
751 : }
752 :
753 : const MSSysCalColumns&
754 0 : SubtableColumns::sysCal() const
755 : {
756 0 : return msIter_p->msColumns().sysCal();
757 : }
758 :
759 : const MSWeatherColumns&
760 0 : SubtableColumns::weather() const
761 : {
762 0 : return msIter_p->msColumns().weather();
763 : }
764 :
765 :
766 : } // end namespace vi
767 :
768 :
769 : using namespace casacore;
770 : } // end namespace casa
|
