Line data Source code
1 : //# MSTransformBufferImpl.h: This file contains the implementation of the MSTransformBufferImpl.h class.
2 : //#
3 : //# CASA - Common Astronomy Software Applications (http://casa.nrao.edu/)
4 : //# Copyright (C) Associated Universities, Inc. Washington DC, USA 2011, All rights reserved.
5 : //# Copyright (C) European Southern Observatory, 2011, All rights reserved.
6 : //#
7 : //# This library is free software; you can redistribute it and/or
8 : //# modify it under the terms of the GNU Lesser General Public
9 : //# License as published by the Free software Foundation; either
10 : //# version 2.1 of the License, or (at your option) any later version.
11 : //#
12 : //# This library is distributed in the hope that it will be useful,
13 : //# but WITHOUT ANY WARRANTY, without even the implied warranty of
14 : //# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 : //# Lesser General Public License for more details.
16 : //#
17 : //# You should have received a copy of the GNU Lesser General Public
18 : //# License along with this library; if not, write to the Free Software
19 : //# Foundation, Inc., 59 Temple Place, Suite 330, Boston,
20 : //# MA 02111-1307 USA
21 : //# $Id: $
22 :
23 : #include <mstransform/MSTransform/MSTransformBufferImpl.h>
24 :
25 : using namespace casacore;
26 : namespace casa
27 : {
28 :
29 : // -----------------------------------------------------------------------
30 : //
31 : // -----------------------------------------------------------------------
32 0 : MSTransformBufferImpl::MSTransformBufferImpl(MSTransformManager *manager)
33 : {
34 0 : manager_p = manager;
35 0 : rowIdOffset_p = 0;
36 :
37 : // First store SPW related info (CAS-7460)
38 0 : MSSpectralWindow spwTable = manager_p->outputMs_p->spectralWindow();
39 0 : MSSpWindowColumns spwCols(spwTable);
40 0 : spwFrequencies_p.reference(spwCols.chanFreq());
41 0 : spwRefRame_p.reference(spwCols.chanFreqMeas());
42 0 : inputOutputSPWIndexMap_p = manager_p->inputOutputSPWIndexMap_p;
43 :
44 : // Store observatory position
45 0 : MSObservation observationTable = manager_p->selectedInputMs_p->observation();
46 0 : MSObservationColumns observationCols(observationTable);
47 0 : String observatoryName = observationCols.telescopeName()(0);
48 0 : MeasTable::Observatory(observatoryPosition_p,observatoryName);
49 :
50 0 : if (not manager_p->reindex_p)
51 : {
52 0 : manager_p->inputOutputObservationIndexMap_p.clear();
53 0 : manager_p->inputOutputArrayIndexMap_p.clear();
54 0 : manager_p->inputOutputScanIndexMap_p.clear();
55 0 : manager_p->inputOutputScanIntentIndexMap_p.clear();
56 0 : manager_p->inputOutputFieldIndexMap_p.clear();
57 0 : manager_p->inputOutputSPWIndexMap_p.clear();
58 0 : manager_p->inputOutputDDIndexMap_p.clear();
59 0 : manager_p->inputOutputAntennaIndexMap_p.clear();
60 0 : manager_p->outputInputSPWIndexMap_p.clear();
61 : }
62 :
63 0 : dx_p = 0;
64 0 : dy_p = 0;
65 :
66 : // NONE datacol handling
67 0 : if (manager_p->datacolumn_p.contains("NONE"))
68 : {
69 0 : noneDataCol_p = true;
70 : }
71 : else
72 : {
73 0 : noneDataCol_p = false;
74 : }
75 :
76 0 : return;
77 0 : }
78 :
79 : // -----------------------------------------------------------------------
80 : //
81 : // -----------------------------------------------------------------------
82 0 : void MSTransformBufferImpl::resetState()
83 : {
84 0 : observationIdOk_p = false;
85 0 : arrayIdOk_p = false;
86 0 : scanOk_p = false;
87 0 : stateIdOk_p = false;
88 0 : fieldIdOk_p = false;
89 0 : dataDescIdOk_p = false;
90 0 : spectralWindowsOk_p = false;
91 0 : processorIdOk_p = false;
92 0 : antenna1Ok_p = false;
93 0 : antenna2Ok_p = false;
94 0 : feed1Ok_p = false;
95 0 : feed2Ok_p = false;
96 0 : flagRowOk_p = false;
97 0 : timeOk_p = false;
98 0 : timeCentroidOk_p = false;
99 0 : timeIntervalOk_p = false;
100 0 : exposureOk_p = false;
101 0 : uvwOk_p = false;
102 0 : weightOk_p = false;
103 0 : sigmaOk_p = false;
104 0 : flagCubeOk_p = false;
105 0 : visCubeOk_p = false;
106 0 : visCubeCorrectedOk_p = false;
107 0 : visCubeModelOk_p = false;
108 0 : visCubeFloatOk_p = false;
109 0 : weightSpectrumOk_p = false;
110 0 : sigmaSpectrumOk_p = false;
111 0 : feedPaOk_p = false;
112 0 : parangOk_p = false;
113 0 : azelOk_p = false;
114 0 : frequenciesOk_p = false;
115 0 : channelNumbersOk_p = false;
116 0 : channelNumbersSelectedOk_p = false;
117 0 : rowIdsOk_p = false;
118 0 : shapeOk_p = false;
119 0 : nRowsOk_p = false;
120 0 : nChannelsOk_p = false;
121 0 : nCorrelationsOk_p = false;
122 0 : nAntennasOk_p = false;
123 0 : freqRefFrameTypeOk_p = false;
124 :
125 0 : observationIdTransformed_p = false;
126 0 : arrayIdTransformed_p = false;
127 0 : scanTransformed_p = false;
128 0 : stateIdTransformed_p = false;
129 0 : fieldIdTransformed_p = false;
130 0 : dataDescIdTransformed_p = false;
131 0 : spectralWindowsTransformed_p = false;
132 0 : processorIdTransformed_p = false;
133 0 : antenna1Transformed_p = false;
134 0 : antenna2Transformed_p = false;
135 0 : feed1Transformed_p = false;
136 0 : feed2Transformed_p = false;
137 0 : flagRowTransformed_p = false;
138 0 : uvwTransformed_p = false;
139 0 : weightTransformed_p = false;
140 0 : sigmaTransformed_p = false;
141 0 : timeTransformed_p = false;
142 0 : timeCentroidTransformed_p = false;
143 0 : timeIntervalTransformed_p = false;
144 0 : exposureTransformed_p = false;
145 0 : feedPaTransformed_p = false;
146 0 : parangTransformed_p = false;
147 0 : azelTransformed_p = false;
148 0 : frequenciesTransformed_p = false;
149 0 : channelNumbersTransformed_p = false;
150 0 : rowIdsTransformed_p = false;
151 :
152 0 : manager_p->weightSpectrumFlatFilled_p = false;
153 0 : manager_p->weightSpectrumFromSigmaFilled_p = false;
154 :
155 0 : return;
156 : }
157 :
158 : // -----------------------------------------------------------------------
159 : //
160 : // -----------------------------------------------------------------------
161 0 : void MSTransformBufferImpl::generateWeights() const
162 : {
163 : // Make sure shape is defined
164 0 : getShape();
165 :
166 : // Make sure flags are updated
167 : // (are needed to extract weight/sigma from the spectrum columns by using mean/median)
168 0 : flagCube();
169 :
170 : // Reshape arrays
171 0 : sigmaSpectrum_p.resize(shape_p,false);
172 0 : weightSpectrum_p.resize(shape_p,false);
173 0 : weight_p.resize(nCorrelations_p,nRows_p,false);
174 0 : sigma_p.resize(nCorrelations_p,nRows_p,false);
175 :
176 : // Assign array pointers in the manager to the arrays resident in this buffer
177 0 : manager_p->weight_p = &weight_p;
178 0 : manager_p->sigma_p = &sigma_p;
179 0 : manager_p->flagCube_p = &flagCube_p;
180 0 : manager_p->sigmaSpectrum_p = &sigmaSpectrum_p;
181 0 : manager_p->weightSpectrum_p = &weightSpectrum_p;
182 :
183 : // Transform weight columns
184 0 : RefRows dummyRefRows(0,0);
185 0 : manager_p->fillWeightCols(manager_p->getVisBuffer(),dummyRefRows);
186 :
187 : // Set state
188 0 : weightOk_p = true;
189 0 : sigmaOk_p = true;
190 0 : weightSpectrumOk_p = true;
191 0 : sigmaSpectrumOk_p = true;
192 0 : sigmaTransformed_p = true;
193 0 : weightTransformed_p = true;
194 :
195 0 : return;
196 0 : }
197 :
198 : // -----------------------------------------------------------------------
199 : //
200 : // -----------------------------------------------------------------------
201 0 : const Vector<Int> & MSTransformBufferImpl::dataDescriptionIds () const
202 : {
203 0 : if (not dataDescIdOk_p)
204 : {
205 0 : getShape();
206 0 : dataDescriptionIds_p.resize(nRows_p,false);
207 :
208 0 : dataDescIdTransformed_p = manager_p->transformDDIVector(manager_p->getVisBuffer()->dataDescriptionIds(),
209 0 : dataDescriptionIds_p);
210 :
211 0 : if (not dataDescIdTransformed_p)
212 : {
213 0 : dataDescriptionIds_p = manager_p->getVisBuffer()->dataDescriptionIds();
214 : }
215 :
216 0 : dataDescIdOk_p = true;
217 : }
218 :
219 0 : return dataDescriptionIds_p;
220 : }
221 :
222 : // -----------------------------------------------------------------------
223 : //
224 : // -----------------------------------------------------------------------
225 0 : const Vector<Int> & MSTransformBufferImpl::spectralWindows () const
226 : {
227 0 : if (not spectralWindowsOk_p)
228 : {
229 0 : dataDescriptionIds();
230 :
231 0 : getShape();
232 0 : spectralWindows_p.resize(nRows_p,false);
233 :
234 0 : if (not dataDescIdTransformed_p)
235 : {
236 0 : spectralWindows_p = manager_p->getVisBuffer()->spectralWindows();
237 : }
238 : else
239 : {
240 0 : for (rownr_t rowIdx = 0; rowIdx<nRows_p;rowIdx++)
241 : {
242 0 : spectralWindows_p(rowIdx) = dataDescriptionIds_p(rowIdx);
243 : }
244 :
245 0 : spectralWindowsTransformed_p = true;
246 : }
247 :
248 0 : spectralWindowsOk_p = true;
249 : }
250 :
251 0 : return spectralWindows_p;
252 : }
253 :
254 : // -----------------------------------------------------------------------
255 : //
256 : // -----------------------------------------------------------------------
257 0 : const Vector<Int> & MSTransformBufferImpl::observationId () const
258 : {
259 0 : if (not observationIdOk_p)
260 : {
261 0 : getShape();
262 0 : observationId_p.resize(nRows_p,false);
263 :
264 0 : observationIdTransformed_p = manager_p->transformReindexableVector( manager_p->getVisBuffer()->observationId(),
265 0 : observationId_p,
266 : true,
267 0 : manager_p->inputOutputObservationIndexMap_p);
268 0 : observationIdOk_p = true;
269 : }
270 :
271 0 : if (not observationIdTransformed_p)
272 : {
273 0 : return manager_p->getVisBuffer()->observationId();
274 : }
275 :
276 0 : return observationId_p;
277 : }
278 :
279 : // -----------------------------------------------------------------------
280 : //
281 : // -----------------------------------------------------------------------
282 0 : const Vector<Int> & MSTransformBufferImpl::arrayId () const
283 : {
284 0 : if (not arrayIdOk_p)
285 : {
286 0 : getShape();
287 0 : arrayId_p.resize(nRows_p,false);
288 :
289 0 : arrayIdTransformed_p = manager_p->transformReindexableVector( manager_p->getVisBuffer()->arrayId(),
290 0 : arrayId_p,
291 : true,
292 0 : manager_p->inputOutputArrayIndexMap_p);
293 0 : arrayIdOk_p = true;
294 : }
295 :
296 0 : if (not arrayIdTransformed_p)
297 : {
298 0 : return manager_p->getVisBuffer()->arrayId();
299 : }
300 :
301 0 : return arrayId_p;
302 : }
303 :
304 : // -----------------------------------------------------------------------
305 : //
306 : // -----------------------------------------------------------------------
307 0 : const Vector<Int> & MSTransformBufferImpl::fieldId () const
308 : {
309 0 : if (not fieldIdOk_p)
310 : {
311 0 : getShape();
312 0 : fieldId_p.resize(nRows_p,false);
313 :
314 0 : fieldIdTransformed_p = manager_p->transformReindexableVector( manager_p->getVisBuffer()->fieldId(),
315 0 : fieldId_p,
316 0 : !manager_p->timespan_p.contains("field"),
317 0 : manager_p->inputOutputFieldIndexMap_p);
318 0 : fieldIdOk_p = true;
319 : }
320 :
321 0 : if (not fieldIdTransformed_p)
322 : {
323 0 : return manager_p->getVisBuffer()->fieldId();
324 : }
325 :
326 0 : return fieldId_p;
327 : }
328 :
329 : // -----------------------------------------------------------------------
330 : //
331 : // -----------------------------------------------------------------------
332 0 : const Vector<Int> & MSTransformBufferImpl::stateId () const
333 : {
334 0 : if (not stateIdOk_p)
335 : {
336 0 : getShape();
337 0 : stateId_p.resize(nRows_p,false);
338 :
339 0 : stateIdTransformed_p = manager_p->transformReindexableVector( manager_p->getVisBuffer()->stateId(),
340 0 : stateId_p,
341 0 : !manager_p->timespan_p.contains("state"),
342 0 : manager_p->inputOutputScanIntentIndexMap_p);
343 0 : stateIdOk_p = true;
344 : }
345 :
346 0 : if (not stateIdTransformed_p)
347 : {
348 0 : return manager_p->getVisBuffer()->stateId();
349 : }
350 :
351 :
352 0 : return stateId_p;
353 : }
354 :
355 : // -----------------------------------------------------------------------
356 : //
357 : // -----------------------------------------------------------------------
358 0 : const Vector<Int> & MSTransformBufferImpl::antenna1 () const
359 : {
360 0 : if (not antenna1Ok_p)
361 : {
362 0 : getShape();
363 0 : antenna1_p.resize(nRows_p,false);
364 :
365 0 : antenna1Transformed_p = manager_p->transformReindexableVector( manager_p->getVisBuffer()->antenna1(),
366 0 : antenna1_p,
367 : false,
368 0 : manager_p->inputOutputAntennaIndexMap_p);
369 0 : antenna1Ok_p = true;
370 : }
371 :
372 0 : if (not antenna1Transformed_p)
373 : {
374 0 : return manager_p->getVisBuffer()->antenna1();
375 : }
376 :
377 0 : return antenna1_p;
378 : }
379 :
380 : // -----------------------------------------------------------------------
381 : //
382 : // -----------------------------------------------------------------------
383 0 : const Vector<Int> & MSTransformBufferImpl::antenna2 () const
384 : {
385 0 : if (not antenna2Ok_p)
386 : {
387 0 : getShape();
388 0 : antenna2_p.resize(nRows_p,false);
389 :
390 0 : antenna2Transformed_p = manager_p->transformReindexableVector( manager_p->getVisBuffer()->antenna2(),
391 0 : antenna2_p,
392 : false,
393 0 : manager_p->inputOutputAntennaIndexMap_p);
394 0 : antenna2Ok_p = true;
395 : }
396 :
397 0 : if (not antenna2Transformed_p)
398 : {
399 0 : return manager_p->getVisBuffer()->antenna2();
400 : }
401 :
402 0 : return antenna2_p;
403 : }
404 :
405 : // -----------------------------------------------------------------------
406 : //
407 : // -----------------------------------------------------------------------
408 0 : const Vector<Int> & MSTransformBufferImpl::scan () const
409 : {
410 0 : if (not scanOk_p)
411 : {
412 0 : getShape();
413 0 : scan_p.resize(nRows_p,false);
414 :
415 0 : scanTransformed_p = manager_p->transformNotReindexableVector( manager_p->getVisBuffer()->scan(),
416 0 : scan_p,
417 0 : !manager_p->timespan_p.contains("scan"));
418 0 : scanOk_p = true;
419 : }
420 :
421 0 : if (not scanTransformed_p)
422 : {
423 0 : return manager_p->getVisBuffer()->scan();
424 : }
425 :
426 0 : return scan_p;
427 : }
428 :
429 : // -----------------------------------------------------------------------
430 : //
431 : // -----------------------------------------------------------------------
432 0 : const Vector<Int> & MSTransformBufferImpl::processorId () const
433 : {
434 0 : if (not processorIdOk_p)
435 : {
436 0 : getShape();
437 0 : processorId_p.resize(nRows_p,false);
438 :
439 0 : processorIdTransformed_p = manager_p->transformNotReindexableVector( manager_p->getVisBuffer()->processorId(),
440 0 : processorId_p,
441 : false);
442 0 : processorIdOk_p = true;
443 : }
444 :
445 0 : if (not processorIdTransformed_p)
446 : {
447 0 : return manager_p->getVisBuffer()->processorId();
448 : }
449 :
450 0 : return processorId_p;
451 : }
452 :
453 : // -----------------------------------------------------------------------
454 : //
455 : // -----------------------------------------------------------------------
456 0 : const Vector<Int> & MSTransformBufferImpl::feed1 () const
457 : {
458 0 : if (not feed1Ok_p)
459 : {
460 0 : getShape();
461 0 : feed1_p.resize(nRows_p,false);
462 :
463 0 : feed1Transformed_p = manager_p->transformNotReindexableVector( manager_p->getVisBuffer()->feed1(),
464 0 : feed1_p,
465 : false);
466 0 : feed1Ok_p = true;
467 : }
468 :
469 0 : if (not feed1Transformed_p)
470 : {
471 0 : return manager_p->getVisBuffer()->feed1();
472 : }
473 :
474 0 : return feed1_p;
475 : }
476 :
477 : // -----------------------------------------------------------------------
478 : //
479 : // -----------------------------------------------------------------------
480 0 : const Vector<Int> & MSTransformBufferImpl::feed2 () const
481 : {
482 0 : if (not feed2Ok_p)
483 : {
484 0 : getShape();
485 0 : feed2_p.resize(nRows_p,false);
486 :
487 0 : feed2Transformed_p = manager_p->transformNotReindexableVector( manager_p->getVisBuffer()->feed2(),
488 0 : feed2_p,
489 : false);
490 0 : feed2Ok_p = true;
491 : }
492 :
493 0 : if (not feed2Transformed_p)
494 : {
495 0 : return manager_p->getVisBuffer()->feed2();
496 : }
497 :
498 0 : return feed2_p;
499 : }
500 :
501 : // -----------------------------------------------------------------------
502 : //
503 : // -----------------------------------------------------------------------
504 0 : const Vector<Double> & MSTransformBufferImpl::time () const
505 : {
506 0 : if (not timeOk_p)
507 : {
508 0 : getShape();
509 0 : time_p.resize(nRows_p,false);
510 :
511 0 : timeTransformed_p = manager_p->transformNotReindexableVector( manager_p->getVisBuffer()->time(),
512 0 : time_p,
513 : false);
514 0 : timeOk_p = true;
515 : }
516 :
517 0 : if (not timeTransformed_p)
518 : {
519 0 : return manager_p->getVisBuffer()->time();
520 : }
521 :
522 0 : return time_p;
523 : }
524 :
525 : // -----------------------------------------------------------------------
526 : //
527 : // -----------------------------------------------------------------------
528 0 : const Vector<Double> & MSTransformBufferImpl::timeCentroid () const
529 : {
530 0 : if (not timeCentroidOk_p)
531 : {
532 0 : getShape();
533 0 : timeCentroid_p.resize(nRows_p,false);
534 :
535 0 : timeCentroidTransformed_p = manager_p->transformNotReindexableVector( manager_p->getVisBuffer()->timeCentroid(),
536 0 : timeCentroid_p,
537 : false);
538 0 : timeCentroidOk_p = true;
539 : }
540 :
541 0 : if (not timeCentroidTransformed_p)
542 : {
543 0 : return manager_p->getVisBuffer()->timeCentroid();
544 : }
545 :
546 0 : return timeCentroid_p;
547 : }
548 :
549 : // -----------------------------------------------------------------------
550 : //
551 : // -----------------------------------------------------------------------
552 0 : const Vector<Double> & MSTransformBufferImpl::timeInterval () const
553 : {
554 0 : if (not timeIntervalOk_p)
555 : {
556 0 : getShape();
557 0 : timeInterval_p.resize(nRows_p,false);
558 :
559 0 : timeIntervalTransformed_p = manager_p->transformNotReindexableVector( manager_p->getVisBuffer()->timeInterval(),
560 0 : timeInterval_p,
561 : false);
562 0 : timeIntervalOk_p = true;
563 : }
564 :
565 0 : if (not timeIntervalTransformed_p)
566 : {
567 0 : return manager_p->getVisBuffer()->timeInterval();
568 : }
569 :
570 0 : return timeInterval_p;
571 : }
572 :
573 : // -----------------------------------------------------------------------
574 : //
575 : // -----------------------------------------------------------------------
576 0 : const Vector<Double> & MSTransformBufferImpl::exposure () const
577 : {
578 0 : if (not exposureOk_p)
579 : {
580 0 : getShape();
581 0 : exposure_p.resize(nRows_p,false);
582 :
583 0 : if (manager_p->combinespws_p)
584 : {
585 0 : manager_p->mapAndAverageVector( manager_p->getVisBuffer()->exposure(),exposure_p);
586 0 : exposureTransformed_p = true;
587 : }
588 : else
589 : {
590 0 : exposureTransformed_p = false;
591 : }
592 :
593 0 : exposureOk_p = true;
594 : }
595 :
596 0 : if (not exposureTransformed_p)
597 : {
598 0 : return manager_p->getVisBuffer()->exposure();
599 : }
600 :
601 0 : return exposure_p;
602 : }
603 :
604 : // -----------------------------------------------------------------------
605 : //
606 : // -----------------------------------------------------------------------
607 0 : const Vector<Bool> & MSTransformBufferImpl::flagRow () const
608 : {
609 0 : if (not flagRowOk_p)
610 : {
611 0 : getShape();
612 0 : flagRow_p.resize(nRows_p,false);
613 :
614 0 : if (manager_p->combinespws_p)
615 : {
616 0 : manager_p->mapAndAverageVector( manager_p->getVisBuffer()->flagRow(),flagRow_p);
617 0 : flagRowTransformed_p = true;
618 : }
619 : else
620 : {
621 0 : flagRowTransformed_p = false;
622 : }
623 :
624 0 : flagRowOk_p = true;
625 : }
626 :
627 0 : if (not flagRowTransformed_p)
628 : {
629 0 : return manager_p->getVisBuffer()->flagRow();
630 : }
631 :
632 0 : return flagRow_p;
633 : }
634 :
635 : // -----------------------------------------------------------------------
636 : //
637 : // -----------------------------------------------------------------------
638 0 : const Matrix<Double> & MSTransformBufferImpl::uvw () const
639 : {
640 0 : if (not uvwOk_p)
641 : {
642 0 : getShape();
643 0 : uvw_p.resize(3,nRows_p,false);
644 :
645 0 : if (manager_p->combinespws_p)
646 : {
647 0 : manager_p->mapMatrix(manager_p->getVisBuffer()->uvw(),uvw_p);
648 0 : uvwTransformed_p = true;
649 : }
650 : else
651 : {
652 0 : uvwTransformed_p = false;
653 : }
654 :
655 0 : uvwOk_p = true;
656 : }
657 :
658 0 : if (not uvwTransformed_p)
659 : {
660 0 : return manager_p->getVisBuffer()->uvw();
661 : }
662 :
663 0 : return uvw_p;
664 : }
665 :
666 : // -----------------------------------------------------------------------
667 : //
668 : // -----------------------------------------------------------------------
669 0 : const Matrix<Float> & MSTransformBufferImpl::weight () const
670 : {
671 0 : if (not weightOk_p)
672 : {
673 0 : if (manager_p->cubeTransformation_p)
674 : {
675 0 : generateWeights();
676 0 : weightTransformed_p = true;
677 : }
678 : else
679 : {
680 0 : getShape();
681 :
682 0 : if (manager_p->combinespws_p)
683 : {
684 0 : weight_p.resize(nCorrelations_p,nRows_p,false);
685 :
686 0 : if (manager_p->newWeightFactorMap_p.size() > 0)
687 : {
688 0 : manager_p->mapAndScaleMatrix( manager_p->getVisBuffer()->weight(),
689 0 : weight_p,
690 0 : manager_p->newWeightFactorMap_p,
691 0 : manager_p->getVisBuffer()->spectralWindows());
692 : }
693 : else
694 : {
695 0 : manager_p->mapMatrix(manager_p->getVisBuffer()->weight(),weight_p);
696 : }
697 0 : weightTransformed_p = true;
698 : }
699 0 : else if (manager_p->newWeightFactorMap_p.size() > 0)
700 : {
701 0 : weight_p.resize(nCorrelations_p,nRows_p,false);
702 0 : weight_p = manager_p->getVisBuffer()->weight();
703 :
704 : // Apply scale factor
705 0 : if ( (manager_p->newWeightFactorMap_p.find(manager_p->getVisBuffer()->spectralWindows()(0)) != manager_p->newWeightFactorMap_p.end()) and
706 0 : (manager_p->newWeightFactorMap_p[manager_p->getVisBuffer()->spectralWindows()(0)] != 1) )
707 : {
708 0 : weight_p *= manager_p->newWeightFactorMap_p[manager_p->getVisBuffer()->spectralWindows()(0)];
709 : }
710 0 : weightTransformed_p = true;
711 : }
712 : else
713 : {
714 0 : weightTransformed_p = false;
715 : }
716 : }
717 :
718 0 : weightOk_p = true;
719 : }
720 :
721 0 : if (not weightTransformed_p)
722 : {
723 0 : return manager_p->getVisBuffer()->weight();
724 : }
725 :
726 0 : return weight_p;
727 : }
728 :
729 : // -----------------------------------------------------------------------
730 : //
731 : // -----------------------------------------------------------------------
732 0 : const Matrix<Float> & MSTransformBufferImpl::sigma () const
733 : {
734 0 : if (not sigmaOk_p)
735 : {
736 0 : if (manager_p->cubeTransformation_p)
737 : {
738 0 : generateWeights();
739 0 : sigmaTransformed_p = true;
740 : }
741 : else
742 : {
743 0 : getShape();
744 :
745 0 : if (manager_p->combinespws_p)
746 : {
747 0 : sigma_p.resize(nCorrelations_p,nRows_p,false);
748 :
749 0 : if (manager_p->correctedToData_p)
750 : {
751 : // Sigma must be redefined to 1/weight when corrected data becomes data
752 0 : sigma_p = weight(); // Copy operator implements an actual copy
753 0 : arrayTransformInPlace(sigma_p, vi::AveragingTvi2::weightToSigma);
754 : }
755 0 : else if (manager_p->newSigmaFactorMap_p.size() > 0)
756 : {
757 0 : manager_p->mapAndScaleMatrix( manager_p->getVisBuffer()->sigma(),
758 0 : sigma_p,
759 0 : manager_p->newSigmaFactorMap_p,
760 0 : manager_p->getVisBuffer()->spectralWindows());
761 : }
762 : else
763 : {
764 0 : manager_p->mapMatrix(manager_p->getVisBuffer()->sigma(),sigma_p);
765 : }
766 0 : sigmaTransformed_p = true;
767 : }
768 0 : else if (manager_p->correctedToData_p)
769 : {
770 : // Sigma must be redefined to 1/weight when corrected data becomes data
771 0 : sigma_p.resize(nCorrelations_p,nRows_p,false);
772 0 : sigma_p = weight(); // Copy operator implements an actual copy
773 0 : arrayTransformInPlace(sigma_p, vi::AveragingTvi2::weightToSigma);
774 0 : sigmaTransformed_p = true;
775 : }
776 0 : else if (manager_p->newSigmaFactorMap_p.size() > 0)
777 : {
778 0 : sigma_p.resize(nCorrelations_p,nRows_p,false);
779 0 : sigma_p = manager_p->getVisBuffer()->sigma();
780 :
781 : // Apply scale factor
782 0 : if ( (manager_p->newSigmaFactorMap_p.find(manager_p->getVisBuffer()->spectralWindows()(0)) != manager_p->newSigmaFactorMap_p.end()) and
783 0 : (manager_p->newSigmaFactorMap_p[manager_p->getVisBuffer()->spectralWindows()(0)] != 1) )
784 : {
785 0 : sigma_p *= manager_p->newSigmaFactorMap_p[manager_p->getVisBuffer()->spectralWindows()(0)];
786 : }
787 0 : sigmaTransformed_p = true;
788 : }
789 : else
790 : {
791 0 : sigmaTransformed_p = false;
792 : }
793 : }
794 :
795 0 : sigmaOk_p = true;
796 : }
797 :
798 0 : if (not sigmaTransformed_p)
799 : {
800 0 : return manager_p->getVisBuffer()->sigma();
801 : }
802 :
803 0 : return sigma_p;
804 : }
805 :
806 : // -----------------------------------------------------------------------
807 : //
808 : // -----------------------------------------------------------------------
809 0 : const Cube<Bool> & MSTransformBufferImpl::flagCube () const
810 : {
811 0 : if (not manager_p->cubeTransformation_p)
812 : {
813 0 : return manager_p->getVisBuffer()->flagCube();
814 : }
815 0 : else if (not flagCubeOk_p)
816 : {
817 0 : if (noneDataCol_p)
818 : {
819 : // Setup input data map
820 0 : DataCubeMap inputDataCubeMap;
821 0 : Cube<Bool> inputFlagCube = manager_p->getVisBuffer()->flagCube();
822 0 : DataCubeHolder<Bool> inputFlagDataHolder(inputFlagCube);
823 0 : inputDataCubeMap.add(MS::FLAG,static_cast<DataCubeHolderBase*>(&inputFlagDataHolder));
824 :
825 : // Setup output data map
826 0 : DataCubeMap outputDataCubeMap;
827 0 : flagCube_p.resize(getShape(),false);
828 0 : DataCubeHolder<Bool> outputFlagDataHolder(flagCube_p);
829 0 : outputDataCubeMap.add(MS::FLAG,static_cast<DataCubeHolderBase*>(&outputFlagDataHolder));
830 :
831 : // Setup transformation
832 0 : Int inputSpw = manager_p->getVisBuffer()->spectralWindows()(0);
833 0 : uInt chanbin = manager_p->freqbinMap_p[inputSpw];
834 0 : inputDataCubeMap.setWindowShape(IPosition(1,chanbin));
835 :
836 : // Transform data
837 0 : transformDataCube( manager_p->getVisBuffer(),
838 : inputDataCubeMap,
839 : outputDataCubeMap,
840 : &MSTransformBufferImpl::channelAverage);
841 0 : }
842 0 : else if (manager_p->dataColumnAvailable_p)
843 : {
844 0 : visCube();
845 : }
846 0 : else if (manager_p->correctedDataColumnAvailable_p)
847 : {
848 0 : visCubeCorrected();
849 : }
850 0 : else if (manager_p->modelDataColumnAvailable_p)
851 : {
852 0 : visCubeModel();
853 : }
854 0 : else if (manager_p->floatDataColumnAvailable_p)
855 : {
856 0 : visCubeFloat();
857 : }
858 :
859 0 : flagCubeOk_p = true;
860 : }
861 :
862 0 : return flagCube_p;
863 : }
864 :
865 : // -----------------------------------------------------------------------
866 : //
867 : // -----------------------------------------------------------------------
868 0 : const Cube<Complex> & MSTransformBufferImpl::visCube () const
869 : {
870 :
871 0 : if (not manager_p->dataColumnAvailable_p)
872 : {
873 0 : manager_p->logger_p << LogIO::EXCEPTION << LogOrigin("MSTransformBufferImpl", __FUNCTION__)
874 0 : << "visCube requested but DATA column not present in input MS" << LogIO::POST;
875 : }
876 :
877 0 : if (applyPhaseShifting_p and not visCubeOk_p)
878 : {
879 0 : manager_p->getVisBuffer()->dirtyComponentsAdd(VisBufferComponent2::VisibilityCubeObserved);
880 0 : manager_p->getVisBuffer()->visCube();
881 0 : manager_p->getVisBuffer()->phaseCenterShift(dx_p,dy_p);
882 : }
883 :
884 0 : if (not manager_p->cubeTransformation_p)
885 : {
886 0 : visCubeOk_p = true;
887 0 : return manager_p->getVisBuffer()->visCube();
888 : }
889 0 : else if (not visCubeOk_p)
890 : {
891 0 : visCube_p.resize(getShape(),false);
892 0 : manager_p->visCube_p = &visCube_p;
893 :
894 0 : flagCube_p.resize(getShape(),false);
895 0 : manager_p->flagCube_p = &flagCube_p;
896 :
897 0 : RefRows dummyRefRows(0,0);
898 0 : ArrayColumn<Complex> dummyDataCol;
899 :
900 0 : const Cube<Float> &applicableSpectrum = manager_p->getApplicableSpectrum(manager_p->getVisBuffer(),MS::DATA);
901 :
902 0 : manager_p->dataBuffer_p = MSTransformations::visCube;
903 0 : manager_p->transformCubeOfData( manager_p->getVisBuffer(),
904 : dummyRefRows,
905 0 : manager_p->getVisBuffer()->visCube(),
906 : dummyDataCol,
907 : NULL,
908 : applicableSpectrum);
909 0 : flagCubeOk_p = true;
910 0 : visCubeOk_p = true;
911 0 : }
912 :
913 0 : return visCube_p;
914 : }
915 :
916 : // -----------------------------------------------------------------------
917 : //
918 : // -----------------------------------------------------------------------
919 0 : const Cube<Complex> & MSTransformBufferImpl::visCubeCorrected () const
920 : {
921 0 : if (not manager_p->correctedDataColumnAvailable_p)
922 : {
923 0 : manager_p->logger_p << LogIO::EXCEPTION << LogOrigin("MSTransformBufferImpl", __FUNCTION__)
924 0 : << "visCubeCorrected requested but CORRECTED_DATA column not present in input MS" << LogIO::POST;
925 : }
926 :
927 0 : if (applyPhaseShifting_p and not visCubeCorrectedOk_p)
928 : {
929 0 : manager_p->getVisBuffer()->dirtyComponentsAdd(VisBufferComponent2::VisibilityCubeCorrected);
930 0 : manager_p->getVisBuffer()->visCubeCorrected();
931 0 : manager_p->getVisBuffer()->phaseCenterShift(dx_p,dy_p);
932 : }
933 :
934 0 : if (not manager_p->cubeTransformation_p)
935 : {
936 0 : visCubeCorrectedOk_p = true;
937 0 : return manager_p->getVisBuffer()->visCubeCorrected();
938 : }
939 0 : else if (not visCubeCorrectedOk_p)
940 : {
941 0 : visCubeCorrected_p.resize(getShape(),false);
942 0 : manager_p->visCubeCorrected_p = &visCubeCorrected_p;
943 :
944 0 : flagCube_p.resize(getShape(),false);
945 0 : manager_p->flagCube_p = &flagCube_p;
946 :
947 0 : RefRows dummyRefRows(0,0);
948 0 : ArrayColumn<Complex> dummyDataCol;
949 :
950 0 : const Cube<Float> &applicableSpectrum = manager_p->getApplicableSpectrum(manager_p->getVisBuffer(),MS::CORRECTED_DATA);
951 :
952 0 : manager_p->dataBuffer_p = MSTransformations::visCubeCorrected;
953 0 : manager_p->transformCubeOfData( manager_p->getVisBuffer(),
954 : dummyRefRows,
955 0 : manager_p->getVisBuffer()->visCubeCorrected(),
956 : dummyDataCol,
957 : NULL,
958 : applicableSpectrum);
959 0 : flagCubeOk_p = true;
960 0 : visCubeCorrectedOk_p = true;
961 0 : }
962 :
963 0 : return visCubeCorrected_p;
964 : }
965 :
966 : // -----------------------------------------------------------------------
967 : //
968 : // -----------------------------------------------------------------------
969 0 : const Cube<Complex> & MSTransformBufferImpl::visCubeModel () const
970 : {
971 :
972 0 : if (not manager_p->modelDataColumnAvailable_p)
973 : {
974 0 : manager_p->logger_p << LogIO::EXCEPTION << LogOrigin("MSTransformBufferImpl", __FUNCTION__)
975 0 : << "visCubeModel requested but MODEL_DATA column not present in input MS" << LogIO::POST;
976 : }
977 :
978 0 : if (applyPhaseShifting_p and not visCubeModelOk_p)
979 : {
980 0 : manager_p->getVisBuffer()->dirtyComponentsAdd(VisBufferComponent2::VisibilityCubeModel);
981 0 : manager_p->getVisBuffer()->visCubeModel();
982 0 : manager_p->getVisBuffer()->phaseCenterShift(dx_p,dy_p);
983 : }
984 :
985 0 : if (not manager_p->cubeTransformation_p)
986 : {
987 0 : visCubeModelOk_p = true;
988 0 : return manager_p->getVisBuffer()->visCubeModel();
989 : }
990 0 : else if (not visCubeModelOk_p)
991 : {
992 0 : visCubeModel_p.resize(getShape(),false);
993 0 : manager_p->visCubeModel_p = &visCubeModel_p;
994 :
995 0 : flagCube_p.resize(getShape(),false);
996 0 : manager_p->flagCube_p = &flagCube_p;
997 :
998 0 : RefRows dummyRefRows(0,0);
999 0 : ArrayColumn<Complex> dummyDataCol;
1000 :
1001 0 : const Cube<Float> &applicableSpectrum = manager_p->getApplicableSpectrum(manager_p->getVisBuffer(),MS::MODEL_DATA);
1002 :
1003 0 : manager_p->dataBuffer_p = MSTransformations::visCubeModel;
1004 0 : manager_p->transformCubeOfData( manager_p->getVisBuffer(),
1005 : dummyRefRows,
1006 0 : manager_p->getVisBuffer()->visCubeModel(),
1007 : dummyDataCol,
1008 : NULL,
1009 : applicableSpectrum);
1010 0 : flagCubeOk_p = true;
1011 0 : visCubeModelOk_p= true;
1012 0 : }
1013 :
1014 0 : return visCubeModel_p;
1015 : }
1016 :
1017 : // -----------------------------------------------------------------------
1018 : //
1019 : // -----------------------------------------------------------------------
1020 0 : const Cube<Float> & MSTransformBufferImpl::visCubeFloat () const
1021 : {
1022 0 : if (not manager_p->floatDataColumnAvailable_p)
1023 : {
1024 0 : manager_p->logger_p << LogIO::EXCEPTION << LogOrigin("MSTransformBufferImpl", __FUNCTION__)
1025 0 : << "visCubeFloat requested but FLOAT_DATA column not present in input MS" << LogIO::POST;
1026 : }
1027 :
1028 0 : if (not manager_p->cubeTransformation_p)
1029 : {
1030 0 : return manager_p->getVisBuffer()->visCubeFloat();
1031 : }
1032 0 : else if (not visCubeFloatOk_p)
1033 : {
1034 0 : visCubeFloat_p.resize(getShape(),false);
1035 0 : manager_p->visCubeFloat_p = &visCubeFloat_p;
1036 :
1037 0 : flagCube_p.resize(getShape(),false);
1038 0 : manager_p->flagCube_p = &flagCube_p;
1039 :
1040 0 : RefRows dummyRefRows(0,0);
1041 0 : ArrayColumn<Float> dummyDataCol;
1042 :
1043 0 : const Cube<Float> &applicableSpectrum = manager_p->getApplicableSpectrum(manager_p->getVisBuffer(),MS::FLOAT_DATA);
1044 :
1045 0 : manager_p->dataBuffer_p = MSTransformations::visCubeFloat;
1046 0 : manager_p->transformCubeOfData( manager_p->getVisBuffer(),
1047 : dummyRefRows,
1048 0 : manager_p->getVisBuffer()->visCubeFloat(),
1049 : dummyDataCol,
1050 : NULL,
1051 : applicableSpectrum);
1052 :
1053 0 : flagCubeOk_p = true;
1054 0 : visCubeFloatOk_p = true;
1055 0 : }
1056 :
1057 0 : return visCubeFloat_p;
1058 : }
1059 :
1060 : // -----------------------------------------------------------------------
1061 : //
1062 : // -----------------------------------------------------------------------
1063 0 : const Cube<Float> & MSTransformBufferImpl::weightSpectrum () const
1064 : {
1065 0 : if (not manager_p->cubeTransformation_p)
1066 : {
1067 0 : return manager_p->getVisBuffer()->weightSpectrum();
1068 : }
1069 0 : else if (not weightSpectrumOk_p)
1070 : {
1071 0 : generateWeights();
1072 0 : weightSpectrumOk_p = true;
1073 : }
1074 :
1075 0 : return weightSpectrum_p;
1076 : }
1077 :
1078 : // -----------------------------------------------------------------------
1079 : //
1080 : // -----------------------------------------------------------------------
1081 0 : const Cube<Float> & MSTransformBufferImpl::sigmaSpectrum () const
1082 : {
1083 0 : if (not manager_p->cubeTransformation_p)
1084 : {
1085 0 : return manager_p->getVisBuffer()->sigmaSpectrum();
1086 : }
1087 0 : if (not sigmaSpectrumOk_p)
1088 : {
1089 0 : generateWeights();
1090 0 : sigmaSpectrumOk_p = true;
1091 : }
1092 :
1093 0 : return sigmaSpectrum_p;
1094 : }
1095 :
1096 : // -----------------------------------------------------------------------
1097 : //
1098 : // -----------------------------------------------------------------------
1099 0 : const Array<Bool> & MSTransformBufferImpl::flagCategory () const
1100 : {
1101 0 : if (not manager_p->inputFlagCategoryAvailable_p)
1102 : {
1103 0 : manager_p->logger_p << LogIO::EXCEPTION << LogOrigin("MSTransformBufferImpl", __FUNCTION__)
1104 0 : << "FlagCategory requested but FLAG_CATEGORY column not present in input MS" << LogIO::POST;
1105 : }
1106 :
1107 0 : if (not manager_p->spectrumReshape_p)
1108 : {
1109 0 : return manager_p->getVisBuffer()->flagCategory();
1110 : }
1111 0 : else if (not flagCategoryOk_p)
1112 : {
1113 0 : uInt nCategories = manager_p->getVisBuffer()->flagCategory().shape()(2); // [nC,nF,nCategories,nR]
1114 0 : IPosition flagCategoryShape(4,nCorrelations_p,nChannels_p,nCategories,nRows_p);
1115 0 : flagCategory_p.resize(flagCategoryShape,false);
1116 0 : flagCategoryOk_p = true;
1117 0 : }
1118 :
1119 0 : return flagCategory_p;
1120 : }
1121 :
1122 : // -----------------------------------------------------------------------
1123 : //
1124 : // -----------------------------------------------------------------------
1125 0 : const Vector<Float> & MSTransformBufferImpl::feedPa (Double time) const
1126 : {
1127 0 : return manager_p->getVisBuffer()->feedPa(time);
1128 : }
1129 :
1130 : // -----------------------------------------------------------------------
1131 : //
1132 : // -----------------------------------------------------------------------
1133 0 : Float MSTransformBufferImpl::parang0 (Double time) const
1134 : {
1135 0 : return manager_p->getVisBuffer()->parang0(time);
1136 : }
1137 :
1138 : // -----------------------------------------------------------------------
1139 : //
1140 : // -----------------------------------------------------------------------
1141 0 : const Vector<Float> & MSTransformBufferImpl::parang(Double time) const
1142 : {
1143 0 : return manager_p->getVisBuffer()->parang(time);
1144 : }
1145 :
1146 : // -----------------------------------------------------------------------
1147 : //
1148 : // -----------------------------------------------------------------------
1149 0 : MDirection MSTransformBufferImpl::azel0 (Double time) const
1150 : {
1151 0 : return manager_p->getVisBuffer()->azel0(time);
1152 : }
1153 :
1154 : // -----------------------------------------------------------------------
1155 : //
1156 : // -----------------------------------------------------------------------
1157 0 : const Vector<MDirection> & MSTransformBufferImpl::azel(Double time) const
1158 : {
1159 0 : return manager_p->getVisBuffer()->azel(time);
1160 : }
1161 : // -----------------------------------------------------------------------
1162 : //
1163 : // -----------------------------------------------------------------------
1164 0 : const Vector<MDirection> & MSTransformBufferImpl::direction1() const
1165 : {
1166 0 : return manager_p->getVisBuffer()->direction1();
1167 : }
1168 :
1169 : // -----------------------------------------------------------------------
1170 : //
1171 : // -----------------------------------------------------------------------
1172 0 : Double MSTransformBufferImpl::hourang(Double time) const
1173 : {
1174 0 : return manager_p->getVisBuffer()->hourang(time);
1175 : }
1176 :
1177 : // -----------------------------------------------------------------------
1178 : //
1179 : // -----------------------------------------------------------------------
1180 0 : Vector<Int> MSTransformBufferImpl::getCorrelationTypes () const
1181 : {
1182 0 : return manager_p->getVisBuffer()->getCorrelationTypes();
1183 : }
1184 :
1185 : // -----------------------------------------------------------------------
1186 : //
1187 : // -----------------------------------------------------------------------
1188 0 : const Vector<Int> & MSTransformBufferImpl::correlationTypes () const
1189 : {
1190 0 : return manager_p->getVisBuffer()->correlationTypes();
1191 : }
1192 :
1193 : // -----------------------------------------------------------------------
1194 : //
1195 : // -----------------------------------------------------------------------
1196 0 : Vector<Stokes::StokesTypes> MSTransformBufferImpl::getCorrelationTypesDefined () const
1197 : {
1198 0 : return manager_p->getVisBuffer()->getCorrelationTypesDefined();
1199 : }
1200 :
1201 : // -----------------------------------------------------------------------
1202 : //
1203 : // -----------------------------------------------------------------------
1204 0 : Vector<Stokes::StokesTypes> MSTransformBufferImpl::getCorrelationTypesSelected () const
1205 : {
1206 0 : return manager_p->getVisBuffer()->getCorrelationTypesSelected();
1207 : }
1208 :
1209 : // -----------------------------------------------------------------------
1210 : //
1211 : // -----------------------------------------------------------------------
1212 0 : Double MSTransformBufferImpl::getFrequency (Int rowInBuffer, Int frequencyIndex, Int frame) const
1213 : {
1214 0 : Bool newFrequencies = manager_p->combinespws_p ||
1215 0 : manager_p->refFrameTransformation_p ||
1216 0 : manager_p->channelAverage_p ||
1217 0 : (manager_p->nspws_p > 1);
1218 :
1219 0 : if (not newFrequencies)
1220 : {
1221 0 : return manager_p->getVisBuffer()->getFrequency (rowInBuffer,frequencyIndex,frame);
1222 : }
1223 :
1224 0 : getFrequencies(rowInBuffer,frame);
1225 :
1226 :
1227 0 : return frequencies_p(frequencyIndex);
1228 : }
1229 :
1230 : // -----------------------------------------------------------------------
1231 : //
1232 : // -----------------------------------------------------------------------
1233 0 : const Vector<Double> & MSTransformBufferImpl::getFrequencies (Int rowInBuffer,Int frame) const
1234 : {
1235 : // CAS-7699: Check if frequencies have to be transformed to a new ref. frame
1236 0 : Bool freqRefFrameTransRequested = false;
1237 0 : MFrequency::Types requestedFreqRefFrame = static_cast<MFrequency::Types> (frame);
1238 0 : if (frame != FrameNotSpecified and requestedFreqRefFrame != freqRefFrameType())
1239 : {
1240 0 : frequenciesOk_p = false;
1241 0 : freqRefFrameTransRequested = true;
1242 0 : freqRefFrameType_p = requestedFreqRefFrame;
1243 : }
1244 :
1245 0 : if (not frequenciesOk_p)
1246 : {
1247 0 : Bool newFrequencies = manager_p->combinespws_p ||
1248 0 : manager_p->refFrameTransformation_p ||
1249 0 : manager_p->channelAverage_p ||
1250 0 : (manager_p->nspws_p > 1);
1251 :
1252 0 : if (not newFrequencies)
1253 : {
1254 0 : frequenciesTransformed_p = false;
1255 : }
1256 : else
1257 : {
1258 0 : getShape();
1259 0 : spectralWindows();
1260 0 : frequencies_p.resize(nChannels_p,false);
1261 :
1262 0 : if ( (manager_p->reindex_p) or inputOutputSPWIndexMap_p.size() == 0)
1263 : {
1264 0 : frequencies_p = spwFrequencies_p(spectralWindows_p(rowInBuffer));
1265 : }
1266 : else
1267 : {
1268 0 : uInt inputSPWIndex = spectralWindows_p(rowInBuffer);
1269 0 : uInt outputSPWIndex = inputOutputSPWIndexMap_p.find(inputSPWIndex)->second;
1270 0 : frequencies_p = spwFrequencies_p(outputSPWIndex);
1271 : }
1272 :
1273 0 : if (freqRefFrameTransRequested)
1274 : {
1275 :
1276 0 : MFrequency::Convert freqRefTranEngine = generateFreqRefTranEngine(time()(rowInBuffer),frame,false);
1277 0 : for (uInt chan_i=0;chan_i<frequencies_p.size();chan_i++)
1278 : {
1279 0 : frequencies_p(chan_i) = freqRefTranEngine (Quantity (frequencies_p(chan_i), "Hz")).get ("Hz").getValue();
1280 : }
1281 0 : }
1282 :
1283 0 : frequenciesTransformed_p = true;
1284 : }
1285 :
1286 0 : frequenciesOk_p = true;
1287 : }
1288 :
1289 0 : if (not frequenciesTransformed_p)
1290 : {
1291 0 : return manager_p->getVisBuffer()->getFrequencies(rowInBuffer,frame);
1292 : }
1293 :
1294 0 : return frequencies_p;
1295 :
1296 : }
1297 :
1298 : // -----------------------------------------------------------------------
1299 : //
1300 : // -----------------------------------------------------------------------
1301 0 : const MDirection & MSTransformBufferImpl::phaseCenter () const
1302 : {
1303 0 : return manager_p->getVisBuffer()->phaseCenter();
1304 : }
1305 :
1306 : // -----------------------------------------------------------------------
1307 : //
1308 : // -----------------------------------------------------------------------
1309 0 : const MFrequency::Types & MSTransformBufferImpl::freqRefFrameType () const
1310 : {
1311 0 : if ( not freqRefFrameTypeOk_p)
1312 : {
1313 0 : spectralWindows();
1314 :
1315 : uInt inputSPWIndex;
1316 0 : if ( (manager_p->reindex_p) or inputOutputSPWIndexMap_p.size() == 0)
1317 : {
1318 0 : inputSPWIndex = spectralWindows_p(0);
1319 : }
1320 : else
1321 : {
1322 0 : inputSPWIndex = inputOutputSPWIndexMap_p.find(spectralWindows_p(0))->second;
1323 : }
1324 :
1325 0 : MFrequency refFrame = Vector<MFrequency>(spwRefRame_p(inputSPWIndex))(0);
1326 0 : freqRefFrameType_p = MFrequency::castType (refFrame.getRef().getType());
1327 0 : }
1328 :
1329 0 : return freqRefFrameType_p;
1330 : }
1331 :
1332 :
1333 : // -----------------------------------------------------------------------
1334 : //
1335 : // -----------------------------------------------------------------------
1336 0 : MFrequency::Convert MSTransformBufferImpl::generateFreqRefTranEngine ( Double time,
1337 : Int outputRefFrame,
1338 : Bool toObservedFrame) const
1339 : {
1340 : // Construct input (observed) ref. frame object
1341 0 : MDirection direction = phaseCenter();
1342 0 : MEpoch epoch (MVEpoch (Quantity (time, "s")));
1343 0 : MPosition position = observatoryPosition_p;
1344 0 : MFrequency::Types refFrameType = freqRefFrameType();
1345 0 : MeasFrame inputRefFrame (epoch, position, direction);
1346 0 : MFrequency::Ref inputFreqRefFrame (refFrameType, inputRefFrame);
1347 :
1348 : // Construct output ref. frame
1349 0 : MFrequency::Types outputFreqRefFrame = static_cast<MFrequency::Types> (outputRefFrame);
1350 :
1351 : // Generate freq. trans engine
1352 0 : MFrequency::Convert result;
1353 0 : if (toObservedFrame)
1354 : {
1355 0 : result = MFrequency::Convert (outputFreqRefFrame, inputFreqRefFrame);
1356 : }
1357 : else
1358 : {
1359 0 : result = MFrequency::Convert (inputFreqRefFrame, outputFreqRefFrame);
1360 : }
1361 :
1362 0 : return result;
1363 0 : }
1364 :
1365 : // -----------------------------------------------------------------------
1366 : //
1367 : // -----------------------------------------------------------------------
1368 0 : Int MSTransformBufferImpl::getChannelNumber (Int rowInBuffer, Int frequencyIndex) const
1369 : {
1370 0 : Bool newFrequencies = manager_p->combinespws_p ||
1371 0 : manager_p->refFrameTransformation_p ||
1372 0 : manager_p->channelAverage_p ||
1373 0 : (manager_p->nspws_p > 1);
1374 :
1375 0 : if (not newFrequencies)
1376 : {
1377 0 : return manager_p->getVisBuffer()->getChannelNumber (rowInBuffer,frequencyIndex);
1378 : }
1379 :
1380 0 : return frequencyIndex;
1381 : }
1382 :
1383 : // -----------------------------------------------------------------------
1384 : //
1385 : // -----------------------------------------------------------------------
1386 0 : const Vector<Int> & MSTransformBufferImpl::getChannelNumbers (Int rowInBuffer) const
1387 : {
1388 0 : if (not channelNumbersOk_p)
1389 : {
1390 0 : Bool newFrequencies = manager_p->combinespws_p ||
1391 0 : manager_p->refFrameTransformation_p ||
1392 0 : manager_p->channelAverage_p ||
1393 0 : (manager_p->nspws_p > 1);
1394 :
1395 0 : if (not newFrequencies)
1396 : {
1397 0 : channelNumbersTransformed_p = false;
1398 : }
1399 : else
1400 : {
1401 0 : getShape();
1402 0 : channelNumbers_p.resize(nChannels_p,false);
1403 :
1404 0 : for (uInt chanIdx = 0; chanIdx<nChannels_p;chanIdx++)
1405 : {
1406 0 : channelNumbers_p(chanIdx) = chanIdx;
1407 : }
1408 :
1409 0 : channelNumbersTransformed_p = true;
1410 : }
1411 :
1412 0 : channelNumbersOk_p = true;
1413 : }
1414 :
1415 0 : if (not channelNumbersTransformed_p)
1416 : {
1417 0 : return manager_p->getVisBuffer()->getChannelNumbers(rowInBuffer);
1418 : }
1419 :
1420 0 : return channelNumbers_p;
1421 : }
1422 :
1423 : // -----------------------------------------------------------------------
1424 : //
1425 : // -----------------------------------------------------------------------
1426 0 : Vector<Int> MSTransformBufferImpl::getChannelNumbersSelected (Int outputChannelIndex) const
1427 : {
1428 0 : if (not channelNumbersSelectedOk_p)
1429 : {
1430 : // Make sure output channel numbers are filled in and map is cleared
1431 0 : outputInputChannelMap_p.clear();
1432 0 : Vector<Int> channelNumbers = getChannelNumbers(0); // Sometimes is FW directly from the inner VB
1433 :
1434 : // Get current SPW
1435 0 : Int inputSpw = manager_p->getVisBuffer()->spectralWindows()[0];
1436 :
1437 : // If there is no chan. selection for this SPW create a dummy selection
1438 0 : if (manager_p->inputOutputChanIndexMap_p.find(inputSpw) == manager_p->inputOutputChanIndexMap_p.end())
1439 : {
1440 0 : manager_p->inputOutputChanIndexMap_p[inputSpw] = vector<Int>(manager_p->getVisBuffer()->nChannels(),0);
1441 0 : for (Int idx=0;idx<manager_p->getVisBuffer()->nChannels();idx++)
1442 : {
1443 0 : manager_p->inputOutputChanIndexMap_p[inputSpw].at(idx) = idx;
1444 : }
1445 : }
1446 :
1447 : // If there is no channel average just map input-output channel
1448 : Int selectedChannel;
1449 0 : if (not manager_p->channelAverage_p)
1450 : {
1451 0 : for (uInt outChanIdx=0;outChanIdx<channelNumbers.size();outChanIdx++)
1452 : {
1453 0 : selectedChannel = manager_p->inputOutputChanIndexMap_p[inputSpw].at(outChanIdx);
1454 : // CAS-8018: If there is not channel average (also trigger by chanbin=1)
1455 : // Then getChannelNumbers are not an index ranging from 0 to nOutChans
1456 : // but the actual channel selection from the inner VI/VB
1457 0 : outputInputChannelMap_p[outChanIdx] = Vector<Int>(1,selectedChannel);
1458 : }
1459 : }
1460 : // If there channel average map all selected channels falling in each bin
1461 : else
1462 : {
1463 0 : for (uInt outChanIdx=0;outChanIdx<channelNumbers.size();outChanIdx++)
1464 : {
1465 : // CAS-8018: If there is channel average then getChannelNumbers
1466 : // is just an index ranging from 0 to nOutChans so there
1467 : // is no need to re-map it.
1468 0 : outputInputChannelMap_p[outChanIdx] =
1469 0 : Vector<Int>(manager_p->dataHandler_p->getSelectedChannelsMap()[inputSpw][outChanIdx]);
1470 : }
1471 : }
1472 :
1473 0 : channelNumbersSelectedOk_p = true;
1474 0 : }
1475 :
1476 0 : return outputInputChannelMap_p[outputChannelIndex];
1477 : }
1478 :
1479 : // -----------------------------------------------------------------------
1480 : //
1481 : // -----------------------------------------------------------------------
1482 0 : const Vector<rownr_t> & MSTransformBufferImpl::rowIds () const
1483 : {
1484 0 : if (not rowIdsOk_p)
1485 : {
1486 0 : Bool newFrequencies = manager_p->combinespws_p ||
1487 0 : manager_p->refFrameTransformation_p ||
1488 0 : manager_p->channelAverage_p ||
1489 0 : (manager_p->nspws_p > 1);
1490 :
1491 0 : if (not newFrequencies)
1492 : {
1493 0 : rowIdsTransformed_p = false;
1494 : }
1495 : else
1496 : {
1497 0 : getShape();
1498 0 : rowIds_p.resize(nRows_p,false);
1499 :
1500 0 : for (uInt rowIdx = 0; rowIdx<nRows_p;rowIdx++)
1501 : {
1502 0 : rowIds_p(rowIdx) = rowIdOffset_p + rowIdx;
1503 : }
1504 :
1505 0 : rowIdsTransformed_p = true;
1506 : }
1507 :
1508 0 : rowIdsOk_p = true;
1509 : }
1510 :
1511 0 : if (not rowIdsTransformed_p)
1512 : {
1513 0 : return manager_p->getVisBuffer()->rowIds();
1514 : }
1515 :
1516 0 : return rowIds_p;
1517 : }
1518 :
1519 : // -----------------------------------------------------------------------
1520 : //
1521 : // -----------------------------------------------------------------------
1522 0 : IPosition MSTransformBufferImpl::getShape () const
1523 : {
1524 0 : if (not shapeOk_p)
1525 : {
1526 0 : shape_p = manager_p->getShape();
1527 0 : nRows_p = shape_p(2);
1528 0 : nChannels_p = shape_p(1);
1529 0 : nCorrelations_p = shape_p(0);
1530 0 : nAntennas_p = manager_p->getVisBuffer()->nAntennas();
1531 0 : shapeOk_p = true;
1532 : }
1533 :
1534 0 : return shape_p;
1535 : }
1536 :
1537 : // -----------------------------------------------------------------------
1538 : //
1539 : // -----------------------------------------------------------------------
1540 0 : rownr_t MSTransformBufferImpl::nRows () const
1541 : {
1542 0 : if (not nRowsOk_p)
1543 : {
1544 0 : getShape();
1545 0 : nRowsOk_p = true;
1546 : }
1547 :
1548 0 : return nRows_p;
1549 : }
1550 :
1551 : // -----------------------------------------------------------------------
1552 : //
1553 : // -----------------------------------------------------------------------
1554 0 : Int MSTransformBufferImpl::nChannels () const
1555 : {
1556 0 : if (not nChannelsOk_p)
1557 : {
1558 0 : getShape();
1559 0 : nChannelsOk_p = true;
1560 : }
1561 :
1562 0 : return nChannels_p;
1563 : }
1564 :
1565 : // -----------------------------------------------------------------------
1566 : //
1567 : // -----------------------------------------------------------------------
1568 0 : Int MSTransformBufferImpl::nCorrelations () const
1569 : {
1570 0 : if (not nCorrelationsOk_p)
1571 : {
1572 0 : getShape();
1573 0 : nCorrelationsOk_p = true;
1574 : }
1575 :
1576 0 : return nCorrelations_p;
1577 : }
1578 :
1579 : // -----------------------------------------------------------------------
1580 : //
1581 : // -----------------------------------------------------------------------
1582 0 : Int MSTransformBufferImpl::nAntennas () const
1583 : {
1584 0 : if (not nAntennasOk_p)
1585 : {
1586 0 : getShape();
1587 0 : nAntennasOk_p = true;
1588 : }
1589 :
1590 0 : return nAntennas_p;
1591 : }
1592 :
1593 :
1594 : // -----------------------------------------------------------------------
1595 : // Rotate visibility phase for given vector (dim = nrow of vb) of phases (meters)
1596 : // phase*(-2*pi*f/c) gives phase for the channel of the given baseline in radian
1597 : // sign convention will _correct_ data
1598 : // -----------------------------------------------------------------------
1599 0 : void MSTransformBufferImpl::phaseCenterShift(const Vector<Double>& phase)
1600 : {
1601 : // Trigger phase center shift in the inner buffer as it always has to happen before any averaging
1602 0 : manager_p->getVisBuffer()->phaseCenterShift(phase);
1603 :
1604 : // Clear vis cube state so that they are re-filled and re-averaged with the shifted visibilities
1605 0 : visCubeOk_p = false;
1606 0 : visCubeCorrectedOk_p = false;
1607 0 : visCubeModelOk_p = false;
1608 :
1609 0 : return;
1610 : }
1611 :
1612 : // -----------------------------------------------------------------------
1613 : // Rotate visibility phase for phase center offsets
1614 : // -----------------------------------------------------------------------
1615 0 : void MSTransformBufferImpl::phaseCenterShift(Double dx, Double dy)
1616 : {
1617 : // Trigger phase center shift in the inner buffer as it always has to happen before any averaging
1618 0 : manager_p->getVisBuffer()->phaseCenterShift(dx,dy);
1619 :
1620 : // Clear vis cube state so that they are re-filled and re-averaged with the shifted visibilities
1621 0 : visCubeOk_p = false;
1622 0 : visCubeCorrectedOk_p = false;
1623 0 : visCubeModelOk_p = false;
1624 :
1625 0 : return;
1626 : }
1627 :
1628 : // -----------------------------------------------------------------------
1629 : //
1630 : // -----------------------------------------------------------------------
1631 0 : void MSTransformBufferImpl::transformDataCube( vi::VisBuffer2 *vb,
1632 : DataCubeMap &inputDataCubeMap,
1633 : DataCubeMap &outputDataCubeMap,
1634 : TransformFunction funcPointer) const
1635 : {
1636 0 : uInt nRows = vb->nRows();
1637 0 : uInt nCorrs = vb->nCorrelations();
1638 :
1639 0 : for (uInt rowIndex=0; rowIndex < nRows; rowIndex++)
1640 : {
1641 : // Switch input data to current row
1642 0 : inputDataCubeMap.setMatrixIndex(rowIndex);
1643 0 : outputDataCubeMap.setMatrixIndex(rowIndex);
1644 :
1645 0 : for (uInt corrIndex=0; corrIndex < nCorrs; corrIndex++)
1646 : {
1647 : // Switch input data to current row
1648 0 : inputDataCubeMap.setVectorIndex(corrIndex);
1649 0 : outputDataCubeMap.setVectorIndex(corrIndex);
1650 :
1651 : // Process data
1652 0 : (*this.*funcPointer)(vb,inputDataCubeMap,outputDataCubeMap);
1653 : }
1654 : }
1655 :
1656 0 : return;
1657 : }
1658 :
1659 : // -----------------------------------------------------------------------
1660 : //
1661 : // -----------------------------------------------------------------------
1662 0 : void MSTransformBufferImpl::decimationWindow( vi::VisBuffer2 *vb,
1663 : DataCubeMap &inputDataCubeMap,
1664 : DataCubeMap &outputDataCubeMap,
1665 : TransformKernel1D kernelPointer) const
1666 : {
1667 0 : uInt width = inputDataCubeMap.getWindowShape()(0);
1668 0 : uInt inputSize = inputDataCubeMap.getVectorShape()(0);
1669 0 : uInt outputSize = outputDataCubeMap.getVectorShape()(0);
1670 :
1671 0 : uInt outputIndex = 0;
1672 0 : uInt inputStartIndex = 0;
1673 0 : uInt tail = inputSize % width;
1674 0 : uInt limit = inputSize - tail;
1675 :
1676 0 : while (inputStartIndex < limit)
1677 : {
1678 0 : (*this.*kernelPointer)( vb,
1679 : inputDataCubeMap,
1680 : outputDataCubeMap,
1681 : inputStartIndex,
1682 : outputIndex,
1683 : width);
1684 0 : outputIndex += 1;
1685 0 : inputStartIndex += width;
1686 : }
1687 :
1688 0 : if (tail > 0 and outputIndex < outputSize )
1689 : {
1690 0 : (*this.*kernelPointer)( vb,
1691 : inputDataCubeMap,
1692 : outputDataCubeMap,
1693 : inputStartIndex,
1694 : outputIndex,
1695 : tail);
1696 : }
1697 :
1698 0 : return;
1699 : }
1700 :
1701 : // -----------------------------------------------------------------------
1702 : //
1703 : // -----------------------------------------------------------------------
1704 0 : void MSTransformBufferImpl::channelAverage( vi::VisBuffer2 *vb,
1705 : DataCubeMap &inputDataCubeMap,
1706 : DataCubeMap &outputDataCubeMap) const
1707 : {
1708 0 : decimationWindow(vb,inputDataCubeMap,outputDataCubeMap,&MSTransformBufferImpl::flagAverageKernel);
1709 0 : return;
1710 : }
1711 :
1712 :
1713 : // -----------------------------------------------------------------------
1714 : //
1715 : // -----------------------------------------------------------------------
1716 0 : void MSTransformBufferImpl::flagAverageKernel( vi::VisBuffer2 *,
1717 : DataCubeMap &inputDataCubeMap,
1718 : DataCubeMap &outputDataCubeMap,
1719 : uInt &inputPos,
1720 : uInt &outputPos,
1721 : uInt &kernelSize) const
1722 : {
1723 0 : Vector<Bool> inputFlags = inputDataCubeMap.getVector<Bool>(MS::FLAG);
1724 0 : Vector<Bool> outputFlags = outputDataCubeMap.getVector<Bool>(MS::FLAG);
1725 :
1726 0 : Bool outputFlag = true;
1727 0 : for (uInt deltaPos=0;deltaPos<kernelSize;deltaPos++)
1728 : {
1729 0 : if (not inputFlags(inputPos+deltaPos))
1730 : {
1731 0 : outputFlag = false;
1732 0 : break;
1733 : }
1734 : }
1735 :
1736 0 : outputFlags(outputPos) = outputFlag;
1737 :
1738 0 : return;
1739 0 : }
1740 :
1741 :
1742 : } //# NAMESPACE CASA - END
1743 :
1744 :
|
