Line data Source code
1 : #include <msvis/MSVis/TransformingVi2.h>
2 :
3 : #include <casacore/measures/Measures/MDirection.h>
4 : #include <casacore/measures/Measures/MEpoch.h>
5 : #include <casacore/measures/Measures/MPosition.h>
6 : #include <stdcasa/UtilJ.h>
7 : #include <msvis/MSVis/VisibilityIterator2.h>
8 : #include <msvis/MSVis/VisBuffer2.h>
9 :
10 : //#include <casa/Arrays/Cube.h>
11 : //#include <casa/Arrays/Matrix.h>
12 : //#include <casa/Arrays/Slicer.h>
13 : //#include <casa/BasicSL/String.h>
14 : //#include <casa/Containers/Stack.h>
15 : //#include <casa/Quanta/MVDoppler.h>
16 : //#include <casa/aips.h>
17 : //#include <measures/Measures/MCDoppler.h>
18 : //#include <measures/Measures/MDoppler.h>
19 : //#include <measures/Measures/MeasConvert.h>
20 : //#include <measures/Measures/Stokes.h>
21 : //#include <ms/MSOper/MSDerivedValues.h>
22 : //#include <ms/MeasurementSets/MSIter.h>
23 : //#include <ms/MeasurementSets/MSColumns.h>
24 : //#include <ms/MeasurementSets/MeasurementSet.h>
25 : //#include <scimath/Mathematics/RigidVector.h>
26 : //#include <scimath/Mathematics/SquareMatrix.h>
27 : //#include <msvis/MSVis/StokesVector.h>
28 : //#include <msvis/MSVis/VisBufferComponents2.h>
29 : //#include <msvis/MSVis/VisImagingWeight.h>
30 : //#include <msvis/MSVis/VisibilityIterator2.h>
31 : //#include <tables/Tables/ArrayColumn.h>
32 : //#include <tables/Tables/ScalarColumn.h>
33 :
34 : #define Tvi2NotImplemented() {Throw ("Not implemented.");}
35 :
36 : using namespace casacore;
37 : using namespace casa::utilj;
38 :
39 : using namespace casacore;
40 : namespace casa {
41 :
42 : namespace vi {
43 :
44 875 : TransformingVi2::TransformingVi2 (ViImplementation2 * inputVi)
45 : : inputVii_p (inputVi),
46 875 : vb_p (0)
47 875 : {}
48 :
49 875 : TransformingVi2::~TransformingVi2 ()
50 : {
51 875 : delete inputVii_p;
52 875 : delete vb_p;
53 875 : }
54 :
55 : void
56 3801 : TransformingVi2::next ()
57 : {
58 3801 : getVii()->next ();
59 3801 : }
60 :
61 : Bool
62 0 : TransformingVi2::allBeamOffsetsZero () const
63 : {
64 0 : return getVii()->allBeamOffsetsZero ();
65 : }
66 :
67 : void
68 480484 : TransformingVi2::antenna1 (Vector<Int> & ant1) const
69 : {
70 480484 : getVii()->antenna1 (ant1);
71 480484 : }
72 :
73 : void
74 480480 : TransformingVi2::antenna2 (Vector<Int> & ant2) const
75 : {
76 480480 : getVii()->antenna2 (ant2);
77 480480 : }
78 :
79 : const Vector<String> &
80 0 : TransformingVi2::antennaMounts () const
81 : {
82 0 : return getVii()->antennaMounts ();
83 : }
84 :
85 : void
86 74141 : TransformingVi2::arrayIds (Vector<Int>& ids) const
87 : {
88 74141 : return getVii()->arrayIds (ids);
89 : }
90 :
91 : const Vector<MDirection> &
92 0 : TransformingVi2::azel (Double time) const
93 : {
94 0 : return getVii()->azel (time);
95 : }
96 :
97 : MDirection
98 0 : TransformingVi2::azel0 (Double time) const
99 : {
100 0 : return getVii()->azel0 (time);
101 : }
102 :
103 : void
104 521270 : TransformingVi2::configureNewSubchunk (){
105 :
106 521270 : configureNewSubchunk (msId(), // always the first MS
107 521270 : msName(),
108 521270 : isNewMs(),
109 521270 : isNewArrayId (),
110 521270 : isNewFieldId (),
111 521270 : isNewSpectralWindow (),
112 521270 : getSubchunkId (),
113 521270 : nRowsPerShape(),
114 521270 : nChannelsPerShape(),
115 521270 : nCorrelationsPerShape(),
116 1042540 : getCorrelations(),
117 1042540 : getCorrelationTypesDefined(),
118 1042540 : getCorrelationTypesSelected(),
119 1042540 : getWeightScaling());
120 521270 : }
121 :
122 : void
123 521270 : TransformingVi2::configureNewSubchunk (Int msId, const String & msName, Bool isNewMs,
124 : Bool isNewArrayId, Bool isNewFieldId,
125 : Bool isNewSpectralWindow, const Subchunk & subchunk,
126 : const casacore::Vector<casacore::rownr_t>& nRowsPerShape,
127 : const casacore::Vector<casacore::Int>& nChannelsPerShape,
128 : const casacore::Vector<casacore::Int>& nCorrelationsPerShape,
129 : const Vector<Int> & correlations,
130 : const Vector<Stokes::StokesTypes> & correlationsDefined,
131 : const Vector<Stokes::StokesTypes> & correlationsSelected,
132 : CountedPtr<WeightScaling> weightScaling)
133 : {
134 1042540 : getVisBuffer()->configureNewSubchunk (msId, // always the first MS
135 : msName,
136 : isNewMs,
137 : isNewArrayId,
138 : isNewFieldId,
139 : isNewSpectralWindow,
140 : subchunk,
141 : nRowsPerShape,
142 : nChannelsPerShape,
143 : nCorrelationsPerShape,
144 : correlations,
145 : correlationsDefined,
146 : correlationsSelected,
147 521270 : weightScaling);
148 521270 : }
149 :
150 :
151 :
152 : void
153 56254 : TransformingVi2::corrType (Vector<Int> & corrTypes) const
154 : {
155 56254 : getVii()->corrType (corrTypes);
156 56254 : }
157 :
158 : Int
159 95661 : TransformingVi2::dataDescriptionId () const
160 : {
161 95661 : return getVii()->dataDescriptionId ();
162 : }
163 :
164 : void
165 73913 : TransformingVi2::dataDescriptionIds(Vector<int>& ddIds) const
166 : {
167 73913 : getVii()->dataDescriptionIds (ddIds);
168 73913 : }
169 :
170 : Bool
171 1672 : TransformingVi2::existsColumn (VisBufferComponent2 id) const
172 : {
173 1672 : return getVii()->existsColumn (id);
174 : }
175 :
176 : void
177 419331 : TransformingVi2::exposure (Vector<Double> & expo) const
178 : {
179 419331 : getVii()->exposure (expo);
180 419331 : }
181 :
182 : void
183 12814 : TransformingVi2::feed1 (Vector<Int> & fd1) const
184 : {
185 12814 : getVii()->feed1 (fd1);
186 12814 : }
187 :
188 : void
189 12810 : TransformingVi2::feed2 (Vector<Int> & fd2) const
190 : {
191 12810 : getVii()->feed2 (fd2);
192 12810 : }
193 :
194 : const Vector<Float> &
195 74612 : TransformingVi2::feed_pa (Double time) const
196 : {
197 74612 : return getVii()->feed_pa (time);
198 : }
199 :
200 : void
201 74141 : TransformingVi2::fieldIds (Vector<Int>& ids) const
202 : {
203 74141 : return getVii()->fieldIds (ids);
204 : }
205 :
206 : String
207 0 : TransformingVi2::fieldName () const
208 : {
209 0 : return getVii()->fieldName ();
210 : }
211 :
212 : void
213 5109 : TransformingVi2::flag (Cube<Bool> & flags) const
214 : {
215 5109 : getVii()->flag (flags);
216 5109 : }
217 :
218 : void
219 0 : TransformingVi2::flag (Vector<Cube<Bool>> & flags) const
220 : {
221 0 : getVii()->flag (flags);
222 0 : }
223 :
224 : void
225 0 : TransformingVi2::flag (Matrix<Bool> & flags) const
226 : {
227 0 : getVii()->flag (flags);
228 0 : }
229 :
230 : void
231 0 : TransformingVi2::flagCategory (Array<Bool> & flagCategories) const
232 : {
233 0 : getVii()->flagCategory (flagCategories);
234 0 : }
235 :
236 : Bool
237 0 : TransformingVi2::flagCategoryExists () const
238 : {
239 0 : return getVii()->flagCategoryExists ();
240 : }
241 :
242 : void
243 24858 : TransformingVi2::flagRow (Vector<Bool> & rowflags) const
244 : {
245 24858 : getVii()->flagRow (rowflags);
246 24858 : }
247 :
248 : void
249 0 : TransformingVi2::floatData (Cube<Float> & fcube) const
250 : {
251 0 : getVii()->floatData (fcube);
252 0 : }
253 :
254 : void
255 0 : TransformingVi2::floatData (Vector<Cube<Float>> & fcube) const
256 : {
257 0 : getVii()->floatData (fcube);
258 0 : }
259 :
260 : const Cube<RigidVector<Double, 2> > &
261 0 : TransformingVi2::getBeamOffsets () const
262 : {
263 0 : return getVii()->getBeamOffsets ();
264 : }
265 :
266 : Vector<Int>
267 1134 : TransformingVi2::getChannels (Double time, Int frameOfReference,
268 : Int spectralWindowId, Int msId) const
269 : {
270 1134 : return getVii()->getChannels (time, frameOfReference,
271 1134 : spectralWindowId, msId);
272 : }
273 :
274 : Vector<Int>
275 742733 : TransformingVi2::getCorrelations () const
276 : {
277 742733 : return getVii()->getCorrelations();
278 : }
279 :
280 : Vector<Stokes::StokesTypes>
281 742733 : TransformingVi2::getCorrelationTypesDefined () const
282 : {
283 742733 : return getVii()->getCorrelationTypesDefined();
284 : }
285 :
286 : Vector<Stokes::StokesTypes>
287 742733 : TransformingVi2::getCorrelationTypesSelected () const
288 : {
289 742733 : return getVii()->getCorrelationTypesSelected();
290 : }
291 :
292 : MEpoch
293 0 : TransformingVi2::getEpoch () const
294 : {
295 0 : return getVii()->getEpoch ();
296 : }
297 :
298 : Vector<Double>
299 58544 : TransformingVi2::getFrequencies (Double time, Int frameOfReference,
300 : Int spectralWindowId, Int msId) const
301 : {
302 58544 : return getVii()->getFrequencies (time, frameOfReference,
303 58544 : spectralWindowId, msId);
304 : }
305 :
306 : Vector<Double>
307 853 : TransformingVi2::getChanWidths (Double time, Int frameOfReference,
308 : Int spectralWindowId, Int msId) const
309 : {
310 853 : return getVii()->getChanWidths (time, frameOfReference,
311 853 : spectralWindowId, msId);
312 : }
313 :
314 : const VisImagingWeight &
315 0 : TransformingVi2::getImagingWeightGenerator () const
316 : {
317 0 : return getVii()->getImagingWeightGenerator ();
318 : }
319 :
320 : Double
321 0 : TransformingVi2::getInterval () const
322 : {
323 0 : return getVii()->getInterval ();
324 : }
325 :
326 : Int
327 93 : TransformingVi2::getNMs () const
328 : {
329 93 : return getVii()->getNMs ();
330 : }
331 :
332 : MFrequency::Types
333 0 : TransformingVi2::getObservatoryFrequencyType () const
334 : {
335 0 : return getVii()->getObservatoryFrequencyType ();
336 : }
337 :
338 : MPosition
339 0 : TransformingVi2::getObservatoryPosition () const
340 : {
341 0 : return getVii()->getObservatoryPosition ();
342 : }
343 :
344 : std::pair<bool, casacore::MDirection>
345 0 : TransformingVi2::getPointingAngle (int antenna, double time) const
346 : {
347 0 : return getVii()->getPointingAngle (antenna, time);
348 : }
349 :
350 : Vector<Float>
351 0 : TransformingVi2::getReceptor0Angle ()
352 : {
353 0 : return getVii()->getReceptor0Angle ();
354 : }
355 :
356 : Int
357 75836 : TransformingVi2::getReportingFrameOfReference () const
358 : {
359 75836 : return getVii()->getReportingFrameOfReference ();
360 : }
361 :
362 : void
363 3559 : TransformingVi2::getRowIds (Vector<rownr_t> & rowids) const
364 : {
365 3559 : getVii()->getRowIds (rowids);
366 3559 : }
367 :
368 : const SortColumns &
369 0 : TransformingVi2::getSortColumns () const
370 : {
371 0 : return getVii()->getSortColumns ();
372 : }
373 :
374 : const SpectralWindowChannels &
375 0 : TransformingVi2::getSpectralWindowChannels (Int msId, Int spectralWindowId) const
376 : {
377 0 : return getVii()->getSpectralWindowChannels (msId, spectralWindowId);
378 : }
379 :
380 : Subchunk
381 750389 : TransformingVi2::getSubchunkId () const
382 : {
383 750389 : return getVii()->getSubchunkId ();
384 : }
385 :
386 : ViImplementation2 *
387 24759916 : TransformingVi2::getVii () const
388 : {
389 24759916 : Assert (inputVii_p != 0);
390 :
391 24759916 : return inputVii_p;
392 : }
393 :
394 : Double
395 0 : TransformingVi2::hourang (Double time) const
396 : {
397 0 : return getVii()->hourang (time);
398 : }
399 :
400 : Bool
401 750141 : TransformingVi2::isNewArrayId () const
402 : {
403 750141 : return getVii()->isNewArrayId ();
404 : }
405 :
406 : Bool
407 750141 : TransformingVi2::isNewFieldId () const
408 : {
409 750141 : return getVii()->isNewFieldId ();
410 : }
411 :
412 : Bool
413 760892 : TransformingVi2::isNewMs () const
414 : {
415 760892 : return getVii()->isNewMs ();
416 : }
417 :
418 : Bool
419 750141 : TransformingVi2::isNewSpectralWindow () const
420 : {
421 750141 : return getVii()->isNewSpectralWindow ();
422 : }
423 :
424 : Bool
425 0 : TransformingVi2::isWritable () const
426 : {
427 0 : return getVii()->isWritable ();
428 : }
429 :
430 : void
431 0 : TransformingVi2::jonesC (Vector<SquareMatrix<Complex, 2> > & cjones) const
432 : {
433 0 : getVii()->jonesC (cjones);
434 0 : }
435 :
436 : Bool
437 563571 : TransformingVi2::more () const
438 : {
439 563571 : return getVii()->more ();
440 : }
441 :
442 : Bool
443 118436 : TransformingVi2::moreChunks () const
444 : {
445 118436 : return getVii()->moreChunks ();
446 : }
447 :
448 : void
449 282 : TransformingVi2::result(casacore::Record &res) const
450 : {
451 282 : return getVii()->result(res);
452 : }
453 :
454 : const MeasurementSet &
455 907 : TransformingVi2::ms () const
456 : {
457 907 : return getVii()->ms ();
458 : }
459 :
460 : Int
461 1199972 : TransformingVi2::msId () const
462 : {
463 1199972 : return getVii()->msId ();
464 : }
465 :
466 750177 : String TransformingVi2::msName () const
467 : {
468 750177 : return getVii()->msName ();
469 : }
470 :
471 : Int
472 201445 : TransformingVi2::nAntennas () const
473 : {
474 201445 : return getVii()->nAntennas ();
475 : }
476 :
477 : Int
478 0 : TransformingVi2::nDataDescriptionIds () const
479 : {
480 0 : return getVii()->nDataDescriptionIds ();
481 : }
482 :
483 : Int
484 390 : TransformingVi2::nPolarizationIds () const
485 : {
486 390 : return getVii()->nPolarizationIds ();
487 : }
488 :
489 : rownr_t
490 6998 : TransformingVi2::nRows () const
491 : {
492 6998 : return getVii()->nRows ();
493 : }
494 :
495 : rownr_t
496 0 : TransformingVi2::nShapes () const
497 : {
498 0 : return getVii()->nShapes ();
499 : }
500 :
501 : const casacore::Vector<casacore::rownr_t>&
502 750141 : TransformingVi2::nRowsPerShape () const
503 : {
504 750141 : return getVii()->nRowsPerShape ();
505 : }
506 :
507 : const casacore::Vector<casacore::Int>&
508 300310 : TransformingVi2::nChannelsPerShape () const
509 : {
510 300310 : return getVii()->nChannelsPerShape ();
511 : }
512 :
513 : const casacore::Vector<casacore::Int>&
514 742733 : TransformingVi2::nCorrelationsPerShape () const
515 : {
516 742733 : return getVii()->nCorrelationsPerShape ();
517 : }
518 :
519 : rownr_t
520 258 : TransformingVi2::nRowsInChunk () const
521 : {
522 258 : return getVii()->nRowsInChunk ();
523 : }
524 :
525 : rownr_t
526 0 : TransformingVi2::nRowsViWillSweep () const
527 : {
528 0 : return getVii()->nRowsViWillSweep ();
529 : }
530 :
531 : Int
532 21227 : TransformingVi2::nSpectralWindows () const
533 : {
534 21227 : return getVii()->nSpectralWindows ();
535 : }
536 :
537 0 : Int TransformingVi2::nTimes() const {
538 0 : return getVii()->nTimes();
539 : }
540 :
541 : void
542 78854 : TransformingVi2::nextChunk ()
543 : {
544 78854 : getVii()->nextChunk ();
545 78854 : }
546 :
547 : void
548 74141 : TransformingVi2::observationId (Vector<Int> & obsids) const
549 : {
550 74141 : getVii()->observationId (obsids);
551 74141 : }
552 :
553 : void
554 99 : TransformingVi2::origin ()
555 : {
556 99 : getVii()->origin ();
557 99 : }
558 :
559 : void
560 194 : TransformingVi2::originChunks (Bool forceRewind)
561 : {
562 194 : getVii()->originChunks (forceRewind);
563 194 : }
564 :
565 : const Vector<Float> &
566 0 : TransformingVi2::parang (Double time) const
567 : {
568 0 : return getVii()->parang (time);
569 : }
570 :
571 : const Float &
572 0 : TransformingVi2::parang0 (Double time) const
573 : {
574 0 : return getVii()->parang0 (time);
575 : }
576 :
577 : const MDirection &
578 573 : TransformingVi2::phaseCenter () const
579 : {
580 573 : return getVii()->phaseCenter ();
581 : }
582 :
583 : Int
584 573 : TransformingVi2::polFrame () const
585 : {
586 573 : return getVii()->polFrame ();
587 : }
588 :
589 : Int
590 574 : TransformingVi2::polarizationId () const
591 : {
592 574 : return getVii()->polarizationId ();
593 : }
594 :
595 : void
596 12810 : TransformingVi2::processorId (Vector<Int> & procids) const
597 : {
598 12810 : getVii()->processorId (procids);
599 12810 : }
600 :
601 : const Cube<Double> &
602 0 : TransformingVi2::receptorAngles () const
603 : {
604 0 : return getVii()->receptorAngles ();
605 : }
606 :
607 : void
608 74145 : TransformingVi2::scan (Vector<Int> & scans) const
609 : {
610 74145 : getVii()->scan (scans);
611 74145 : }
612 :
613 : void
614 93 : TransformingVi2::setFrequencySelections (const FrequencySelections & selection)
615 : {
616 93 : getVii()->setFrequencySelections (selection);
617 93 : }
618 :
619 : void
620 0 : TransformingVi2::setInterval (Double timeInterval)
621 : {
622 0 : getVii()->setInterval (timeInterval);
623 0 : }
624 :
625 : void
626 0 : TransformingVi2::setReportingFrameOfReference (Int frame)
627 : {
628 0 : getVii()->setReportingFrameOfReference (frame);
629 0 : }
630 :
631 : void
632 61 : TransformingVi2::setRowBlocking (rownr_t nRows)
633 : {
634 61 : getVii()->setRowBlocking (nRows);
635 61 : }
636 :
637 : rownr_t
638 13647 : TransformingVi2::getRowBlocking () const
639 : {
640 13647 : return getVii()->getRowBlocking ();
641 : }
642 :
643 : void
644 874 : TransformingVi2::setVisBuffer (VisBuffer2 * vb)
645 : {
646 874 : ThrowIf (vb_p != 0, "A VisBuffer is already associated with this VI");
647 :
648 874 : vb_p = vb;
649 874 : }
650 :
651 : void
652 217972 : TransformingVi2::sigma (Matrix<Float> & sig) const
653 : {
654 217972 : getVii()->sigma (sig);
655 217972 : }
656 :
657 : void
658 0 : TransformingVi2::sigma (Vector<Matrix<Float>> & sig) const
659 : {
660 0 : getVii()->sigma (sig);
661 0 : }
662 :
663 : void
664 38 : TransformingVi2::slurp () const
665 : {
666 38 : getVii()->slurp ();
667 38 : }
668 :
669 : String
670 0 : TransformingVi2::sourceName () const
671 : {
672 0 : return getVii()->sourceName ();
673 : }
674 :
675 : void
676 1128436 : TransformingVi2::spectralWindows (Vector<Int> & spws) const
677 : {
678 1128436 : getVii()->spectralWindows (spws);
679 1128436 : }
680 :
681 : void
682 0 : TransformingVi2::polarizationIds (Vector<Int> & spws) const
683 : {
684 0 : getVii()->polarizationIds (spws);
685 0 : }
686 :
687 : void
688 12982 : TransformingVi2::stateId (Vector<Int> & stateids) const
689 : {
690 12982 : getVii()->stateId (stateids);
691 12982 : }
692 :
693 : const vi::SubtableColumns &
694 0 : TransformingVi2::subtableColumns () const
695 : {
696 0 : return getVii()->subtableColumns ();
697 : }
698 :
699 : void
700 477117 : TransformingVi2::time (Vector<Double> & t) const
701 : {
702 477117 : getVii()->time (t);
703 477117 : }
704 :
705 : void
706 476875 : TransformingVi2::timeCentroid (Vector<Double> & t) const
707 : {
708 476875 : getVii()->timeCentroid (t);
709 476875 : }
710 :
711 : void
712 415772 : TransformingVi2::timeInterval (Vector<Double> & ti) const
713 : {
714 415772 : getVii()->timeInterval (ti);
715 415772 : }
716 :
717 : void
718 0 : TransformingVi2::useImagingWeight (const VisImagingWeight & imWgt)
719 : {
720 0 : getVii()->useImagingWeight (imWgt);
721 0 : }
722 :
723 : void
724 413677 : TransformingVi2::uvw (Matrix<Double> & uvwmat) const
725 : {
726 413677 : getVii()->uvw (uvwmat);
727 413677 : }
728 :
729 : void
730 0 : TransformingVi2::visibilityCorrected (Cube<Complex> & vis) const
731 : {
732 0 : getVii()->visibilityCorrected (vis);
733 0 : }
734 :
735 : void
736 0 : TransformingVi2::visibilityCorrected (Vector<Cube<Complex>> & vis) const
737 : {
738 0 : getVii()->visibilityCorrected (vis);
739 0 : }
740 :
741 : void
742 0 : TransformingVi2::visibilityModel (Cube<Complex> & vis) const
743 : {
744 0 : getVii()->visibilityModel (vis);
745 0 : }
746 :
747 : void
748 0 : TransformingVi2::visibilityModel (casacore::Vector<casacore::Cube<casacore::Complex>> & vis) const
749 : {
750 0 : getVii()->visibilityModel (vis);
751 0 : }
752 :
753 : void
754 120 : TransformingVi2::visibilityObserved (Cube<Complex> & vis) const
755 : {
756 120 : getVii()->visibilityObserved (vis);
757 120 : }
758 :
759 : void
760 0 : TransformingVi2::visibilityObserved (casacore::Vector<casacore::Cube<casacore::Complex>> & vis) const
761 : {
762 0 : getVii()->visibilityObserved (vis);
763 0 : }
764 :
765 : IPosition
766 1005979 : TransformingVi2::visibilityShape () const
767 : {
768 1005979 : return getVii()->visibilityShape ();
769 : }
770 :
771 : void
772 132 : TransformingVi2::weight (Matrix<Float> & wt) const
773 : {
774 132 : getVii()->weight (wt);
775 132 : }
776 :
777 : void
778 0 : TransformingVi2::weight (Vector<Matrix<Float>> & wt) const
779 : {
780 0 : getVii()->weight (wt);
781 0 : }
782 :
783 : void
784 682 : TransformingVi2::weightSpectrum (Cube<Float> & wtsp) const
785 : {
786 682 : getVii()->weightSpectrum (wtsp);
787 682 : }
788 :
789 : void
790 0 : TransformingVi2::weightSpectrum (Vector<Cube<Float>> & wtsp) const
791 : {
792 0 : getVii()->weightSpectrum (wtsp);
793 0 : }
794 :
795 : void
796 3335 : TransformingVi2::sigmaSpectrum (Cube<Float> & sigsp) const
797 : {
798 3335 : getVii()->sigmaSpectrum (sigsp);
799 3335 : }
800 :
801 : void
802 0 : TransformingVi2::sigmaSpectrum (Vector<Cube<Float>> & sigsp) const
803 : {
804 0 : getVii()->sigmaSpectrum (sigsp);
805 0 : }
806 :
807 : Bool
808 15934 : TransformingVi2::weightSpectrumExists () const
809 : {
810 15934 : return getVii()->weightSpectrumExists ();
811 : }
812 :
813 : Bool
814 194788 : TransformingVi2::sigmaSpectrumExists () const
815 : {
816 194788 : return getVii()->sigmaSpectrumExists ();
817 : }
818 :
819 : void
820 0 : TransformingVi2::writeBackChanges (VisBuffer2 * /*vb*/)
821 : {
822 0 : Tvi2NotImplemented ();
823 : }
824 :
825 : void
826 0 : TransformingVi2::writeFlag (const Matrix<Bool> & /*flag*/)
827 : {
828 0 : Tvi2NotImplemented ();
829 : }
830 :
831 : void
832 0 : TransformingVi2::writeFlag (const Cube<Bool> & /*flag*/)
833 : {
834 0 : Tvi2NotImplemented ();
835 : }
836 :
837 : void
838 0 : TransformingVi2::writeFlagCategory (const Array<Bool>& /*fc*/)
839 : {
840 0 : Tvi2NotImplemented ();
841 : }
842 :
843 : void
844 0 : TransformingVi2::writeFlagRow (const Vector<Bool> & /*rowflags*/)
845 : {
846 0 : Tvi2NotImplemented ();
847 : }
848 :
849 : void
850 0 : TransformingVi2::writeModel (const RecordInterface& /*rec*/, Bool /*iscomponentlist*/,
851 : Bool /*incremental*/)
852 : {
853 0 : Tvi2NotImplemented ();
854 : }
855 :
856 : void
857 0 : TransformingVi2::writeSigma (const Matrix<Float> & /*sig*/)
858 : {
859 0 : Tvi2NotImplemented ();
860 : }
861 :
862 : //void
863 : //TransformingVi2::writeSigmaMat (const Matrix<Float> & /*sigmat*/)
864 : //{
865 : // Tvi2NotImplemented ();
866 : //}
867 :
868 : //void
869 : //TransformingVi2::writeVisCorrected (const Matrix<CStokesVector> & /*visibilityStokes*/)
870 : //{
871 : // Tvi2NotImplemented ();
872 : //}
873 :
874 : void
875 0 : TransformingVi2::writeVisCorrected (const Cube<Complex> & /*vis*/)
876 : {
877 0 : Tvi2NotImplemented ();
878 : }
879 :
880 : //void
881 : //TransformingVi2::writeVisModel (const Matrix<CStokesVector> & /*visibilityStokes*/)
882 : //{
883 : // Tvi2NotImplemented ();
884 : //}
885 :
886 : void
887 0 : TransformingVi2::writeVisModel (const Cube<Complex> & /*vis*/)
888 : {
889 0 : Tvi2NotImplemented ();
890 : }
891 :
892 : //void
893 : //TransformingVi2::writeVisObserved (const Matrix<CStokesVector> & /*visibilityStokes*/)
894 : //{
895 : // Tvi2NotImplemented ();
896 : //}
897 :
898 : void
899 0 : TransformingVi2::writeVisObserved (const Cube<Complex> & /*vis*/)
900 : {
901 0 : Tvi2NotImplemented ();
902 : }
903 :
904 : void
905 0 : TransformingVi2::writeWeight (const Matrix<Float> & /*wt*/)
906 : {
907 0 : Tvi2NotImplemented ();
908 : }
909 :
910 : //void
911 : //TransformingVi2::writeWeightMat (const Matrix<Float> & /*wtmat*/)
912 : //{
913 : // Tvi2NotImplemented ();
914 : //}
915 :
916 : void
917 0 : TransformingVi2::writeWeightSpectrum (const Cube<Float> & /*wtsp*/)
918 : {
919 0 : Tvi2NotImplemented ();
920 : }
921 :
922 : void
923 0 : TransformingVi2::writeSigmaSpectrum (const Cube<Float> & /*wtsp*/)
924 : {
925 0 : Tvi2NotImplemented ();
926 : }
927 :
928 : void
929 202 : TransformingVi2::setWeightScaling (CountedPtr <WeightScaling> weightScaling)
930 : {
931 202 : getVii()->setWeightScaling(weightScaling);
932 202 : }
933 :
934 : Bool
935 0 : TransformingVi2::hasWeightScaling () const
936 : {
937 0 : return getVii()->hasWeightScaling();
938 : }
939 :
940 : CountedPtr<WeightScaling>
941 750141 : TransformingVi2::getWeightScaling () const
942 : {
943 750141 : return getVii()->getWeightScaling();
944 : }
945 :
946 : // -----------------------------------------------------------------------
947 : // Utility method to calculate FLAG_ROW from flag cube with the applicable convention
948 : // -----------------------------------------------------------------------
949 208 : void TransformingVi2::calculateFlagRowFromFlagCube (const Cube<Bool> &flagCube, Vector<Bool> &flagRow)
950 : {
951 : // Get original shape
952 416 : IPosition shape = flagCube.shape();
953 208 : size_t nCorr = shape(0);
954 208 : size_t nChan = shape(1);
955 208 : size_t nRows = shape(2);
956 :
957 : // Reshape flag cube to match the input shape
958 208 : flagRow.resize(nRows,false);
959 208 : flagRow = false;
960 :
961 208 : Bool rowFlagValue = false;
962 8412 : for (size_t row_i =0;row_i<nRows;row_i++)
963 : {
964 8204 : rowFlagValue = true;
965 57332 : for (size_t chan_i =0;chan_i<nChan;chan_i++)
966 : {
967 57088 : if (rowFlagValue)
968 : {
969 213800 : for (size_t corr_i =0;corr_i<nCorr;corr_i++)
970 : {
971 172632 : if (not flagCube(corr_i,chan_i,row_i))
972 : {
973 7960 : rowFlagValue = false;
974 7960 : break;
975 : }
976 : }
977 : }
978 : else
979 : {
980 7960 : break;
981 : }
982 : }
983 8204 : flagRow(row_i) = rowFlagValue;
984 : }
985 :
986 416 : return;
987 : }
988 :
989 : //**********************************************************************
990 : // Methods to access the subtables.
991 : //**********************************************************************
992 :
993 0 : const casacore::MSAntennaColumns& TransformingVi2::antennaSubtablecols() const
994 : {
995 0 : return getVii()->antennaSubtablecols();
996 : }
997 :
998 123 : const casacore::MSDataDescColumns& TransformingVi2::dataDescriptionSubtablecols() const
999 : {
1000 123 : return getVii()->dataDescriptionSubtablecols();
1001 : }
1002 :
1003 0 : const casacore::MSFeedColumns& TransformingVi2::feedSubtablecols() const
1004 : {
1005 0 : return getVii()->feedSubtablecols();
1006 : }
1007 :
1008 0 : const casacore::MSFieldColumns& TransformingVi2::fieldSubtablecols() const
1009 : {
1010 0 : return getVii()->fieldSubtablecols();
1011 : }
1012 :
1013 0 : const casacore::MSFlagCmdColumns& TransformingVi2::flagCmdSubtablecols() const
1014 : {
1015 0 : return getVii()->flagCmdSubtablecols();
1016 : }
1017 :
1018 0 : const casacore::MSHistoryColumns& TransformingVi2::historySubtablecols() const
1019 : {
1020 0 : return getVii()->historySubtablecols();
1021 : }
1022 :
1023 0 : const casacore::MSObservationColumns& TransformingVi2::observationSubtablecols() const
1024 : {
1025 0 : return getVii()->observationSubtablecols();
1026 : }
1027 :
1028 0 : const casacore::MSPointingColumns& TransformingVi2::pointingSubtablecols() const
1029 : {
1030 0 : return getVii()->pointingSubtablecols();
1031 : }
1032 :
1033 47 : const casacore::MSPolarizationColumns& TransformingVi2::polarizationSubtablecols() const
1034 : {
1035 47 : return getVii()->polarizationSubtablecols();
1036 : }
1037 :
1038 0 : const casacore::MSProcessorColumns& TransformingVi2::processorSubtablecols() const
1039 : {
1040 0 : return getVii()->processorSubtablecols();
1041 : }
1042 :
1043 541 : const casacore::MSSpWindowColumns& TransformingVi2::spectralWindowSubtablecols() const
1044 : {
1045 541 : return getVii()->spectralWindowSubtablecols();
1046 : }
1047 :
1048 40014 : const casacore::MSStateColumns& TransformingVi2::stateSubtablecols() const
1049 : {
1050 40014 : return getVii()->stateSubtablecols();
1051 : }
1052 :
1053 0 : const casacore::MSDopplerColumns& TransformingVi2::dopplerSubtablecols() const
1054 : {
1055 0 : return getVii()->dopplerSubtablecols();
1056 : }
1057 :
1058 0 : const casacore::MSFreqOffsetColumns& TransformingVi2::freqOffsetSubtablecols() const
1059 : {
1060 0 : return getVii()->freqOffsetSubtablecols();
1061 : }
1062 :
1063 0 : const casacore::MSSourceColumns& TransformingVi2::sourceSubtablecols() const
1064 : {
1065 0 : return getVii()->sourceSubtablecols();
1066 : }
1067 :
1068 0 : const casacore::MSSysCalColumns& TransformingVi2::sysCalSubtablecols() const
1069 : {
1070 0 : return getVii()->sysCalSubtablecols();
1071 : }
1072 :
1073 0 : const casacore::MSWeatherColumns& TransformingVi2::weatherSubtablecols() const
1074 : {
1075 0 : return getVii()->weatherSubtablecols();
1076 : }
1077 :
1078 :
1079 : } // end namespace vi
1080 :
1081 : using namespace casacore;
1082 : } // end namespace casa
|
