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 57 : TransformingVi2::TransformingVi2 (ViImplementation2 * inputVi)
45 57 : : inputVii_p (inputVi),
46 57 : vb_p (0)
47 57 : {}
48 :
49 57 : TransformingVi2::~TransformingVi2 ()
50 : {
51 57 : delete inputVii_p;
52 57 : delete vb_p;
53 57 : }
54 :
55 : void
56 0 : TransformingVi2::next ()
57 : {
58 0 : getVii()->next ();
59 0 : }
60 :
61 : Bool
62 0 : TransformingVi2::allBeamOffsetsZero () const
63 : {
64 0 : return getVii()->allBeamOffsetsZero ();
65 : }
66 :
67 : void
68 46 : TransformingVi2::antenna1 (Vector<Int> & ant1) const
69 : {
70 46 : getVii()->antenna1 (ant1);
71 46 : }
72 :
73 : void
74 46 : TransformingVi2::antenna2 (Vector<Int> & ant2) const
75 : {
76 46 : getVii()->antenna2 (ant2);
77 46 : }
78 :
79 : const Vector<String> &
80 0 : TransformingVi2::antennaMounts () const
81 : {
82 0 : return getVii()->antennaMounts ();
83 : }
84 :
85 : void
86 228 : TransformingVi2::arrayIds (Vector<Int>& ids) const
87 : {
88 228 : 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 262 : TransformingVi2::configureNewSubchunk (){
105 :
106 262 : configureNewSubchunk (msId(), // always the first MS
107 262 : msName(),
108 262 : isNewMs(),
109 262 : isNewArrayId (),
110 262 : isNewFieldId (),
111 262 : isNewSpectralWindow (),
112 262 : getSubchunkId (),
113 262 : nRowsPerShape(),
114 262 : nChannelsPerShape(),
115 262 : nCorrelationsPerShape(),
116 524 : getCorrelations(),
117 524 : getCorrelationTypesDefined(),
118 524 : getCorrelationTypesSelected(),
119 524 : getWeightScaling());
120 262 : }
121 :
122 : void
123 262 : 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 262 : 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 : weightScaling);
148 262 : }
149 :
150 :
151 :
152 : void
153 264 : TransformingVi2::corrType (Vector<Int> & corrTypes) const
154 : {
155 264 : getVii()->corrType (corrTypes);
156 264 : }
157 :
158 : Int
159 0 : TransformingVi2::dataDescriptionId () const
160 : {
161 0 : return getVii()->dataDescriptionId ();
162 : }
163 :
164 : void
165 0 : TransformingVi2::dataDescriptionIds(Vector<int>& ddIds) const
166 : {
167 0 : getVii()->dataDescriptionIds (ddIds);
168 0 : }
169 :
170 : Bool
171 0 : TransformingVi2::existsColumn (VisBufferComponent2 id) const
172 : {
173 0 : return getVii()->existsColumn (id);
174 : }
175 :
176 : void
177 0 : TransformingVi2::exposure (Vector<Double> & expo) const
178 : {
179 0 : getVii()->exposure (expo);
180 0 : }
181 :
182 : void
183 0 : TransformingVi2::feed1 (Vector<Int> & fd1) const
184 : {
185 0 : getVii()->feed1 (fd1);
186 0 : }
187 :
188 : void
189 0 : TransformingVi2::feed2 (Vector<Int> & fd2) const
190 : {
191 0 : getVii()->feed2 (fd2);
192 0 : }
193 :
194 : const Vector<Float> &
195 0 : TransformingVi2::feed_pa (Double time) const
196 : {
197 0 : return getVii()->feed_pa (time);
198 : }
199 :
200 : void
201 228 : TransformingVi2::fieldIds (Vector<Int>& ids) const
202 : {
203 228 : return getVii()->fieldIds (ids);
204 : }
205 :
206 : String
207 0 : TransformingVi2::fieldName () const
208 : {
209 0 : return getVii()->fieldName ();
210 : }
211 :
212 : void
213 0 : TransformingVi2::flag (Cube<Bool> & flags) const
214 : {
215 0 : getVii()->flag (flags);
216 0 : }
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 0 : TransformingVi2::flagRow (Vector<Bool> & rowflags) const
244 : {
245 0 : getVii()->flagRow (rowflags);
246 0 : }
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 19 : TransformingVi2::getChannels (Double time, Int frameOfReference,
268 : Int spectralWindowId, Int msId) const
269 : {
270 19 : return getVii()->getChannels (time, frameOfReference,
271 19 : spectralWindowId, msId);
272 : }
273 :
274 : Vector<Int>
275 333 : TransformingVi2::getCorrelations () const
276 : {
277 333 : return getVii()->getCorrelations();
278 : }
279 :
280 : Vector<Stokes::StokesTypes>
281 333 : TransformingVi2::getCorrelationTypesDefined () const
282 : {
283 333 : return getVii()->getCorrelationTypesDefined();
284 : }
285 :
286 : Vector<Stokes::StokesTypes>
287 333 : TransformingVi2::getCorrelationTypesSelected () const
288 : {
289 333 : return getVii()->getCorrelationTypesSelected();
290 : }
291 :
292 : MEpoch
293 0 : TransformingVi2::getEpoch () const
294 : {
295 0 : return getVii()->getEpoch ();
296 : }
297 :
298 : Vector<Double>
299 40 : TransformingVi2::getFrequencies (Double time, Int frameOfReference,
300 : Int spectralWindowId, Int msId) const
301 : {
302 40 : return getVii()->getFrequencies (time, frameOfReference,
303 40 : spectralWindowId, msId);
304 : }
305 :
306 : Vector<Double>
307 0 : TransformingVi2::getChanWidths (Double time, Int frameOfReference,
308 : Int spectralWindowId, Int msId) const
309 : {
310 0 : return getVii()->getChanWidths (time, frameOfReference,
311 0 : 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 1 : TransformingVi2::getNMs () const
328 : {
329 1 : 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 0 : TransformingVi2::getReportingFrameOfReference () const
358 : {
359 0 : return getVii()->getReportingFrameOfReference ();
360 : }
361 :
362 : void
363 0 : TransformingVi2::getRowIds (Vector<rownr_t> & rowids) const
364 : {
365 0 : getVii()->getRowIds (rowids);
366 0 : }
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 333 : TransformingVi2::getSubchunkId () const
382 : {
383 333 : return getVii()->getSubchunkId ();
384 : }
385 :
386 : ViImplementation2 *
387 33441 : TransformingVi2::getVii () const
388 : {
389 33441 : Assert (inputVii_p != 0);
390 :
391 33441 : 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 333 : TransformingVi2::isNewArrayId () const
402 : {
403 333 : return getVii()->isNewArrayId ();
404 : }
405 :
406 : Bool
407 333 : TransformingVi2::isNewFieldId () const
408 : {
409 333 : return getVii()->isNewFieldId ();
410 : }
411 :
412 : Bool
413 333 : TransformingVi2::isNewMs () const
414 : {
415 333 : return getVii()->isNewMs ();
416 : }
417 :
418 : Bool
419 333 : TransformingVi2::isNewSpectralWindow () const
420 : {
421 333 : 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 192 : TransformingVi2::more () const
438 : {
439 192 : return getVii()->more ();
440 : }
441 :
442 : Bool
443 70 : TransformingVi2::moreChunks () const
444 : {
445 70 : return getVii()->moreChunks ();
446 : }
447 :
448 : void
449 19 : TransformingVi2::result(casacore::Record &res) const
450 : {
451 19 : return getVii()->result(res);
452 : }
453 :
454 : const MeasurementSet &
455 0 : TransformingVi2::ms () const
456 : {
457 0 : return getVii()->ms ();
458 : }
459 :
460 : Int
461 666 : TransformingVi2::msId () const
462 : {
463 666 : return getVii()->msId ();
464 : }
465 :
466 333 : String TransformingVi2::msName () const
467 : {
468 333 : return getVii()->msName ();
469 : }
470 :
471 : Int
472 918 : TransformingVi2::nAntennas () const
473 : {
474 918 : return getVii()->nAntennas ();
475 : }
476 :
477 : Int
478 0 : TransformingVi2::nDataDescriptionIds () const
479 : {
480 0 : return getVii()->nDataDescriptionIds ();
481 : }
482 :
483 : Int
484 0 : TransformingVi2::nPolarizationIds () const
485 : {
486 0 : return getVii()->nPolarizationIds ();
487 : }
488 :
489 : rownr_t
490 0 : TransformingVi2::nRows () const
491 : {
492 0 : 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 333 : TransformingVi2::nRowsPerShape () const
503 : {
504 333 : return getVii()->nRowsPerShape ();
505 : }
506 :
507 : const casacore::Vector<casacore::Int>&
508 0 : TransformingVi2::nChannelsPerShape () const
509 : {
510 0 : return getVii()->nChannelsPerShape ();
511 : }
512 :
513 : const casacore::Vector<casacore::Int>&
514 333 : TransformingVi2::nCorrelationsPerShape () const
515 : {
516 333 : 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 106 : TransformingVi2::nSpectralWindows () const
533 : {
534 106 : return getVii()->nSpectralWindows ();
535 : }
536 :
537 0 : Int TransformingVi2::nTimes() const {
538 0 : return getVii()->nTimes();
539 : }
540 :
541 : void
542 70 : TransformingVi2::nextChunk ()
543 : {
544 70 : getVii()->nextChunk ();
545 70 : }
546 :
547 : void
548 228 : TransformingVi2::observationId (Vector<Int> & obsids) const
549 : {
550 228 : getVii()->observationId (obsids);
551 228 : }
552 :
553 : void
554 0 : TransformingVi2::origin ()
555 : {
556 0 : getVii()->origin ();
557 0 : }
558 :
559 : void
560 0 : TransformingVi2::originChunks (Bool forceRewind)
561 : {
562 0 : getVii()->originChunks (forceRewind);
563 0 : }
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 36 : TransformingVi2::phaseCenter () const
579 : {
580 36 : return getVii()->phaseCenter ();
581 : }
582 :
583 : Int
584 36 : TransformingVi2::polFrame () const
585 : {
586 36 : return getVii()->polFrame ();
587 : }
588 :
589 : Int
590 37 : TransformingVi2::polarizationId () const
591 : {
592 37 : return getVii()->polarizationId ();
593 : }
594 :
595 : void
596 0 : TransformingVi2::processorId (Vector<Int> & procids) const
597 : {
598 0 : getVii()->processorId (procids);
599 0 : }
600 :
601 : const Cube<Double> &
602 0 : TransformingVi2::receptorAngles () const
603 : {
604 0 : return getVii()->receptorAngles ();
605 : }
606 :
607 : void
608 228 : TransformingVi2::scan (Vector<Int> & scans) const
609 : {
610 228 : getVii()->scan (scans);
611 228 : }
612 :
613 : void
614 1 : TransformingVi2::setFrequencySelections (const FrequencySelections & selection)
615 : {
616 1 : getVii()->setFrequencySelections (selection);
617 1 : }
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 20 : TransformingVi2::setRowBlocking (rownr_t nRows)
633 : {
634 20 : getVii()->setRowBlocking (nRows);
635 20 : }
636 :
637 : rownr_t
638 0 : TransformingVi2::getRowBlocking () const
639 : {
640 0 : return getVii()->getRowBlocking ();
641 : }
642 :
643 : void
644 57 : TransformingVi2::setVisBuffer (VisBuffer2 * vb)
645 : {
646 57 : ThrowIf (vb_p != 0, "A VisBuffer is already associated with this VI");
647 :
648 57 : vb_p = vb;
649 57 : }
650 :
651 : void
652 0 : TransformingVi2::sigma (Matrix<Float> & sig) const
653 : {
654 0 : getVii()->sigma (sig);
655 0 : }
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 561 : TransformingVi2::spectralWindows (Vector<Int> & spws) const
677 : {
678 561 : getVii()->spectralWindows (spws);
679 561 : }
680 :
681 : void
682 0 : TransformingVi2::polarizationIds (Vector<Int> & spws) const
683 : {
684 0 : getVii()->polarizationIds (spws);
685 0 : }
686 :
687 : void
688 0 : TransformingVi2::stateId (Vector<Int> & stateids) const
689 : {
690 0 : getVii()->stateId (stateids);
691 0 : }
692 :
693 : const vi::SubtableColumns &
694 0 : TransformingVi2::subtableColumns () const
695 : {
696 0 : return getVii()->subtableColumns ();
697 : }
698 :
699 : void
700 39 : TransformingVi2::time (Vector<Double> & t) const
701 : {
702 39 : getVii()->time (t);
703 39 : }
704 :
705 : void
706 0 : TransformingVi2::timeCentroid (Vector<Double> & t) const
707 : {
708 0 : getVii()->timeCentroid (t);
709 0 : }
710 :
711 : void
712 0 : TransformingVi2::timeInterval (Vector<Double> & ti) const
713 : {
714 0 : getVii()->timeInterval (ti);
715 0 : }
716 :
717 : void
718 0 : TransformingVi2::useImagingWeight (const VisImagingWeight & imWgt)
719 : {
720 0 : getVii()->useImagingWeight (imWgt);
721 0 : }
722 :
723 : void
724 0 : TransformingVi2::uvw (Matrix<Double> & uvwmat) const
725 : {
726 0 : getVii()->uvw (uvwmat);
727 0 : }
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 0 : TransformingVi2::visibilityObserved (Cube<Complex> & vis) const
755 : {
756 0 : getVii()->visibilityObserved (vis);
757 0 : }
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 72 : TransformingVi2::visibilityShape () const
767 : {
768 72 : return getVii()->visibilityShape ();
769 : }
770 :
771 : void
772 0 : TransformingVi2::weight (Matrix<Float> & wt) const
773 : {
774 0 : getVii()->weight (wt);
775 0 : }
776 :
777 : void
778 0 : TransformingVi2::weight (Vector<Matrix<Float>> & wt) const
779 : {
780 0 : getVii()->weight (wt);
781 0 : }
782 :
783 : void
784 0 : TransformingVi2::weightSpectrum (Cube<Float> & wtsp) const
785 : {
786 0 : getVii()->weightSpectrum (wtsp);
787 0 : }
788 :
789 : void
790 0 : TransformingVi2::weightSpectrum (Vector<Cube<Float>> & wtsp) const
791 : {
792 0 : getVii()->weightSpectrum (wtsp);
793 0 : }
794 :
795 : void
796 0 : TransformingVi2::sigmaSpectrum (Cube<Float> & sigsp) const
797 : {
798 0 : getVii()->sigmaSpectrum (sigsp);
799 0 : }
800 :
801 : void
802 0 : TransformingVi2::sigmaSpectrum (Vector<Cube<Float>> & sigsp) const
803 : {
804 0 : getVii()->sigmaSpectrum (sigsp);
805 0 : }
806 :
807 : Bool
808 0 : TransformingVi2::weightSpectrumExists () const
809 : {
810 0 : return getVii()->weightSpectrumExists ();
811 : }
812 :
813 : Bool
814 0 : TransformingVi2::sigmaSpectrumExists () const
815 : {
816 0 : 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 19 : TransformingVi2::setWeightScaling (CountedPtr <WeightScaling> weightScaling)
930 : {
931 19 : getVii()->setWeightScaling(weightScaling);
932 19 : }
933 :
934 : Bool
935 0 : TransformingVi2::hasWeightScaling () const
936 : {
937 0 : return getVii()->hasWeightScaling();
938 : }
939 :
940 : CountedPtr<WeightScaling>
941 333 : TransformingVi2::getWeightScaling () const
942 : {
943 333 : 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 208 : 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 208 : }
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 0 : const casacore::MSDataDescColumns& TransformingVi2::dataDescriptionSubtablecols() const
999 : {
1000 0 : 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 0 : const casacore::MSPolarizationColumns& TransformingVi2::polarizationSubtablecols() const
1034 : {
1035 0 : return getVii()->polarizationSubtablecols();
1036 : }
1037 :
1038 0 : const casacore::MSProcessorColumns& TransformingVi2::processorSubtablecols() const
1039 : {
1040 0 : return getVii()->processorSubtablecols();
1041 : }
1042 :
1043 0 : const casacore::MSSpWindowColumns& TransformingVi2::spectralWindowSubtablecols() const
1044 : {
1045 0 : return getVii()->spectralWindowSubtablecols();
1046 : }
1047 :
1048 0 : const casacore::MSStateColumns& TransformingVi2::stateSubtablecols() const
1049 : {
1050 0 : 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
|
