Line data Source code
1 : //# MSTransformManager.h: This file contains the interface definition of the MSTransformManager 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 : #ifndef MSTransformManager_H_
24 : #define MSTransformManager_H_
25 :
26 : // To handle configuration records
27 : #include <casacore/casa/Containers/Record.h>
28 :
29 : // To handle variant parameters
30 : #include <stdcasa/StdCasa/CasacSupport.h>
31 :
32 : // Measurement Set Selection
33 : #include <casacore/ms/MSSel/MSSelection.h>
34 :
35 : // casacore::Data handling
36 : #include <mstransform/MSTransform/MSTransformDataHandler.h>
37 :
38 : // Regridding
39 : #include <mstransform/MSTransform/MSTransformRegridder.h>
40 :
41 : // VisibityIterator / VisibilityBuffer framework
42 : #include <msvis/MSVis/VisibilityIterator2.h>
43 : #include <msvis/MSVis/VisBuffer2.h>
44 : #include <msvis/MSVis/ViFrequencySelection.h>
45 :
46 : // TVI framework
47 : #include <msvis/MSVis/ViiLayerFactory.h>
48 : #include <msvis/MSVis/IteratingParameters.h>
49 : #include <msvis/MSVis/AveragingVi2Factory.h>
50 : #include <msvis/MSVis/LayeredVi2Factory.h>
51 : #include <mstransform/TVI/UVContSubTVI.h>
52 : #include <mstransform/TVI/PhaseShiftingTVI.h>
53 :
54 : // THis is needed just because of vi::AveragingTvi2::weightToSigma
55 : #include <msvis/MSVis/AveragingTvi2.h>
56 :
57 : // To apply hanning smooth
58 : #include <casacore/scimath/Mathematics/Smooth.h>
59 :
60 : // To apply fft shift
61 : #include <casacore/scimath/Mathematics/FFTServer.h>
62 :
63 : // To apply 1D interpolations
64 : #include <casacore/scimath/Mathematics/InterpolateArray1D.h>
65 :
66 : // single dish specific
67 : #include <casacore/scimath/Mathematics/Convolver.h>
68 :
69 : #include <map>
70 :
71 : namespace casa { //# NAMESPACE CASA - BEGIN
72 :
73 : // Forward declarations
74 : class MSTransformBufferImpl;
75 : class MSTransformIterator;
76 : class MSTransformIteratorFactory;
77 :
78 : // casacore::MS Transform Framework utilities
79 : namespace MSTransformations
80 : {
81 : // Returns 1/sqrt(wt) or -1, depending on whether wt is positive..
82 : casacore::Double wtToSigma(casacore::Double wt);
83 : casacore::Double sigmaToWeight(casacore::Double wt);
84 :
85 : enum InterpolationMethod {
86 : // nearest neighbour
87 : nearestNeighbour,
88 : // linear
89 : linear,
90 : // cubic
91 : cubic,
92 : // cubic spline
93 : spline,
94 : // fft shift
95 : fftshift
96 : };
97 :
98 : enum WeightingSetup {
99 : spectrum,
100 : flags,
101 : cumSum,
102 : flat,
103 : flagSpectrum,
104 : flagCumSum,
105 : flagsNonZero,
106 : flagSpectrumNonZero,
107 : flagCumSumNonZero
108 : };
109 :
110 : enum SmoothingSetup {
111 : plainSmooth,
112 : plainSmoothSpectrum
113 : };
114 :
115 : enum dataCol {
116 : visCube,
117 : visCubeCorrected,
118 : visCubeModel,
119 : visCubeFloat,
120 : weightSpectrum,
121 : sigmaSpectrum
122 : };
123 :
124 : enum weightTransformation {
125 :
126 : transformWeight,
127 : transformWeightIntoSigma,
128 : weightIntoSigma
129 : };
130 : }
131 :
132 : // Forward declarations
133 : struct spwInfo;
134 : struct channelContribution;
135 :
136 : // casacore::Map definition
137 : typedef map<casacore::MS::PredefinedColumns,casacore::MS::PredefinedColumns> dataColMap;
138 : typedef map< pair< pair<casacore::uInt,casacore::uInt> , casacore::uInt >,std::vector<casacore::uInt> > baselineMap;
139 : typedef map<casacore::uInt,map<casacore::uInt, casacore::uInt > > inputSpwChanMap;
140 : typedef map<casacore::uInt,vector < channelContribution > > inputOutputChanFactorMap;
141 : typedef map<casacore::uInt,pair < spwInfo, spwInfo > > inputOutputSpwMap;
142 :
143 : // Struct definition
144 : struct channelInfo {
145 :
146 : casacore::Int SPW_id;
147 : casacore::uInt inpChannel;
148 : casacore::uInt outChannel;
149 : casacore::Double CHAN_FREQ;
150 : casacore::Double CHAN_WIDTH;
151 : casacore::Double EFFECTIVE_BW;
152 : casacore::Double RESOLUTION;
153 : std::vector<casacore::Double> contribFrac;
154 : std::vector<casacore::Int> contribChannel;
155 : std::vector<casacore::Int> contribSPW_id;
156 :
157 132887 : channelInfo()
158 132887 : {
159 132887 : SPW_id = -1;
160 132887 : inpChannel = 0;
161 132887 : outChannel = 0;
162 :
163 132887 : CHAN_FREQ = -1;
164 132887 : CHAN_WIDTH = -1;
165 132887 : EFFECTIVE_BW = -1;
166 132887 : RESOLUTION = -1;
167 132887 : }
168 :
169 980507 : bool operator<(const channelInfo& right_operand) const
170 : {
171 980507 : if (CHAN_FREQ<right_operand.CHAN_FREQ)
172 : {
173 712460 : return true;
174 : }
175 : else
176 : {
177 268047 : return false;
178 : }
179 : }
180 :
181 : casacore::Double upperBound() const
182 : {
183 : return CHAN_FREQ + 0.5 * std::abs(CHAN_WIDTH);
184 : }
185 :
186 : casacore::Double lowerBound() const
187 : {
188 : return CHAN_FREQ - 0.5 * std::abs(CHAN_WIDTH);
189 : }
190 :
191 : casacore::Double overlap(const channelInfo& other) const
192 : {
193 :
194 : // The other channel completely covers this channel
195 : if ((lowerBound() <= other.lowerBound()) and (upperBound() >= other.upperBound()))
196 : {
197 : return 1.0;
198 : }
199 : // The other channel is completely covered by this channel
200 : else if ((lowerBound() >= other.lowerBound()) and (upperBound() <= other.upperBound()))
201 : {
202 : return CHAN_WIDTH/other.CHAN_WIDTH;
203 : }
204 : // Lower end of this channel is overlapping with the other channel
205 : else if (lowerBound() < other.lowerBound() && other.lowerBound() < upperBound() && upperBound() < other.upperBound())
206 : {
207 : return (upperBound()-other.lowerBound())/other.CHAN_WIDTH;
208 : }
209 : // Upper end of this channel is overlapping with the other channel
210 : else if (other.lowerBound() < lowerBound() && lowerBound() < other.upperBound() && other.upperBound() < upperBound())
211 : {
212 : return (other.upperBound()-lowerBound())/other.CHAN_WIDTH;
213 : }
214 : else
215 : {
216 : return 0.0;
217 : }
218 :
219 : }
220 : };
221 :
222 : struct channelContribution {
223 :
224 : casacore::Int inpSpw;
225 : casacore::uInt inpChannel;
226 : casacore::uInt outChannel;
227 : casacore::Double weight;
228 : bool flag;
229 :
230 : channelContribution()
231 : {
232 : inpSpw = 0;
233 : inpChannel = 0;
234 : outChannel = 0;
235 : weight = 0;
236 : flag = false;
237 : }
238 :
239 82102 : channelContribution(casacore::Int inputSpw, casacore::uInt inputChannel, casacore::uInt outputChannel,casacore::Double fraction)
240 82102 : {
241 82102 : inpSpw = inputSpw;
242 82102 : inpChannel = inputChannel;
243 82102 : outChannel = outputChannel;
244 82102 : weight = fraction;
245 82102 : flag = true;
246 82102 : }
247 : };
248 :
249 : struct spwInfo {
250 :
251 380 : spwInfo()
252 380 : {
253 380 : initialize(0);
254 380 : }
255 :
256 : spwInfo(casacore::uInt nChannels)
257 : {
258 : initialize(nChannels);
259 : }
260 :
261 380 : spwInfo(casacore::Vector<casacore::Double> &chanFreq,casacore::Vector<casacore::Double> &chanWidth)
262 380 : {
263 380 : reset(chanFreq,chanWidth);
264 380 : }
265 :
266 380 : void reset(casacore::Vector<casacore::Double> &chanFreq,casacore::Vector<casacore::Double> &chanWidth)
267 : {
268 380 : initialize(chanFreq.size());
269 380 : CHAN_FREQ = chanFreq;
270 380 : CHAN_WIDTH = chanWidth;
271 380 : update();
272 380 : }
273 :
274 760 : void initialize(casacore::uInt nChannels)
275 : {
276 760 : NUM_CHAN = nChannels;
277 760 : CHAN_FREQ.resize(nChannels,false);
278 760 : CHAN_WIDTH.resize(nChannels,false);
279 760 : EFFECTIVE_BW.resize(nChannels,false);
280 760 : RESOLUTION.resize(nChannels,false);
281 760 : CHAN_FREQ_aux.resize(nChannels,false);
282 760 : TOTAL_BANDWIDTH = 0;
283 760 : REF_FREQUENCY = 0;
284 760 : upperBound = 0;
285 760 : lowerBound = 0;
286 760 : }
287 :
288 380 : void update()
289 : {
290 380 : if (CHAN_FREQ(NUM_CHAN - 1) > CHAN_FREQ(0)) {
291 347 : upperBound = CHAN_FREQ(NUM_CHAN-1) + 0.5 * std::abs(CHAN_WIDTH(NUM_CHAN-1));
292 347 : lowerBound = CHAN_FREQ(0) - 0.5 * std::abs(CHAN_WIDTH(0));
293 : // ensure width is positive
294 144896 : for (auto it = CHAN_WIDTH.begin(); it != CHAN_WIDTH.end(); ++it) {
295 144549 : *it = std::abs(*it);
296 : }
297 : }
298 : else {
299 33 : upperBound = CHAN_FREQ(0) + 0.5 * std::abs(CHAN_WIDTH(0));
300 33 : lowerBound = CHAN_FREQ(NUM_CHAN-1) - 0.5 * std::abs(CHAN_WIDTH(NUM_CHAN-1));
301 : // ensure width is negative, may not be the case regridding (without combine)
302 : // preserves the sign but the width computation is always positive due to use
303 : // of original combine+regrid cvel code that converts all channels to ascending
304 17134 : for (auto it = CHAN_WIDTH.begin(); it != CHAN_WIDTH.end(); ++it) {
305 17101 : if (*it > 0) {
306 5025 : *it = -*it;
307 : }
308 : }
309 : }
310 :
311 380 : TOTAL_BANDWIDTH = upperBound - lowerBound;
312 380 : REF_FREQUENCY = CHAN_FREQ(0);
313 :
314 380 : CHAN_FREQ_aux = CHAN_FREQ;
315 380 : EFFECTIVE_BW = CHAN_WIDTH;
316 380 : RESOLUTION = CHAN_WIDTH;
317 380 : }
318 :
319 0 : void resize(casacore::uInt nChannels)
320 : {
321 0 : NUM_CHAN = nChannels;
322 0 : CHAN_FREQ.resize(nChannels,true);
323 0 : CHAN_WIDTH.resize(nChannels,true);
324 0 : EFFECTIVE_BW.resize(nChannels,true);
325 0 : RESOLUTION.resize(nChannels,true);
326 0 : CHAN_FREQ_aux.resize(nChannels,true);
327 0 : update();
328 0 : }
329 :
330 : casacore::uInt NUM_CHAN;
331 : casacore::Vector<casacore::Double> CHAN_FREQ;
332 : casacore::Vector<casacore::Double> CHAN_WIDTH;
333 : casacore::Vector<casacore::Double> EFFECTIVE_BW;
334 : casacore::Vector<casacore::Double> RESOLUTION;
335 : casacore::Vector<casacore::Double> CHAN_FREQ_aux;
336 : casacore::Double TOTAL_BANDWIDTH;
337 : casacore::Double REF_FREQUENCY;
338 : casacore::Double upperBound;
339 : casacore::Double lowerBound;
340 : };
341 :
342 : // MSTransformManager definition
343 : class MSTransformManager
344 : {
345 :
346 : friend class MSTransformBufferImpl;
347 : friend class MSTransformIterator;
348 : friend class MSTransformIteratorFactory;
349 :
350 : public:
351 :
352 : MSTransformManager();
353 : MSTransformManager(casacore::Record configuration);
354 :
355 : virtual ~MSTransformManager();
356 :
357 : void initialize();
358 : void configure(casacore::Record &configuration);
359 :
360 : void open();
361 : void setup();
362 : void close();
363 :
364 : void setupBufferTransformations(vi::VisBuffer2 *vb);
365 : void fillOutputMs(vi::VisBuffer2 *vb);
366 :
367 : // For buffer handling classes (MSTransformIterator)
368 :
369 : // Needed by MSTransformIteratorFactory
370 1849 : vi::VisibilityIterator2 * getVisIter() {return visibilityIterator_p;}
371 :
372 : // Needed by MSTransformIterator
373 743 : casacore::MeasurementSet * getOutputMs () {return outputMs_p;};
374 0 : casacore::String getOutputMsName () {return outMsName_p;};
375 :
376 : // Needed by MSTransformBuffer
377 0 : vi::VisBuffer2 * getVisBuffer() {return visibilityIterator_p->getVisBuffer();}
378 : casacore::IPosition getShape();
379 : casacore::IPosition getTransformedShape(vi::VisBuffer2 *inputVisBuffer);
380 :
381 : // Need by tMSTransformIterator
382 : dataColMap getDataColMap() { return dataColMap_p;}
383 :
384 :
385 :
386 : protected:
387 :
388 : void parseMsSpecParams(casacore::Record &configuration);
389 : void parseDataSelParams(casacore::Record &configuration);
390 : void parseFreqTransParams(casacore::Record &configuration);
391 : void parseChanAvgParams(casacore::Record &configuration);
392 : void parseRefFrameTransParams(casacore::Record &configuration);
393 : void parseFreqSpecParams(casacore::Record &configuration);
394 : void parsePhaseShiftParams(casacore::Record &configuration);
395 : void parseTimeAvgParams(casacore::Record &configuration);
396 : void parseCalParams(casacore::Record &configuration);
397 : void parseUVContSubParams(casacore::Record &configuration);
398 : void setSpwAvg(casacore::Record &configuration);
399 : void parsePolAvgParams(casacore::Record &configuration);
400 : void parsePointingsInterpolationParams(casacore::Record &configuration);
401 : void parseAtmCorrectionParams(casacore::Record &configuration);
402 :
403 : // From input MS
404 : void initDataSelectionParams();
405 : void getInputNumberOfChannels();
406 :
407 : // To re-grid SPW subtable
408 : void initRefFrameTransParams();
409 : casacore::MFrequency::Types determineInputRefFrame();
410 : casacore::MDirection determinePhaseCenter();
411 : void regridSpwSubTable();
412 : void regridAndCombineSpwSubtable();
413 : /// Regrids one SPW
414 : void regridSpwAux(casacore::Int spwId, casacore::MFrequency::Types spwInputRefFrame,
415 : casacore::Vector<casacore::Double> &inputCHAN_FREQ,
416 : casacore::Vector<casacore::Double> &inputCHAN_WIDTH,
417 : casacore::Vector<casacore::Double> &originalCHAN_FREQ,
418 : casacore::Vector<casacore::Double> &originalCHAN_WIDTH,
419 : casacore::Vector<casacore::Double> ®riddedCHAN_FREQ,
420 : casacore::Vector<casacore::Double> ®riddedCHAN_WIDTH,
421 : string msg);
422 :
423 : void reindexColumn(casacore::ScalarColumn<casacore::Int> &inputCol, casacore::Int value);
424 : void reindexSourceSubTable();
425 : void reindexDDISubTable();
426 : void reindexFeedSubTable();
427 : void reindexSysCalSubTable();
428 : void reindexFreqOffsetSubTable();
429 : void reindexGenericTimeDependentSubTable(const casacore::String& subtabname);
430 :
431 : void separateSpwSubtable();
432 : void separateFeedSubtable();
433 : void separateSourceSubtable();
434 : void separateSyscalSubtable();
435 : void separateFreqOffsetSubtable();
436 : void separateCalDeviceSubtable();
437 : void separateSysPowerSubtable();
438 :
439 : // To average polarization components
440 : casacore::Int getAveragedPolarizationId();
441 : void reindexPolarizationIdInDataDesc(casacore::Int newPolarizationId);
442 :
443 : // Setters for Weight-based transformation
444 : void propagateWeights(bool on);
445 : void setBufferMode(bool on);
446 : void setChannelAverageKernel(casacore::uInt mode);
447 : void setSmoothingKernel(casacore::uInt mode);
448 : void setSmoothingFourierKernel(casacore::uInt mode);
449 :
450 : // Drop channels with non-uniform width when doing channel average
451 : void dropNonUniformWidthChannels();
452 :
453 : // From output MS
454 : void getOutputNumberOfChannels();
455 :
456 : void checkAndPreaverageChannelsIfNeeded(Int spwId,
457 : Vector<Double> &inputCHAN_FREQ,
458 : Vector<Double> &inputCHAN_WIDTH,
459 : const Vector<Double> &originalCHAN_FREQ,
460 : const Vector<Double> &originalCHAN_WIDTH,
461 : const Vector<Double> ®riddedCHAN_FREQ,
462 : const Vector<Double> ®riddedCHAN_WIDTH);
463 : void doPreAveragingBeforeRegridding(uInt widthFactor, Int spwId,
464 : const Vector<Double> &originalCHAN_FREQ,
465 : const Vector<Double> &originalCHAN_WIDTH,
466 : Vector<Double> &inputCHAN_FREQ,
467 : Vector<Double> &inputCHAN_WIDTH);
468 :
469 : // For channel averaging and selection
470 : void calculateIntermediateFrequencies(casacore::Int spwId,
471 : const casacore::Vector<casacore::Double> &inputChanFreq,
472 : const casacore::Vector<casacore::Double> &inputChanWidth,
473 : casacore::Vector<casacore::Double> &intermediateChanFreq,
474 : casacore::Vector<casacore::Double> &intermediateChanWidth);
475 :
476 : void initGridForRegridTClean(const Vector<Double> &originalCHAN_FREQ,
477 : const Vector<Double> ®riddedCHAN_FREQ,
478 : const Vector<Double> ®riddedCHAN_WIDTH,
479 : Double widthFactor);
480 :
481 :
482 : void calculateWeightAndSigmaFactors();
483 : void calculateNewWeightAndSigmaFactors();
484 :
485 : // Column check
486 : void checkFillFlagCategory();
487 : void checkFillWeightSpectrum();
488 : void checkDataColumnsAvailable();
489 : void checkDataColumnsToFill();
490 : void colCheckInfo(const casacore::String& inputColName, const casacore::String& outputColName);
491 : void checkSPWChannelsKnownLimitation();
492 : void checkCorrelatorPreaveraging();
493 :
494 : // Iterator set-up
495 : virtual void setIterationApproach();
496 : void generateIterator();
497 :
498 : void initFrequencyTransGrid(vi::VisBuffer2 *vb);
499 : void fillIdCols(vi::VisBuffer2 *vb,casacore::RefRows &rowRef);
500 : void fillDataCols(vi::VisBuffer2 *vb,casacore::RefRows &rowRef);
501 :
502 : void fillWeightCols(vi::VisBuffer2 *vb,casacore::RefRows &rowRef);
503 : void transformAndWriteSpectrum( vi::VisBuffer2 *vb,
504 : casacore::RefRows &rowRef,
505 : const casacore::Cube<casacore::Float> &inputSpectrum,
506 : casacore::ArrayColumn<casacore::Float> &outputCubeCol,
507 : casacore::ArrayColumn<casacore::Float> &outputMatrixCol,
508 : MSTransformations::weightTransformation weightTransformation,
509 : bool flushSpectrumCube);
510 :
511 : template <class T> void setTileShape(casacore::RefRows &rowRef,casacore::ArrayColumn<T> &outputDataCol);
512 :
513 : const casacore::Cube<casacore::Float>& getApplicableSpectrum(vi::VisBuffer2 *vb, casacore::MS::PredefinedColumns datacol);
514 : casacore::ArrayColumn<casacore::Float>& getOutputWeightColumn(vi::VisBuffer2 *vb, casacore::MS::PredefinedColumns datacol);
515 : const casacore::Cube<casacore::Float>& getWeightSpectrumFromSigmaSpectrum(vi::VisBuffer2 *vb);
516 : const casacore::Cube<casacore::Float>& getWeightSpectrumFlat(vi::VisBuffer2 *vb);
517 :
518 : // Methods to transform and write vectors
519 :
520 : template <class T> void transformAndWriteNotReindexableVector( const casacore::Vector<T> &inputVector,
521 : casacore::Vector<T> &outputVector,
522 : bool constant,
523 : casacore::ScalarColumn<T> &outputCol,
524 : casacore::RefRows &rowReference);
525 :
526 : template <class T> void transformAndWriteReindexableVector( const casacore::Vector<T> &inputVector,
527 : casacore::Vector<T> &outputVector,
528 : bool constant,
529 : map<casacore::uInt,casacore::uInt> &inputOutputIndexMap,
530 : casacore::ScalarColumn<T> &outputCol,
531 : casacore::RefRows &rowReference);
532 :
533 : bool transformDDIVector(const casacore::Vector<casacore::Int> &inputVector,casacore::Vector<casacore::Int> &outputVector);
534 :
535 : void mapAndAverageVector( const casacore::Vector<casacore::Double> &inputVector,
536 : casacore::Vector<casacore::Double> &outputVector);
537 :
538 : void mapAndAverageVector( const casacore::Vector<bool> &inputVector,
539 : casacore::Vector<bool> &outputVector);
540 :
541 : // Templates methods to transform vectors that must be available for MSTransformBuffer
542 :
543 4851746 : template <class T> bool transformNotReindexableVector( const casacore::Vector<T> &inputVector,
544 : casacore::Vector<T> &outputVector,
545 : bool constant)
546 : {
547 4851746 : bool transformed = true;
548 :
549 4851746 : if ((combinespws_p) or (nspws_p >1))
550 : {
551 203568 : if (constant)
552 : {
553 36926 : outputVector = inputVector(0);
554 : }
555 : else
556 : {
557 64858 : mapVector(inputVector,outputVector);
558 : }
559 : }
560 : else
561 : {
562 4749962 : transformed = false;
563 : }
564 :
565 4851746 : return transformed;
566 : };
567 :
568 2273208 : template <class T> bool transformReindexableVector( const casacore::Vector<T> &inputVector,
569 : casacore::Vector<T> &outputVector,
570 : bool constant,
571 : map<casacore::uInt,casacore::uInt> &inputOutputIndexMap)
572 : {
573 2273208 : bool transformed = true;
574 :
575 2273208 : if (inputOutputIndexMap.size() == 0)
576 : {
577 1933294 : transformed = transformNotReindexableVector(inputVector,outputVector,constant);
578 : }
579 : else
580 : {
581 339914 : if (constant)
582 : {
583 332160 : outputVector = inputOutputIndexMap[inputVector(0)];
584 : }
585 7754 : else if (combinespws_p)
586 : {
587 204 : mapAndReindexVector(inputVector,outputVector,inputOutputIndexMap);
588 : }
589 : else
590 : {
591 7550 : reindexVector(inputVector,outputVector,inputOutputIndexMap);
592 : }
593 : }
594 :
595 2273208 : return transformed;
596 : };
597 :
598 204 : template <class T> void mapAndReindexVector( const casacore::Vector<T> &inputVector,
599 : casacore::Vector<T> &outputVector,
600 : map<casacore::uInt,casacore::uInt> &inputOutputIndexMap)
601 : {
602 204 : if (nspws_p <2)
603 : {
604 606 : for (casacore::uInt index=0; index<rowIndex_p.size();index++)
605 : {
606 402 : outputVector(index) = inputOutputIndexMap[inputVector(rowIndex_p[index])];
607 : }
608 : }
609 : else
610 : {
611 0 : casacore::uInt absoluteIndex = 0;
612 0 : for (casacore::uInt index=0; index<rowIndex_p.size();index++)
613 : {
614 0 : for (casacore::uInt spwIndex=0;spwIndex < nspws_p; spwIndex++)
615 : {
616 0 : outputVector(absoluteIndex) = inputOutputIndexMap[inputVector(rowIndex_p[index])];
617 0 : absoluteIndex += 1;
618 : }
619 : }
620 : }
621 :
622 204 : return;
623 : }
624 :
625 :
626 7550 : template <class T> void reindexVector( const casacore::Vector<T> &inputVector,
627 : casacore::Vector<T> &outputVector,
628 : map<casacore::uInt,casacore::uInt> &inputOutputIndexMap)
629 : {
630 7550 : if (nspws_p <2)
631 : {
632 2683682 : for (casacore::uInt index=0; index<inputVector.shape()[0];index++)
633 : {
634 2676132 : outputVector(index) = inputOutputIndexMap[inputVector(index)];
635 : }
636 : }
637 : else
638 : {
639 0 : casacore::uInt absoluteIndex = 0;
640 0 : for (casacore::uInt index=0; index<inputVector.shape()[0];index++)
641 : {
642 0 : for (casacore::uInt spwIndex=0;spwIndex < nspws_p; spwIndex++)
643 : {
644 0 : outputVector(absoluteIndex) = inputOutputIndexMap[inputVector(index)];
645 0 : absoluteIndex += 1;
646 : }
647 : }
648 : }
649 :
650 7550 : return;
651 : };
652 :
653 64858 : template <class T> void mapVector( const casacore::Vector<T> &inputVector,
654 : casacore::Vector<T> &outputVector)
655 : {
656 64858 : if (nspws_p < 2)
657 : {
658 4076512 : for (casacore::uInt index=0; index<rowIndex_p.size();index++)
659 : {
660 4028858 : outputVector(index) = inputVector(rowIndex_p[index]);
661 : }
662 : }
663 : else
664 : {
665 17204 : casacore::uInt absoluteIndex = 0;
666 129098 : for (casacore::uInt index=0; index<rowIndex_p.size();index++)
667 : {
668 653406 : for (casacore::uInt spwIndex=0;spwIndex < nspws_p; spwIndex++)
669 : {
670 541512 : outputVector(absoluteIndex) = inputVector(rowIndex_p[index]);
671 541512 : absoluteIndex += 1;
672 : }
673 : }
674 : }
675 :
676 :
677 64858 : return;
678 : }
679 :
680 : // ------------------------------------------------------------------------------------
681 : // Fill the data from an input matrix with shape [nCol,nBaselinesxnSPWsxnScans/nStates]
682 : // into an output matrix with shape [nCol,nBaselinesxnScans/nStates]
683 : // ------------------------------------------------------------------------------------
684 7234 : template <class T> void mapMatrix( const casacore::Matrix<T> &inputMatrix,casacore::Matrix<T> &outputMatrix)
685 : {
686 : // Get number of columns
687 7234 : casacore::uInt nCols = outputMatrix.shape()(0);
688 :
689 518402 : for (casacore::uInt index=0; index<rowIndex_p.size();index++)
690 : {
691 2044672 : for (casacore::uInt col = 0; col < nCols; col++)
692 : {
693 1533504 : outputMatrix(col,index) = inputMatrix(col,rowIndex_p[index]);
694 : }
695 : }
696 :
697 7234 : return;
698 : }
699 :
700 :
701 : template <class T> void mapAndAverageMatrix( const casacore::Matrix<T> &inputMatrix,
702 : casacore::Matrix<T> &outputMatrix,
703 : bool convolveFlags=false,
704 : vi::VisBuffer2 *vb=NULL);
705 : template <class T> void mapAndScaleMatrix( const casacore::Matrix<T> &inputMatrix,
706 : casacore::Matrix<T> &outputMatrix,
707 : map<casacore::uInt,T> scaleMap,
708 : casacore::Vector<casacore::Int> spws);
709 : template <class T> void writeMatrix( const casacore::Matrix<T> &inputMatrix,
710 : casacore::ArrayColumn<T> &outputCol,
711 : casacore::RefRows &rowRef,
712 : casacore::uInt nBlocks);
713 :
714 : // Methods to transform and write cubes
715 :
716 : template <class T> void writeCube( const casacore::Cube<T> &inputCube,
717 : casacore::ArrayColumn<T> &outputCol,
718 : casacore::RefRows &rowRef);
719 :
720 : void transformCubeOfData( vi::VisBuffer2 *vb,
721 : casacore::RefRows &rowRef,
722 : const casacore::Cube<casacore::Complex> &inputDataCube,
723 : casacore::ArrayColumn<casacore::Complex> &outputDataCol,
724 : casacore::ArrayColumn<bool> *outputFlagCol,
725 : const casacore::Cube<casacore::Float> &inputWeightCube);
726 : void transformCubeOfData( vi::VisBuffer2 *vb,
727 : casacore::RefRows &rowRef,
728 : const casacore::Cube<casacore::Float> &inputDataCube,
729 : casacore::ArrayColumn<casacore::Float> &outputDataCol,
730 : casacore::ArrayColumn<bool> *outputFlagCol,
731 : const casacore::Cube<casacore::Float> &inputWeightCube);
732 : void (casa::MSTransformManager::*transformCubeOfDataComplex_p)( vi::VisBuffer2 *vb,
733 : casacore::RefRows &rowRef,
734 : const casacore::Cube<casacore::Complex> &inputDataCube,
735 : casacore::ArrayColumn<casacore::Complex> &outputDataCol,
736 : casacore::ArrayColumn<bool> *outputFlagCol,
737 : const casacore::Cube<casacore::Float> &inputWeightCube);
738 : void (casa::MSTransformManager::*transformCubeOfDataFloat_p)( vi::VisBuffer2 *vb,
739 : casacore::RefRows &rowRef,
740 : const casacore::Cube<casacore::Float> &inputDataCube,
741 : casacore::ArrayColumn<casacore::Float> &outputDataCol,
742 : casacore::ArrayColumn<bool> *outputFlagCol,
743 : const casacore::Cube<casacore::Float> &inputWeightCube);
744 :
745 : template <class T> void copyCubeOfData( vi::VisBuffer2 *vb,
746 : casacore::RefRows &rowRef,
747 : const casacore::Cube<T> &inputDataCube,
748 : casacore::ArrayColumn<T> &outputDataCol,
749 : casacore::ArrayColumn<bool> *outputFlagCol,
750 : const casacore::Cube<casacore::Float> &inputWeightCube);
751 :
752 : template <class T> void combineCubeOfData( vi::VisBuffer2 *vb,
753 : casacore::RefRows &rowRef,
754 : const casacore::Cube<T> &inputDataCube,
755 : casacore::ArrayColumn<T> &outputDataCol,
756 : casacore::ArrayColumn<bool> *outputFlagCol,
757 : const casacore::Cube<casacore::Float> &inputWeightCube);
758 :
759 : // Methods to transform data in cubes
760 :
761 : void addWeightSpectrumContribution( casacore::Double &weight,
762 : casacore::uInt &pol,
763 : casacore::uInt &inputChannel,
764 : casacore::uInt &row,
765 : const casacore::Cube<casacore::Float> &inputWeightsCube);
766 : void dontAddWeightSpectrumContribution( casacore::Double &weight,
767 : casacore::uInt &pol,
768 : casacore::uInt &inputChannel,
769 : casacore::uInt &row,
770 : const casacore::Cube<casacore::Float> &inputWeightsCube);
771 : void (casa::MSTransformManager::*addWeightSpectrumContribution_p)( casacore::Double &weight,
772 : casacore::uInt &pol,
773 : casacore::uInt &inputChannel,
774 : casacore::uInt &row,
775 : const casacore::Cube<casacore::Float> &inputWeightsCube);
776 :
777 :
778 : void fillWeightsPlane( casacore::uInt pol,
779 : casacore::uInt inputChannel,
780 : casacore::uInt outputChannel,
781 : casacore::uInt inputRow,
782 : const casacore::Cube<casacore::Float> &inputWeightsCube,
783 : casacore::Matrix<casacore::Float> &inputWeightsPlane,
784 : casacore::Double weight);
785 132374071 : void dontfillWeightsPlane( casacore::uInt ,
786 : casacore::uInt ,
787 : casacore::uInt ,
788 : casacore::uInt ,
789 : const casacore::Cube<casacore::Float> &,
790 : casacore::Matrix<casacore::Float> &,
791 132374071 : casacore::Double ) {return;}
792 : void (casa::MSTransformManager::*fillWeightsPlane_p)( casacore::uInt pol,
793 : casacore::uInt inputChannel,
794 : casacore::uInt outputChannel,
795 : casacore::uInt inputRow,
796 : const casacore::Cube<casacore::Float> &inputWeightsCube,
797 : casacore::Matrix<casacore::Float> &inputWeightsPlane,
798 : casacore::Double weight);
799 :
800 : void normalizeWeightsPlane( casacore::uInt pol,
801 : casacore::uInt outputChannel,
802 : casacore::Matrix<casacore::Float> &inputPlaneWeights,
803 : casacore::Matrix<casacore::Double> &normalizingFactorPlane);
804 117737744 : void dontNormalizeWeightsPlane( casacore::uInt ,
805 : casacore::uInt ,
806 : casacore::Matrix<casacore::Float> &,
807 117737744 : casacore::Matrix<casacore::Double> &) {return;}
808 : void (casa::MSTransformManager::*normalizeWeightsPlane_p)( casacore::uInt pol,
809 : casacore::uInt outputChannel,
810 : casacore::Matrix<casacore::Float> &inputPlaneWeights,
811 : casacore::Matrix<casacore::Double> &normalizingFactorPlane);
812 :
813 : template <class T> void averageCubeOfData( vi::VisBuffer2 *vb,
814 : casacore::RefRows &rowRef,
815 : const casacore::Cube<T> &inputDataCube,
816 : casacore::ArrayColumn<T> &outputDataCol,
817 : casacore::ArrayColumn<bool> *outputFlagCol,
818 : const casacore::Cube<casacore::Float> &inputWeightCube);
819 : template <class T> void smoothCubeOfData( vi::VisBuffer2 *vb,
820 : casacore::RefRows &rowRef,
821 : const casacore::Cube<T> &inputDataCube,
822 : casacore::ArrayColumn<T> &outputDataCol,
823 : casacore::ArrayColumn<bool> *outputFlagCol,
824 : const casacore::Cube<casacore::Float> &inputWeightCube);
825 : template <class T> void regridCubeOfData( vi::VisBuffer2 *vb,
826 : casacore::RefRows &rowRef,
827 : const casacore::Cube<T> &inputDataCube,
828 : casacore::ArrayColumn<T> &outputDataCol,
829 : casacore::ArrayColumn<bool> *outputFlagCol,
830 : const casacore::Cube<casacore::Float> &inputWeightCube);
831 : template <class T> void separateCubeOfData( vi::VisBuffer2 *vb,
832 : casacore::RefRows &rowRef,
833 : const casacore::Cube<T> &inputDataCube,
834 : casacore::ArrayColumn<T> &outputDataCol,
835 : casacore::ArrayColumn<bool> *outputFlagCol,
836 : const casacore::Cube<casacore::Float> &inputWeightCube);
837 :
838 : template <class T> void transformAndWriteCubeOfData( casacore::Int inputSpw,
839 : casacore::RefRows &rowRef,
840 : const casacore::Cube<T> &inputDataCube,
841 : const casacore::Cube<bool> &inputFlagsCube,
842 : const casacore::Cube<casacore::Float> &inputWeightsCube,
843 : casacore::IPosition &outputPlaneShape,
844 : casacore::ArrayColumn<T> &outputDataCol,
845 : casacore::ArrayColumn<bool> *outputFlagCol);
846 :
847 :
848 : void setWeightsPlaneByReference( casacore::uInt inputRow,
849 : const casacore::Cube<casacore::Float> &inputWeightsCube,
850 : casacore::Matrix<casacore::Float> &inputWeightsPlane);
851 3823426 : void dontsetWeightsPlaneByReference( casacore::uInt ,
852 : const casacore::Cube<casacore::Float> &,
853 3823426 : casacore::Matrix<casacore::Float> &) {return;}
854 : void (casa::MSTransformManager::*setWeightsPlaneByReference_p)( casacore::uInt inputRow,
855 : const casacore::Cube<casacore::Float> &inputWeightsCube,
856 : casacore::Matrix<casacore::Float> &inputWeightsPlane);
857 :
858 : template <class T> void transformAndWritePlaneOfData( casacore::Int inputSpw,
859 : casacore::uInt row,
860 : casacore::Matrix<T> &inputDataPlane,
861 : casacore::Matrix<bool> &inputFlagsPlane,
862 : casacore::Matrix<casacore::Float> &inputWeightsPlane,
863 : casacore::Matrix<T> &outputDataPlane,
864 : casacore::Matrix<bool> &outputFlagsPlane,
865 : casacore::ArrayColumn<T> &outputDataCol,
866 : casacore::ArrayColumn<bool> *outputFlagCol);
867 : void setWeightStripeByReference( casacore::uInt corrIndex,
868 : casacore::Matrix<casacore::Float> &inputWeightsPlane,
869 : casacore::Vector<casacore::Float> &inputWeightsStripe);
870 12506522 : void dontSetWeightStripeByReference( casacore::uInt ,
871 : casacore::Matrix<casacore::Float> &,
872 12506522 : casacore::Vector<casacore::Float> &) {return;}
873 : void (casa::MSTransformManager::*setWeightStripeByReference_p)( casacore::uInt corrIndex,
874 : casacore::Matrix<casacore::Float> &inputWeightsPlane,
875 : casacore::Vector<casacore::Float> &inputWeightsStripe);
876 :
877 : void setOutputbuffer(casacore::Cube<casacore::Complex> *& dataBufferPointer,casacore::Cube<bool> *& flagBufferPointer);
878 : void setOutputbuffer(casacore::Cube<casacore::Float> *& dataBufferPointer,casacore::Cube<bool> *& flagBufferPointer);
879 :
880 : template <class T> void bufferOutputPlanes( casacore::uInt row,
881 : casacore::Matrix<T> &outputDataPlane,
882 : casacore::Matrix<bool> &outputFlagsPlane,
883 : casacore::ArrayColumn<T> &outputDataCol,
884 : casacore::ArrayColumn<bool> &outputFlagCol);
885 : template <class T> void bufferOutputPlanesInSlices( casacore::uInt row,
886 : casacore::Matrix<T> &outputDataPlane,
887 : casacore::Matrix<bool> &outputFlagsPlane,
888 : casacore::ArrayColumn<T> &outputDataCol,
889 : casacore::ArrayColumn<bool> &outputFlagCol);
890 :
891 : void writeOutputPlanes( casacore::uInt row,
892 : casacore::Matrix<casacore::Complex> &outputDataPlane,
893 : casacore::Matrix<bool> &outputFlagsPlane,
894 : casacore::ArrayColumn<casacore::Complex> &outputDataCol,
895 : casacore::ArrayColumn<bool> &outputFlagCol);
896 : void writeOutputPlanes( casacore::uInt row,
897 : casacore::Matrix<casacore::Float> &outputDataPlane,
898 : casacore::Matrix<bool> &outputFlagsPlane,
899 : casacore::ArrayColumn<casacore::Float> &outputDataCol,
900 : casacore::ArrayColumn<bool> &outputFlagCol);
901 : void (casa::MSTransformManager::*writeOutputPlanesComplex_p)( casacore::uInt row,
902 : casacore::Matrix<casacore::Complex> &outputDataPlane,
903 : casacore::Matrix<bool> &outputFlagsPlane,
904 : casacore::ArrayColumn<casacore::Complex> &outputDataCol,
905 : casacore::ArrayColumn<bool> &outputFlagCol);
906 : void (casa::MSTransformManager::*writeOutputPlanesFloat_p)( casacore::uInt row,
907 : casacore::Matrix<casacore::Float> &outputDataPlane,
908 : casacore::Matrix<bool> &outputFlagsPlane,
909 : casacore::ArrayColumn<casacore::Float> &outputDataCol,
910 : casacore::ArrayColumn<bool> &outputFlagCol);
911 :
912 : template <class T> void writeOutputPlanesInBlock( casacore::uInt row,
913 : casacore::Matrix<T> &outputDataPlane,
914 : casacore::Matrix<bool> &outputFlagsPlane,
915 : casacore::ArrayColumn<T> &outputDataCol,
916 : casacore::ArrayColumn<bool> &outputFlagCol);
917 : void (casa::MSTransformManager::*writeOutputFlagsPlane_p)( casacore::Matrix<bool> &outputPlane,
918 : casacore::ArrayColumn<bool> &outputCol,
919 : casacore::IPosition &outputPlaneShape,
920 : casacore::uInt &outputRow);
921 : void writeOutputFlagsPlane( casacore::Matrix<bool> &outputPlane,
922 : casacore::ArrayColumn<bool> &outputCol,
923 : casacore::IPosition &outputPlaneShape,
924 : casacore::uInt &outputRow);
925 361649 : void dontWriteOutputFlagsPlane( casacore::Matrix<bool> &,
926 : casacore::ArrayColumn<bool> &,
927 : casacore::IPosition &,
928 361649 : casacore::uInt &) {return;}
929 :
930 : template <class T> void writeOutputPlanesInSlices( casacore::uInt row,
931 : casacore::Matrix<T> &outputDataPlane,
932 : casacore::Matrix<bool> &outputFlagsPlane,
933 : casacore::ArrayColumn<T> &outputDataCol,
934 : casacore::ArrayColumn<bool> &outputFlagCol);
935 : template <class T> void writeOutputPlaneSlices( casacore::Matrix<T> &outputPlane,
936 : casacore::ArrayColumn<T> &outputDataCol,
937 : casacore::Slice &sliceX,
938 : casacore::Slice &sliceY,
939 : casacore::IPosition &outputPlaneShape,
940 : casacore::uInt &outputRow);
941 : template <class T> void writeOutputPlaneReshapedSlices( casacore::Matrix<T> &outputPlane,
942 : casacore::ArrayColumn<T> &outputDataCol,
943 : casacore::Slice &sliceX,
944 : casacore::Slice &sliceY,
945 : casacore::IPosition &outputPlaneShape,
946 : casacore::uInt &outputRow);
947 : void (casa::MSTransformManager::*writeOutputFlagsPlaneSlices_p)( casacore::Matrix<bool> &outputPlane,
948 : casacore::ArrayColumn<bool> &outputCol,
949 : casacore::Slice &sliceX,
950 : casacore::Slice &sliceY,
951 : casacore::IPosition &outputPlaneShape,
952 : casacore::uInt &outputRow);
953 : void writeOutputFlagsPlaneSlices( casacore::Matrix<bool> &outputPlane,
954 : casacore::ArrayColumn<bool> &outputCol,
955 : casacore::Slice &sliceX,
956 : casacore::Slice &sliceY,
957 : casacore::IPosition &outputPlaneShape,
958 : casacore::uInt &outputRow);
959 6444 : void dontWriteOutputFlagsPlaneSlices( casacore::Matrix<bool> &,
960 : casacore::ArrayColumn<bool> &,
961 : casacore::Slice &,
962 : casacore::Slice &,
963 : casacore::IPosition &,
964 6444 : casacore::uInt &) {return;}
965 : void (casa::MSTransformManager::*writeOutputFlagsPlaneReshapedSlices_p)( casacore::Matrix<bool> &outputPlane,
966 : casacore::ArrayColumn<bool> &outputCol,
967 : casacore::Slice &sliceX,
968 : casacore::Slice &sliceY,
969 : casacore::IPosition &outputPlaneShape,
970 : casacore::uInt &outputRow);
971 : void writeOutputFlagsPlaneReshapedSlices( casacore::Matrix<bool> &outputPlane,
972 : casacore::ArrayColumn<bool> &outputCol,
973 : casacore::Slice &sliceX,
974 : casacore::Slice &sliceY,
975 : casacore::IPosition &outputPlaneShape,
976 : casacore::uInt &outputRow);
977 2148 : void dontWriteOutputPlaneReshapedSlices( casacore::Matrix<bool> &,
978 : casacore::ArrayColumn<bool> &,
979 : casacore::Slice &,
980 : casacore::Slice &,
981 : casacore::IPosition &,
982 2148 : casacore::uInt &) {return;}
983 :
984 : void transformStripeOfData(casacore::Int inputSpw,
985 : const casacore::Vector<casacore::Complex> &inputDataStripe,
986 : const casacore::Vector<bool> &inputFlagsStripe,
987 : const casacore::Vector<casacore::Float> &inputWeightsStripe,
988 : casacore::Vector<casacore::Complex> &outputDataStripe,
989 : casacore::Vector<bool> &outputFlagsStripe);
990 :
991 : void transformStripeOfData(casacore::Int inputSpw,
992 : const casacore::Vector<casacore::Float> &inputDataStripe,
993 : const casacore::Vector<bool> &inputFlagsStripe,
994 : const casacore::Vector<casacore::Float> &inputWeightsStripe,
995 : casacore::Vector<casacore::Float> &outputDataStripe,
996 : casacore::Vector<bool> &outputFlagsStripe);
997 :
998 : void (casa::MSTransformManager::*transformStripeOfDataComplex_p)(casacore::Int inputSpw,
999 : const casacore::Vector<casacore::Complex> &inputDataStripe,
1000 : const casacore::Vector<bool> &inputFlagsStripe,
1001 : const casacore::Vector<casacore::Float> &inputWeightsStripe,
1002 : casacore::Vector<casacore::Complex> &outputDataStripe,
1003 : casacore::Vector<bool> &outputFlagsStripe);
1004 :
1005 : void (casa::MSTransformManager::*transformStripeOfDataFloat_p)(casacore::Int inputSpw,
1006 : const casacore::Vector<casacore::Float> &inputDataStripe,
1007 : const casacore::Vector<bool> &inputFlagsStripe,
1008 : const casacore::Vector<casacore::Float> &inputWeightsStripe,
1009 : casacore::Vector<casacore::Float> &outputDataStripe,
1010 : casacore::Vector<bool> &outputFlagsStripe);
1011 :
1012 : template <class T> void average(casacore::Int inputSpw,
1013 : const casacore::Vector<T> &inputDataStripe,
1014 : const casacore::Vector<bool> &inputFlagsStripe,
1015 : const casacore::Vector<casacore::Float> &inputWeightsStripe,
1016 : casacore::Vector<T> &outputDataStripe,
1017 : casacore::Vector<bool> &outputFlagsStripe);
1018 :
1019 : template <class T> void simpleAverage(casacore::uInt width,
1020 : const casacore::Vector<T> &inputData,
1021 : casacore::Vector<T> &outputData);
1022 :
1023 : void averageKernel(const casacore::Vector<casacore::Complex> &inputData,
1024 : const casacore::Vector<bool> &inputFlags,
1025 : const casacore::Vector<casacore::Float> &inputWeights,
1026 : casacore::Vector<casacore::Complex> &outputData,
1027 : casacore::Vector<bool> &outputFlags,
1028 : casacore::uInt startInputPos,
1029 : casacore::uInt outputPos,
1030 : casacore::uInt width);
1031 :
1032 : void averageKernel(const casacore::Vector<casacore::Float> &inputData,
1033 : const casacore::Vector<bool> &inputFlags,
1034 : const casacore::Vector<casacore::Float> &inputWeights,
1035 : casacore::Vector<casacore::Float> &outputData,
1036 : casacore::Vector<bool> &outputFlags,
1037 : casacore::uInt startInputPos,
1038 : casacore::uInt outputPos,
1039 : casacore::uInt width);
1040 :
1041 : void (casa::MSTransformManager::*averageKernelComplex_p)(const casacore::Vector<casacore::Complex> &inputData,
1042 : const casacore::Vector<bool> &inputFlags,
1043 : const casacore::Vector<casacore::Float> &inputWeights,
1044 : casacore::Vector<casacore::Complex> &outputData,
1045 : casacore::Vector<bool> &outputFlags,
1046 : casacore::uInt startInputPos,
1047 : casacore::uInt outputPos,
1048 : casacore::uInt width);
1049 : void (casa::MSTransformManager::*averageKernelFloat_p)(const casacore::Vector<casacore::Float> &inputData,
1050 : const casacore::Vector<bool> &inputFlags,
1051 : const casacore::Vector<casacore::Float> &inputWeights,
1052 : casacore::Vector<casacore::Float> &outputData,
1053 : casacore::Vector<bool> &outputFlags,
1054 : casacore::uInt startInputPos,
1055 : casacore::uInt outputPos,
1056 : casacore::uInt width);
1057 : template <class T> void simpleAverageKernel(const casacore::Vector<T> &inputData,
1058 : const casacore::Vector<bool> &,
1059 : const casacore::Vector<casacore::Float> &,
1060 : casacore::Vector<T> &outputData,
1061 : casacore::Vector<bool> &,
1062 : casacore::uInt startInputPos,
1063 : casacore::uInt outputPos,
1064 : casacore::uInt width);
1065 :
1066 : template <class T> void flagAverageKernel(const casacore::Vector<T> &inputData,
1067 : const casacore::Vector<bool> &inputFlags,
1068 : const casacore::Vector<casacore::Float> &,
1069 : casacore::Vector<T> &outputData,
1070 : casacore::Vector<bool> &outputFlags,
1071 : casacore::uInt startInputPos,
1072 : casacore::uInt outputPos,
1073 : casacore::uInt width);
1074 :
1075 : template <class T> void weightAverageKernel(const casacore::Vector<T> &inputData,
1076 : const casacore::Vector<bool> &,
1077 : const casacore::Vector<casacore::Float> &inputWeights,
1078 : casacore::Vector<T> &outputData,
1079 : casacore::Vector<bool> &outputFlags,
1080 : casacore::uInt startInputPos,
1081 : casacore::uInt outputPos,
1082 : casacore::uInt width);
1083 :
1084 : template <class T> void cumSumKernel(const casacore::Vector<T> &inputData,
1085 : const casacore::Vector<bool> &,
1086 : const casacore::Vector<casacore::Float> &,
1087 : casacore::Vector<T> &outputData,
1088 : casacore::Vector<bool> &,
1089 : casacore::uInt startInputPos,
1090 : casacore::uInt outputPos,
1091 : casacore::uInt width);
1092 :
1093 : template <class T> void flagWeightAverageKernel(const casacore::Vector<T> &inputData,
1094 : const casacore::Vector<bool> &inputFlags,
1095 : const casacore::Vector<casacore::Float> &inputWeights,
1096 : casacore::Vector<T> &outputData,
1097 : casacore::Vector<bool> &outputFlags,
1098 : casacore::uInt startInputPos,
1099 : casacore::uInt outputPos,
1100 : casacore::uInt width);
1101 :
1102 : template <class T> void flagCumSumKernel(const casacore::Vector<T> &inputData,
1103 : const casacore::Vector<bool> &inputFlags,
1104 : const casacore::Vector<casacore::Float> &,
1105 : casacore::Vector<T> &outputData,
1106 : casacore::Vector<bool> &,
1107 : casacore::uInt startInputPos,
1108 : casacore::uInt outputPos,
1109 : casacore::uInt width);
1110 :
1111 : template <class T> void flagNonZeroAverageKernel(const casacore::Vector<T> &inputData,
1112 : const casacore::Vector<bool> &inputFlags,
1113 : const casacore::Vector<casacore::Float> &,
1114 : casacore::Vector<T> &outputData,
1115 : casacore::Vector<bool> &,
1116 : casacore::uInt startInputPos,
1117 : casacore::uInt outputPos,
1118 : casacore::uInt width);
1119 :
1120 : template <class T> void flagWeightNonZeroAverageKernel(const casacore::Vector<T> &inputData,
1121 : const casacore::Vector<bool> &inputFlags,
1122 : const casacore::Vector<casacore::Float> &,
1123 : casacore::Vector<T> &outputData,
1124 : casacore::Vector<bool> &,
1125 : casacore::uInt startInputPos,
1126 : casacore::uInt outputPos,
1127 : casacore::uInt width);
1128 :
1129 : template <class T> void flagCumSumNonZeroKernel(const casacore::Vector<T> &inputData,
1130 : const casacore::Vector<bool> &inputFlags,
1131 : const casacore::Vector<casacore::Float> &,
1132 : casacore::Vector<T> &outputData,
1133 : casacore::Vector<bool> &,
1134 : casacore::uInt startInputPos,
1135 : casacore::uInt outputPos,
1136 : casacore::uInt width);
1137 :
1138 :
1139 : template <class T> void smooth(casacore::Int inputSpw,
1140 : const casacore::Vector<T> &inputDataStripe,
1141 : const casacore::Vector<bool> &inputFlagsStripe,
1142 : const casacore::Vector<casacore::Float> &inputWeightsStripe,
1143 : casacore::Vector<T> &outputDataStripe,
1144 : casacore::Vector<bool> &outputFlagsStripe);
1145 :
1146 : void smoothKernel(const casacore::Vector<casacore::Complex> &inputData,
1147 : const casacore::Vector<bool> &inputFlags,
1148 : const casacore::Vector<casacore::Float> &inputWeights,
1149 : casacore::Vector<casacore::Complex> &outputData,
1150 : casacore::Vector<bool> &outputFlags,
1151 : casacore::uInt outputPos);
1152 :
1153 : void smoothKernel(const casacore::Vector<casacore::Float> &inputData,
1154 : const casacore::Vector<bool> &inputFlags,
1155 : const casacore::Vector<casacore::Float> &inputWeights,
1156 : casacore::Vector<casacore::Float> &outputData,
1157 : casacore::Vector<bool> &outputFlags,
1158 : casacore::uInt outputPos);
1159 :
1160 : void (casa::MSTransformManager::*smoothKernelComplex_p)(const casacore::Vector<casacore::Complex> &inputData,
1161 : const casacore::Vector<bool> &inputFlags,
1162 : const casacore::Vector<casacore::Float> &inputWeights,
1163 : casacore::Vector<casacore::Complex> &outputData,
1164 : casacore::Vector<bool> &outputFlags,
1165 : casacore::uInt outputPos);
1166 :
1167 : void (casa::MSTransformManager::*smoothKernelFloat_p)(const casacore::Vector<casacore::Float> &inputData,
1168 : const casacore::Vector<bool> &inputFlags,
1169 : const casacore::Vector<casacore::Float> &inputWeights,
1170 : casacore::Vector<casacore::Float> &outputData,
1171 : casacore::Vector<bool> &outputFlags,
1172 : casacore::uInt outputPos);
1173 :
1174 : template <class T> void plainSmooth(const casacore::Vector<T> &inputData,
1175 : const casacore::Vector<bool> &inputFlags,
1176 : const casacore::Vector<casacore::Float> &inputWeights,
1177 : casacore::Vector<T> &outputData,
1178 : casacore::Vector<bool> &outputFlags,
1179 : casacore::uInt outputPos);
1180 :
1181 : template <class T> void plainSmoothSpectrum(const casacore::Vector<T> &inputData,
1182 : const casacore::Vector<bool> &inputFlags,
1183 : const casacore::Vector<casacore::Float> &inputWeights,
1184 : casacore::Vector<T> &outputData,
1185 : casacore::Vector<bool> &outputFlags,
1186 : casacore::uInt outputPos);
1187 :
1188 :
1189 : template <class T> void regrid(casacore::Int ,
1190 : const casacore::Vector<T> &inputDataStripe,
1191 : const casacore::Vector<bool> &inputFlagsStripe,
1192 : const casacore::Vector<casacore::Float> &,
1193 : casacore::Vector<T> &outputDataStripe,
1194 : casacore::Vector<bool> &outputFlagsStripe);
1195 :
1196 : void regridCore(casacore::Int inputSpw,
1197 : const casacore::Vector<casacore::Complex> &inputDataStripe,
1198 : const casacore::Vector<bool> &inputFlagsStripe,
1199 : const casacore::Vector<casacore::Float> &inputWeightsStripe,
1200 : casacore::Vector<casacore::Complex> &outputDataStripe,
1201 : casacore::Vector<bool> &outputFlagsStripe);
1202 : void regridCore(casacore::Int inputSpw,
1203 : const casacore::Vector<casacore::Float> &inputDataStripe,
1204 : const casacore::Vector<bool> &inputFlagsStripe,
1205 : const casacore::Vector<casacore::Float> &inputWeightsStripe,
1206 : casacore::Vector<casacore::Float> &outputDataStripe,
1207 : casacore::Vector<bool> &outputFlagsStripe);
1208 :
1209 : void (casa::MSTransformManager::*regridCoreComplex_p)(casacore::Int inputSpw,
1210 : const casacore::Vector<casacore::Complex> &inputDataStripe,
1211 : const casacore::Vector<bool> &inputFlagsStripe,
1212 : const casacore::Vector<casacore::Float> &inputWeightsStripe,
1213 : casacore::Vector<casacore::Complex> &outputDataStripe,
1214 : casacore::Vector<bool> &outputFlagsStripe);
1215 :
1216 : void (casa::MSTransformManager::*regridCoreFloat_p)(casacore::Int inputSpw,
1217 : const casacore::Vector<casacore::Float> &inputDataStripe,
1218 : const casacore::Vector<bool> &inputFlagsStripe,
1219 : const casacore::Vector<casacore::Float> &inputWeightsStripe,
1220 : casacore::Vector<casacore::Float> &outputDataStripe,
1221 : casacore::Vector<bool> &outputFlagsStripe);
1222 :
1223 : void fftshift(casacore::Int inputSpw,
1224 : const casacore::Vector<casacore::Complex> &inputDataStripe,
1225 : const casacore::Vector<bool> &inputFlagsStripe,
1226 : const casacore::Vector<casacore::Float> &inputWeightsStripe,
1227 : casacore::Vector<casacore::Complex> &outputDataStripe,
1228 : casacore::Vector<bool> &outputFlagsStripe);
1229 : void fftshift(casacore::Int inputSpw,
1230 : const casacore::Vector<casacore::Float> &inputDataStripe,
1231 : const casacore::Vector<bool> &inputFlagsStripe,
1232 : const casacore::Vector<casacore::Float> &inputWeightsStripe,
1233 : casacore::Vector<casacore::Float> &outputDataStripe,
1234 : casacore::Vector<bool> &outputFlagsStripe);
1235 :
1236 : template <class T> void interpol1D(casacore::Int inputSpw,
1237 : const casacore::Vector<T> &inputDataStripe,
1238 : const casacore::Vector<bool> &inputFlagsStripe,
1239 : const casacore::Vector<casacore::Float> &,
1240 : casacore::Vector<T> &outputDataStripe,
1241 : casacore::Vector<bool> &outputFlagsStripe);
1242 :
1243 : template <class T> void interpol1Dfftshift(casacore::Int inputSpw,
1244 : const casacore::Vector<T> &inputDataStripe,
1245 : const casacore::Vector<bool> &inputFlagsStripe,
1246 : const casacore::Vector<casacore::Float> &inputWeightsStripe,
1247 : casacore::Vector<T> &outputDataStripe,
1248 : casacore::Vector<bool> &outputFlagsStripe);
1249 :
1250 : template <class T> void interpolateByChannelMap(Int spw,
1251 : const Vector<T> &inputDataStripe,
1252 : const Vector<Bool> &inputFlagsStripe,
1253 : Vector<T> &outputDataStripe,
1254 : Vector<Bool> &outputFlagsStripe);
1255 :
1256 : template <class T> void averageRegrid(casacore::Int inputSpw,
1257 : const casacore::Vector<T> &inputDataStripe,
1258 : const casacore::Vector<bool> &inputFlagsStripe,
1259 : const casacore::Vector<casacore::Float> &inputWeightsStripe,
1260 : casacore::Vector<T> &outputDataStripe,
1261 : casacore::Vector<bool> &outputFlagsStripe);
1262 :
1263 : template <class T> void smoothRegrid(casacore::Int inputSpw,
1264 : const casacore::Vector<T> &inputDataStripe,
1265 : const casacore::Vector<bool> &inputFlagsStripe,
1266 : const casacore::Vector<casacore::Float> &inputWeightsStripe,
1267 : casacore::Vector<T> &outputDataStripe,
1268 : casacore::Vector<bool> &outputFlagsStripe);
1269 :
1270 : template <class T> void averageSmooth(casacore::Int inputSpw,
1271 : const casacore::Vector<T> &inputDataStripe,
1272 : const casacore::Vector<bool> &inputFlagsStripe,
1273 : const casacore::Vector<casacore::Float> &inputWeightsStripe,
1274 : casacore::Vector<T> &outputDataStripe,
1275 : casacore::Vector<bool> &outputFlagsStripe);
1276 :
1277 : template <class T> void averageSmoothRegrid(casacore::Int inputSpw,
1278 : const casacore::Vector<T> &inputDataStripe,
1279 : const casacore::Vector<bool> &inputFlagsStripe,
1280 : const casacore::Vector<casacore::Float> &inputWeightsStripe,
1281 : casacore::Vector<T> &outputDataStripe,
1282 : casacore::Vector<bool> &outputFlagsStripe);
1283 :
1284 : // The following methods are single dish specific so far
1285 : void smoothFourierFloat(casacore::Int , const casacore::Vector<casacore::Float> &inputDataStripe,
1286 : const casacore::Vector<bool> &inputFlagsStripe,
1287 : const casacore::Vector<casacore::Float> &inputWeightStripe,
1288 : casacore::Vector<casacore::Float> &outputDataStripe,
1289 : casacore::Vector<bool> &outputFlagsStripe);
1290 :
1291 : void smoothFourierComplex(casacore::Int , const casacore::Vector<casacore::Complex> &inputDataStripe,
1292 : const casacore::Vector<bool> &inputFlagsStripe,
1293 : const casacore::Vector<casacore::Float> &inputWeightStripe,
1294 : casacore::Vector<casacore::Complex> &outputDataStripe,
1295 : casacore::Vector<bool> &outputFlagsStripe);
1296 :
1297 : casacore::Convolver<casacore::Float> *getConvolver(casacore::Int const numChan);
1298 :
1299 : // casacore::MS specification parameters
1300 : casacore::String inpMsName_p;
1301 : casacore::String outMsName_p;
1302 : casacore::String datacolumn_p;
1303 : bool makeVirtualModelColReal_p;
1304 : bool makeVirtualCorrectedColReal_p;
1305 : casacore::Vector<casacore::Int> tileShape_p;
1306 :
1307 : // casacore::Data selection parameters
1308 : casacore::String arraySelection_p;
1309 : casacore::String fieldSelection_p;
1310 : casacore::String scanSelection_p;
1311 : casacore::String timeSelection_p;
1312 : casacore::String spwSelection_p;
1313 : casacore::String baselineSelection_p;
1314 : casacore::String uvwSelection_p;
1315 : casacore::String polarizationSelection_p;
1316 : casacore::String scanIntentSelection_p;
1317 : casacore::String observationSelection_p;
1318 : casacore::String taqlSelection_p;
1319 : casacore::String feedSelection_p;
1320 :
1321 : // casacore::Input-Output index maps
1322 : map<casacore::uInt,casacore::uInt> inputOutputObservationIndexMap_p;
1323 : map<casacore::uInt,casacore::uInt> inputOutputArrayIndexMap_p;
1324 : map<casacore::uInt,casacore::uInt> inputOutputScanIndexMap_p;
1325 : map<casacore::uInt,casacore::uInt> inputOutputScanIntentIndexMap_p;
1326 : map<casacore::uInt,casacore::uInt> inputOutputFieldIndexMap_p;
1327 : map<casacore::uInt,casacore::uInt> inputOutputSPWIndexMap_p;
1328 : map<casacore::uInt,casacore::uInt> inputOutputDDIndexMap_p;
1329 : map<casacore::uInt,casacore::uInt> inputOutputAntennaIndexMap_p;
1330 : map<casacore::uInt,casacore::uInt> outputInputSPWIndexMap_p;
1331 : map<casacore::Int,std::vector<casacore::Int> > inputOutputChanIndexMap_p;
1332 :
1333 : // Frequency transformation parameters
1334 : casacore::uInt nspws_p = 1;
1335 : casacore::Int ddiStart_p = 0;
1336 : bool combinespws_p = false;
1337 : bool enableChanPreAverage_p = false;
1338 : bool channelAverage_p = false;
1339 : bool hanningSmooth_p = false;
1340 : bool refFrameTransformation_p = false;
1341 : casacore::Vector<casacore::Int> freqbin_p = casacore::Vector<Int>(1,-1);
1342 : // For when the interpolation needs to be done the tclean way
1343 : // (output width > 2 input width). CAS-9853, CAS-9852
1344 : bool regridTClean_p = false;
1345 : Vector<Double> regridTCleanCHAN_FREQ_p;
1346 : Vector<Int> regridTCleanChanMap_p;
1347 : casacore::String useweights_p = "flags";
1348 : casacore::uInt weightmode_p = MSTransformations::flags;
1349 : // Options are: nearest, linear, cubic, spline, fftshift
1350 : casacore::String interpolationMethodPar_p = casacore::String("linear");
1351 : casac::variant *phaseCenterPar_p = new casac::variant("");
1352 : casacore::String restFrequency_p = casacore::String("");
1353 : // Options are: LSRK, LSRD, BARY, GALACTO, LGROUP, CMB, GEO, or TOPO
1354 : casacore::String outputReferenceFramePar_p = String("");
1355 : bool radialVelocityCorrection_p = false;
1356 : bool regridding_p = false ;
1357 : casacore::uInt smoothBin_p = 3;
1358 : casacore::uInt smoothmode_p = MSTransformations::plainSmooth;
1359 : casacore::Vector<casacore::Float> smoothCoeff_p;
1360 :
1361 : // Frequency specification parameters
1362 : casacore::String mode_p;
1363 : casacore::String start_p;
1364 : casacore::String width_p;
1365 : int nChan_p;
1366 : casacore::String velocityType_p;
1367 :
1368 : // Phase shifting parameters
1369 : // CAS-12706 To run phase shift via a TVI which has
1370 : // support for shifting across large offset/angles
1371 : casacore::Double dx_p, dy_p;
1372 : bool tviphaseshift_p;
1373 : casacore::Record tviphaseshiftConfig_p;
1374 :
1375 : // For scalar averaging, use "timebin" for iter interval but don't average
1376 : bool scalarAverage_p;
1377 :
1378 : // casacore::Time transformation parameters
1379 : bool timeAverage_p;
1380 : casacore::Double timeBin_p;
1381 : casacore::String timespan_p;
1382 : vi::AveragingOptions timeAvgOptions_p;
1383 : casacore::Double maxuvwdistance_p;
1384 : // casacore::uInt minbaselines_p;
1385 :
1386 : // Calibration parameters
1387 : bool calibrate_p;
1388 : casacore::String callib_p;
1389 : casacore::Record callibRec_p;
1390 :
1391 : // UVContSub parameters
1392 : bool uvcontsub_p;
1393 : casacore::Record uvcontsubRec_p;
1394 : // To produce a MODEL column in output MS, not coming from the input MS MODEL
1395 : // This is used by uvcontsub which from input DATA (or CORRECTED) can produde both
1396 : // DATA and MODEL
1397 : bool produceModel_p = false;
1398 :
1399 : // Spw averaging parameters
1400 : bool spwAverage_p;
1401 :
1402 : // Polarization transformation parameters
1403 : bool polAverage_p;
1404 : casacore::Record polAverageConfig_p;
1405 :
1406 : // Pointings interpolation transformation parameters
1407 : bool pointingsInterpolation_p;
1408 : casacore::Record pointingsInterpolationConfig_p;
1409 :
1410 : // Weight Spectrum parameters
1411 : bool usewtspectrum_p;
1412 :
1413 : // Buffer handling parameters
1414 : bool bufferMode_p;
1415 : bool userBufferMode_p;
1416 : bool reindex_p;
1417 : bool factory_p;
1418 : bool interactive_p;
1419 :
1420 : // casacore::MS-related members
1421 : MSTransformDataHandler *dataHandler_p;
1422 : casacore::MeasurementSet *inputMs_p;
1423 : casacore::MeasurementSet *selectedInputMs_p;
1424 : casacore::MeasurementSet *outputMs_p;
1425 : casacore::MSColumns *selectedInputMsCols_p;
1426 : casacore::MSColumns *outputMsCols_p;
1427 : std::shared_ptr<casacore::MSFieldColumns> inputMSFieldCols_p;
1428 :
1429 : // VI/VB related members
1430 : casacore::Block<casacore::Int> sortColumns_p;
1431 : vi::VisibilityIterator2 *visibilityIterator_p;
1432 : vi::FrequencySelectionUsingChannels *channelSelector_p;
1433 :
1434 : // Output casacore::MS structure related members
1435 : bool inputFlagCategoryAvailable_p;
1436 : bool correctedToData_p;
1437 : bool bothDataColumnsAreOutput_p;
1438 : bool doingData_p;
1439 : bool doingCorrected_p;
1440 : bool doingModel_p;
1441 : dataColMap dataColMap_p;
1442 : casacore::MSMainEnums::PredefinedColumns mainColumn_p;
1443 : casacore::uInt nRowsToAdd_p;
1444 :
1445 : // Frequency transformation members
1446 : casacore::uInt chansPerOutputSpw_p;
1447 : casacore::uInt tailOfChansforLastSpw_p;
1448 : casacore::uInt interpolationMethod_p;
1449 : baselineMap baselineMap_p;
1450 : std::vector<casacore::uInt> rowIndex_p;
1451 : inputSpwChanMap spwChannelMap_p;
1452 : inputOutputSpwMap inputOutputSpwMap_p;
1453 : inputOutputChanFactorMap inputOutputChanFactorMap_p;
1454 : map<casacore::uInt,casacore::uInt> freqbinMap_p;
1455 : map<casacore::uInt,casacore::uInt> numOfInpChanMap_p;
1456 : map<casacore::uInt,casacore::uInt> numOfSelChanMap_p;
1457 : map<casacore::uInt,casacore::uInt> numOfOutChanMap_p;
1458 : map<casacore::uInt,casacore::uInt> numOfCombInputChanMap_p;
1459 : map<casacore::uInt,casacore::uInt> numOfCombInterChanMap_p;
1460 : map<casacore::uInt,casacore::Float> weightFactorMap_p;
1461 : map<casacore::uInt,casacore::Float> sigmaFactorMap_p;
1462 : map<casacore::uInt,casacore::Float> newWeightFactorMap_p;
1463 : map<casacore::uInt,casacore::Float> newSigmaFactorMap_p;
1464 :
1465 : // Reference Frame Transformation members
1466 : casacore::MFrequency::Types inputReferenceFrame_p;
1467 : casacore::MFrequency::Types outputReferenceFrame_p;
1468 : casacore::MPosition observatoryPosition_p;
1469 : casacore::MEpoch referenceTime_p;
1470 : casacore::MDirection phaseCenter_p;
1471 : casacore::MRadialVelocity radialVelocity_p;
1472 : casacore::MFrequency::Convert freqTransEngine_p;
1473 : casacore::MFrequency::Convert refTimeFreqTransEngine_p;
1474 : casacore::FFTServer<casacore::Float, casacore::Complex> fFFTServer_p;
1475 : bool fftShiftEnabled_p;
1476 : casacore::Double fftShift_p;
1477 : casacore::ROScalarMeasColumn<casacore::MEpoch> timeMeas_p;
1478 :
1479 : // Weight Spectrum members
1480 : bool spectrumTransformation_p;
1481 : bool propagateWeights_p;
1482 : bool inputWeightSpectrumAvailable_p;
1483 : bool createWeightSpectrumCols_p;
1484 : // whether to create and fill the WEIGHT/SIMA_SPECTRUM columns in the output MS
1485 : bool flushWeightSpectrum_p;
1486 : bool weightSpectrumFlatFilled_p;
1487 : bool weightSpectrumFromSigmaFilled_p;
1488 : bool combinationOfSPWsWithDifferentExposure_p;
1489 : casacore::Cube<casacore::Float> weightSpectrumCube_p;
1490 : casacore::Cube<casacore::Float> weightSpectrumCubeFlat_p;
1491 : casacore::Cube<casacore::Float> weightSpectrumCubeDummy_p;
1492 :
1493 : // Buffer handling members
1494 : casacore::uInt dataBuffer_p;
1495 : casacore::uInt relativeRow_p;
1496 : bool spectrumReshape_p;
1497 : bool cubeTransformation_p;
1498 : bool dataColumnAvailable_p;
1499 : bool correctedDataColumnAvailable_p;
1500 : bool modelDataColumnAvailable_p;
1501 : bool floatDataColumnAvailable_p;
1502 : bool lagDataColumnAvailable_p;
1503 : casacore::Cube<bool> *flagCube_p;
1504 : casacore::Cube<casacore::Complex> *visCube_p;
1505 : casacore::Cube<casacore::Complex> *visCubeCorrected_p;
1506 : casacore::Cube<casacore::Complex> *visCubeModel_p;
1507 : casacore::Cube<casacore::Float> *visCubeFloat_p;
1508 : casacore::Cube<casacore::Float> *weightSpectrum_p;
1509 : casacore::Cube<casacore::Float> *sigmaSpectrum_p;
1510 : casacore::Matrix<casacore::Float> *weight_p;
1511 : casacore::Matrix<casacore::Float> *sigma_p;
1512 : casacore::ArrayColumn<casacore::Float> dummyWeightCol_p;
1513 :
1514 : // single dish specific
1515 : bool smoothFourier_p;
1516 : map<casacore::Int, casacore::Convolver<casacore::Float> > convolverPool_;
1517 : bool doAtmCor_p;
1518 : casacore::Record atmCorConfig_p;
1519 :
1520 : // Logging
1521 : casacore::LogIO logger_p;
1522 :
1523 : private:
1524 : bool shouldCreateOutputWtSpectrum(bool usewtspectrum);
1525 : void createOutputMSStructure();
1526 :
1527 : };
1528 :
1529 : } //# NAMESPACE CASA - END
1530 :
1531 : #endif /* MSTransformManager_H_ */
|
