00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #ifndef MSTransformManager_H_
00024 #define MSTransformManager_H_
00025
00026
00027 #include <casacore/casa/Containers/Record.h>
00028
00029
00030 #include <stdcasa/StdCasa/CasacSupport.h>
00031
00032
00033 #include <ms/MSSel/MSSelection.h>
00034
00035
00036 #include <mstransform/MSTransform/MSTransformDataHandler.h>
00037
00038
00039 #include <mstransform/MSTransform/MSTransformRegridder.h>
00040
00041
00042 #include <msvis/MSVis/VisibilityIterator2.h>
00043 #include <msvis/MSVis/VisBuffer2.h>
00044 #include <msvis/MSVis/ViFrequencySelection.h>
00045
00046
00047 #include <msvis/MSVis/ViiLayerFactory.h>
00048 #include <msvis/MSVis/IteratingParameters.h>
00049 #include <msvis/MSVis/AveragingVi2Factory.h>
00050 #include <msvis/MSVis/LayeredVi2Factory.h>
00051 #include <mstransform/TVI/UVContSubTVI.h>
00052
00053
00054 #include <msvis/MSVis/AveragingTvi2.h>
00055
00056
00057 #include <measures/Measures/MeasTable.h>
00058
00059
00060 #include <iomanip>
00061
00062
00063 #include <scimath/Mathematics/Smooth.h>
00064
00065
00066 #include <scimath/Mathematics/FFTServer.h>
00067
00068
00069 #include <scimath/Mathematics/InterpolateArray1D.h>
00070
00071
00072 #include <casa/Arrays/ArrayPartMath.h>
00073
00074
00075 #include <map>
00076 #include <scimath/Mathematics/Convolver.h>
00077 #include <cmath>
00078
00079 namespace casa {
00080
00081
00082 class MSTransformBufferImpl;
00083 class MSTransformIterator;
00084 class MSTransformIteratorFactory;
00085
00086
00087 namespace MSTransformations
00088 {
00089
00090 Double wtToSigma(Double wt);
00091 Double sigmaToWeight(Double wt);
00092
00093 enum InterpolationMethod {
00094
00095 nearestNeighbour,
00096
00097 linear,
00098
00099 cubic,
00100
00101 spline,
00102
00103 fftshift
00104 };
00105
00106 enum WeightingSetup {
00107 spectrum,
00108 flags,
00109 cumSum,
00110 flat,
00111 flagSpectrum,
00112 flagCumSum,
00113 flagsNonZero,
00114 flagSpectrumNonZero,
00115 flagCumSumNonZero
00116 };
00117
00118 enum SmoothingSetup {
00119 plainSmooth,
00120 plainSmoothSpectrum
00121 };
00122
00123 enum dataCol {
00124 visCube,
00125 visCubeCorrected,
00126 visCubeModel,
00127 visCubeFloat,
00128 weightSpectrum,
00129 sigmaSpectrum
00130 };
00131
00132 enum weightTransformation {
00133
00134 transformWeight,
00135 transformWeightIntoSigma,
00136 weightIntoSigma
00137 };
00138 }
00139
00140
00141 struct spwInfo;
00142 struct channelContribution;
00143
00144
00145 typedef map<MS::PredefinedColumns,MS::PredefinedColumns> dataColMap;
00146 typedef map< pair< pair<uInt,uInt> , uInt >,vector<uInt> > baselineMap;
00147 typedef map<uInt,map<uInt, uInt > > inputSpwChanMap;
00148 typedef map<uInt,vector < channelContribution > > inputOutputChanFactorMap;
00149 typedef map<uInt,pair < spwInfo, spwInfo > > inputOutputSpwMap;
00150
00151
00152 struct channelInfo {
00153
00154 Int SPW_id;
00155 uInt inpChannel;
00156 uInt outChannel;
00157 Double CHAN_FREQ;
00158 Double CHAN_WIDTH;
00159 Double EFFECTIVE_BW;
00160 Double RESOLUTION;
00161 std::vector<Double> contribFrac;
00162 std::vector<Int> contribChannel;
00163 std::vector<Int> contribSPW_id;
00164
00165 channelInfo()
00166 {
00167 SPW_id = -1;
00168 inpChannel = 0;
00169 outChannel = 0;
00170
00171 CHAN_FREQ = -1;
00172 CHAN_WIDTH = -1;
00173 EFFECTIVE_BW = -1;
00174 RESOLUTION = -1;
00175 }
00176
00177 bool operator<(const channelInfo& right_operand) const
00178 {
00179 if (CHAN_FREQ<right_operand.CHAN_FREQ)
00180 {
00181 return true;
00182 }
00183 else
00184 {
00185 return false;
00186 }
00187 }
00188
00189 Double upperBound() const
00190 {
00191 return CHAN_FREQ + 0.5 * std::abs(CHAN_WIDTH);
00192 }
00193
00194 Double lowerBound() const
00195 {
00196 return CHAN_FREQ - 0.5 * std::abs(CHAN_WIDTH);
00197 }
00198
00199 Double overlap(const channelInfo& other) const
00200 {
00201
00202
00203 if ((lowerBound() <= other.lowerBound()) and (upperBound() >= other.upperBound()))
00204 {
00205 return 1.0;
00206 }
00207
00208 else if ((lowerBound() >= other.lowerBound()) and (upperBound() <= other.upperBound()))
00209 {
00210 return CHAN_WIDTH/other.CHAN_WIDTH;
00211 }
00212
00213 else if (lowerBound() < other.lowerBound() && other.lowerBound() < upperBound() && upperBound() < other.upperBound())
00214 {
00215 return (upperBound()-other.lowerBound())/other.CHAN_WIDTH;
00216 }
00217
00218 else if (other.lowerBound() < lowerBound() && lowerBound() < other.upperBound() && other.upperBound() < upperBound())
00219 {
00220 return (other.upperBound()-lowerBound())/other.CHAN_WIDTH;
00221 }
00222 else
00223 {
00224 return 0.0;
00225 }
00226
00227 }
00228 };
00229
00230 struct channelContribution {
00231
00232 Int inpSpw;
00233 uInt inpChannel;
00234 uInt outChannel;
00235 Double weight;
00236 Bool flag;
00237
00238 channelContribution()
00239 {
00240 inpSpw = 0;
00241 inpChannel = 0;
00242 outChannel = 0;
00243 weight = 0;
00244 flag = False;
00245 }
00246
00247 channelContribution(Int inputSpw, uInt inputChannel, uInt outputChannel,Double fraction)
00248 {
00249 inpSpw = inputSpw;
00250 inpChannel = inputChannel;
00251 outChannel = outputChannel;
00252 weight = fraction;
00253 flag = True;
00254 }
00255 };
00256
00257 struct spwInfo {
00258
00259 spwInfo()
00260 {
00261 initialize(0);
00262 }
00263
00264 spwInfo(uInt nChannels)
00265 {
00266 initialize(nChannels);
00267 }
00268
00269 spwInfo(Vector<Double> &chanFreq,Vector<Double> &chanWidth)
00270 {
00271 reset(chanFreq,chanWidth);
00272 }
00273
00274 void reset(Vector<Double> &chanFreq,Vector<Double> &chanWidth)
00275 {
00276 initialize(chanFreq.size());
00277 CHAN_FREQ = chanFreq;
00278 CHAN_WIDTH = chanWidth;
00279 update();
00280 }
00281
00282 void initialize(uInt nChannels)
00283 {
00284 NUM_CHAN = nChannels;
00285 CHAN_FREQ.resize(nChannels,False);
00286 CHAN_WIDTH.resize(nChannels,False);
00287 EFFECTIVE_BW.resize(nChannels,False);
00288 RESOLUTION.resize(nChannels,False);
00289 CHAN_FREQ_aux.resize(nChannels,False);
00290 TOTAL_BANDWIDTH = 0;
00291 REF_FREQUENCY = 0;
00292 upperBound = 0;
00293 lowerBound = 0;
00294 }
00295
00296 void update()
00297 {
00298 if (CHAN_FREQ(NUM_CHAN - 1) > CHAN_FREQ(0)) {
00299 upperBound = CHAN_FREQ(NUM_CHAN-1) + 0.5 * std::abs(CHAN_WIDTH(NUM_CHAN-1));
00300 lowerBound = CHAN_FREQ(0) - 0.5 * std::abs(CHAN_WIDTH(0));
00301
00302 for (auto it = CHAN_WIDTH.begin(); it != CHAN_WIDTH.end(); ++it) {
00303 *it = std::abs(*it);
00304 }
00305 }
00306 else {
00307 upperBound = CHAN_FREQ(0) + 0.5 * std::abs(CHAN_WIDTH(0));
00308 lowerBound = CHAN_FREQ(NUM_CHAN-1) - 0.5 * std::abs(CHAN_WIDTH(NUM_CHAN-1));
00309
00310
00311
00312 for (auto it = CHAN_WIDTH.begin(); it != CHAN_WIDTH.end(); ++it) {
00313 if (*it > 0) {
00314 *it = -*it;
00315 }
00316 }
00317 }
00318
00319 TOTAL_BANDWIDTH = upperBound - lowerBound;
00320 REF_FREQUENCY = CHAN_FREQ(0);
00321
00322 CHAN_FREQ_aux = CHAN_FREQ;
00323 EFFECTIVE_BW = CHAN_WIDTH;
00324 RESOLUTION = CHAN_WIDTH;
00325 }
00326
00327 void resize(uInt nChannels)
00328 {
00329 NUM_CHAN = nChannels;
00330 CHAN_FREQ.resize(nChannels,True);
00331 CHAN_WIDTH.resize(nChannels,True);
00332 EFFECTIVE_BW.resize(nChannels,True);
00333 RESOLUTION.resize(nChannels,True);
00334 CHAN_FREQ_aux.resize(nChannels,True);
00335 update();
00336 }
00337
00338 uInt NUM_CHAN;
00339 Vector<Double> CHAN_FREQ;
00340 Vector<Double> CHAN_WIDTH;
00341 Vector<Double> EFFECTIVE_BW;
00342 Vector<Double> RESOLUTION;
00343 Vector<Double> CHAN_FREQ_aux;
00344 Double TOTAL_BANDWIDTH;
00345 Double REF_FREQUENCY;
00346 Double upperBound;
00347 Double lowerBound;
00348 };
00349
00350
00351 class MSTransformManager
00352 {
00353
00354 friend class MSTransformBufferImpl;
00355 friend class MSTransformIterator;
00356 friend class MSTransformIteratorFactory;
00357
00358 public:
00359
00360 MSTransformManager();
00361 MSTransformManager(Record configuration);
00362
00363 virtual ~MSTransformManager();
00364
00365 void initialize();
00366 void configure(Record &configuration);
00367
00368 void open();
00369 void setup();
00370 void close();
00371
00372 void setupBufferTransformations(vi::VisBuffer2 *vb);
00373 void fillOutputMs(vi::VisBuffer2 *vb);
00374
00375
00376
00377
00378 vi::VisibilityIterator2 * getVisIter() {return visibilityIterator_p;}
00379
00380
00381 MeasurementSet * getOutputMs () {return outputMs_p;};
00382 String getOutputMsName () {return outMsName_p;};
00383
00384
00385 vi::VisBuffer2 * getVisBuffer() {return visibilityIterator_p->getVisBuffer();}
00386 IPosition getShape();
00387 IPosition getTransformedShape(vi::VisBuffer2 *inputVisBuffer);
00388
00389
00390 dataColMap getDataColMap() { return dataColMap_p;}
00391
00392
00393
00394 protected:
00395
00396 void parseMsSpecParams(Record &configuration);
00397 void parseDataSelParams(Record &configuration);
00398 void parseFreqTransParams(Record &configuration);
00399 void parseChanAvgParams(Record &configuration);
00400 void parseRefFrameTransParams(Record &configuration);
00401 void parseFreqSpecParams(Record &configuration);
00402 void parsePhaseShiftParams(Record &configuration);
00403 void parseTimeAvgParams(Record &configuration);
00404 void parseCalParams(Record &configuration);
00405 void parseUVContSubParams(Record &configuration);
00406 void setSpwAvg(Record &configuration);
00407
00408
00409 void initDataSelectionParams();
00410 void getInputNumberOfChannels();
00411
00412
00413 void initRefFrameTransParams();
00414 void regridSpwSubTable();
00415 void regridAndCombineSpwSubtable();
00416 void regridSpwAux( Int spwId,
00417 MFrequency::Types spwInputRefFrame,
00418 Vector<Double> &inputCHAN_FREQ,
00419 Vector<Double> &inputCHAN_WIDTH,
00420 Vector<Double> &originalCHAN_FREQ,
00421 Vector<Double> &originalCHAN_WIDTH,
00422 Vector<Double> ®riddedCHAN_FREQ,
00423 Vector<Double> ®riddedCHAN_WIDTH,
00424 string msg);
00425
00426 void reindexColumn(ScalarColumn<Int> &inputCol, Int value);
00427 void reindexSourceSubTable();
00428 void reindexDDISubTable();
00429 void reindexFeedSubTable();
00430 void reindexSysCalSubTable();
00431 void reindexFreqOffsetSubTable();
00432 void reindexGenericTimeDependentSubTable(const String& subtabname);
00433
00434 void separateSpwSubtable();
00435 void separateFeedSubtable();
00436 void separateSourceSubtable();
00437 void separateSyscalSubtable();
00438 void separateFreqOffsetSubtable();
00439 void separateCalDeviceSubtable();
00440 void separateSysPowerSubtable();
00441
00442
00443
00444 void propagateWeights(Bool on);
00445 void setBufferMode(Bool on);
00446 void setChannelAverageKernel(uInt mode);
00447 void setSmoothingKernel(uInt mode);
00448 void setSmoothingFourierKernel(uInt mode);
00449
00450
00451 void dropNonUniformWidthChannels();
00452
00453
00454 void getOutputNumberOfChannels();
00455
00456
00457 void calculateIntermediateFrequencies( Int spwId,
00458 Vector<Double> &inputChanFreq,
00459 Vector<Double> &inputChanWidth,
00460 Vector<Double> &intermediateChanFreq,
00461 Vector<Double> &intermediateChanWidth);
00462 void calculateWeightAndSigmaFactors();
00463 void calculateNewWeightAndSigmaFactors();
00464
00465
00466 void checkFillFlagCategory();
00467 void checkFillWeightSpectrum();
00468 void checkDataColumnsAvailable();
00469 void checkDataColumnsToFill();
00470 void colCheckInfo(const String& inputColName, const String& outputColName);
00471
00472
00473 virtual void setIterationApproach();
00474 void generateIterator();
00475
00476 void initFrequencyTransGrid(vi::VisBuffer2 *vb);
00477 void fillIdCols(vi::VisBuffer2 *vb,RefRows &rowRef);
00478 void fillDataCols(vi::VisBuffer2 *vb,RefRows &rowRef);
00479
00480 void fillWeightCols(vi::VisBuffer2 *vb,RefRows &rowRef);
00481 void transformAndWriteSpectrum( vi::VisBuffer2 *vb,
00482 RefRows &rowRef,
00483 const Cube<Float> &inputSpectrum,
00484 ArrayColumn<Float> &outputCubeCol,
00485 ArrayColumn<Float> &outputMatrixCol,
00486 MSTransformations::weightTransformation weightTransformation,
00487 Bool flushSpectrumCube);
00488
00489 template <class T> void setTileShape(RefRows &rowRef,ArrayColumn<T> &outputDataCol);
00490
00491 const Cube<Float>& getApplicableSpectrum(vi::VisBuffer2 *vb, MS::PredefinedColumns datacol);
00492 ArrayColumn<Float>& getOutputWeightColumn(vi::VisBuffer2 *vb, MS::PredefinedColumns datacol);
00493 const Cube<Float>& getWeightSpectrumFromSigmaSpectrum(vi::VisBuffer2 *vb);
00494 const Cube<Float>& getWeightSpectrumFlat(vi::VisBuffer2 *vb);
00495
00496
00497
00498 template <class T> void transformAndWriteNotReindexableVector( const Vector<T> &inputVector,
00499 Vector<T> &outputVector,
00500 Bool constant,
00501 ScalarColumn<T> &outputCol,
00502 RefRows &rowReference);
00503
00504 template <class T> void transformAndWriteReindexableVector( const Vector<T> &inputVector,
00505 Vector<T> &outputVector,
00506 Bool constant,
00507 map<uInt,uInt> &inputOutputIndexMap,
00508 ScalarColumn<T> &outputCol,
00509 RefRows &rowReference);
00510
00511 Bool transformDDIVector(const Vector<Int> &inputVector,Vector<Int> &outputVector);
00512
00513 void mapAndAverageVector( const Vector<Double> &inputVector,
00514 Vector<Double> &outputVector);
00515
00516 void mapAndAverageVector( const Vector<Bool> &inputVector,
00517 Vector<Bool> &outputVector);
00518
00519
00520
00521 template <class T> Bool transformNotReindexableVector( const Vector<T> &inputVector,
00522 Vector<T> &outputVector,
00523 Bool constant)
00524 {
00525 Bool transformed = True;
00526
00527 if ((combinespws_p) or (nspws_p >1))
00528 {
00529 if (constant)
00530 {
00531 outputVector = inputVector(0);
00532 }
00533 else
00534 {
00535 mapVector(inputVector,outputVector);
00536 }
00537 }
00538 else
00539 {
00540 transformed = False;
00541 }
00542
00543 return transformed;
00544 };
00545
00546 template <class T> Bool transformReindexableVector( const Vector<T> &inputVector,
00547 Vector<T> &outputVector,
00548 Bool constant,
00549 map<uInt,uInt> &inputOutputIndexMap)
00550 {
00551 Bool transformed = True;
00552
00553 if (inputOutputIndexMap.size() == 0)
00554 {
00555 transformed = transformNotReindexableVector(inputVector,outputVector,constant);
00556 }
00557 else
00558 {
00559 if (constant)
00560 {
00561 outputVector = inputOutputIndexMap[inputVector(0)];
00562 }
00563 else if (combinespws_p)
00564 {
00565 mapAndReindexVector(inputVector,outputVector,inputOutputIndexMap);
00566 }
00567 else
00568 {
00569 reindexVector(inputVector,outputVector,inputOutputIndexMap);
00570 }
00571 }
00572
00573 return transformed;
00574 };
00575
00576 template <class T> void mapAndReindexVector( const Vector<T> &inputVector,
00577 Vector<T> &outputVector,
00578 map<uInt,uInt> &inputOutputIndexMap)
00579 {
00580 if (nspws_p <2)
00581 {
00582 for (uInt index=0; index<rowIndex_p.size();index++)
00583 {
00584 outputVector(index) = inputOutputIndexMap[inputVector(rowIndex_p[index])];
00585 }
00586 }
00587 else
00588 {
00589 uInt absoluteIndex = 0;
00590 for (uInt index=0; index<rowIndex_p.size();index++)
00591 {
00592 for (uInt spwIndex=0;spwIndex < nspws_p; spwIndex++)
00593 {
00594 outputVector(absoluteIndex) = inputOutputIndexMap[inputVector(rowIndex_p[index])];
00595 absoluteIndex += 1;
00596 }
00597 }
00598 }
00599
00600 return;
00601 }
00602
00603
00604 template <class T> void reindexVector( const Vector<T> &inputVector,
00605 Vector<T> &outputVector,
00606 map<uInt,uInt> &inputOutputIndexMap)
00607 {
00608 if (nspws_p <2)
00609 {
00610 for (uInt index=0; index<inputVector.shape()[0];index++)
00611 {
00612 outputVector(index) = inputOutputIndexMap[inputVector(index)];
00613 }
00614 }
00615 else
00616 {
00617 uInt absoluteIndex = 0;
00618 for (uInt index=0; index<inputVector.shape()[0];index++)
00619 {
00620 for (uInt spwIndex=0;spwIndex < nspws_p; spwIndex++)
00621 {
00622 outputVector(absoluteIndex) = inputOutputIndexMap[inputVector(index)];
00623 absoluteIndex += 1;
00624 }
00625 }
00626 }
00627
00628 return;
00629 };
00630
00631 template <class T> void mapVector( const Vector<T> &inputVector,
00632 Vector<T> &outputVector)
00633 {
00634 if (nspws_p < 2)
00635 {
00636 for (uInt index=0; index<rowIndex_p.size();index++)
00637 {
00638 outputVector(index) = inputVector(rowIndex_p[index]);
00639 }
00640 }
00641 else
00642 {
00643 uInt absoluteIndex = 0;
00644 for (uInt index=0; index<rowIndex_p.size();index++)
00645 {
00646 for (uInt spwIndex=0;spwIndex < nspws_p; spwIndex++)
00647 {
00648 outputVector(absoluteIndex) = inputVector(rowIndex_p[index]);
00649 absoluteIndex += 1;
00650 }
00651 }
00652 }
00653
00654
00655 return;
00656 }
00657
00658
00659
00660
00661
00662 template <class T> void mapMatrix( const Matrix<T> &inputMatrix,Matrix<T> &outputMatrix)
00663 {
00664
00665 uInt nCols = outputMatrix.shape()(0);
00666
00667 for (uInt index=0; index<rowIndex_p.size();index++)
00668 {
00669 for (uInt col = 0; col < nCols; col++)
00670 {
00671 outputMatrix(col,index) = inputMatrix(col,rowIndex_p[index]);
00672 }
00673 }
00674
00675 return;
00676 }
00677
00678
00679 template <class T> void mapAndAverageMatrix( const Matrix<T> &inputMatrix,
00680 Matrix<T> &outputMatrix,
00681 Bool convolveFlags=False,
00682 vi::VisBuffer2 *vb=NULL);
00683 template <class T> void mapAndScaleMatrix( const Matrix<T> &inputMatrix,
00684 Matrix<T> &outputMatrix,
00685 map<uInt,T> scaleMap,
00686 Vector<Int> spws);
00687 template <class T> void writeMatrix( const Matrix<T> &inputMatrix,
00688 ArrayColumn<T> &outputCol,
00689 RefRows &rowRef,
00690 uInt nBlocks);
00691
00692
00693
00694 template <class T> void writeCube( const Cube<T> &inputCube,
00695 ArrayColumn<T> &outputCol,
00696 RefRows &rowRef);
00697
00698 void transformCubeOfData( vi::VisBuffer2 *vb,
00699 RefRows &rowRef,
00700 const Cube<Complex> &inputDataCube,
00701 ArrayColumn<Complex> &outputDataCol,
00702 ArrayColumn<Bool> *outputFlagCol,
00703 const Cube<Float> &inputWeightCube);
00704 void transformCubeOfData( vi::VisBuffer2 *vb,
00705 RefRows &rowRef,
00706 const Cube<Float> &inputDataCube,
00707 ArrayColumn<Float> &outputDataCol,
00708 ArrayColumn<Bool> *outputFlagCol,
00709 const Cube<Float> &inputWeightCube);
00710 void (casa::MSTransformManager::*transformCubeOfDataComplex_p)( vi::VisBuffer2 *vb,
00711 RefRows &rowRef,
00712 const Cube<Complex> &inputDataCube,
00713 ArrayColumn<Complex> &outputDataCol,
00714 ArrayColumn<Bool> *outputFlagCol,
00715 const Cube<Float> &inputWeightCube);
00716 void (casa::MSTransformManager::*transformCubeOfDataFloat_p)( vi::VisBuffer2 *vb,
00717 RefRows &rowRef,
00718 const Cube<Float> &inputDataCube,
00719 ArrayColumn<Float> &outputDataCol,
00720 ArrayColumn<Bool> *outputFlagCol,
00721 const Cube<Float> &inputWeightCube);
00722
00723 template <class T> void copyCubeOfData( vi::VisBuffer2 *vb,
00724 RefRows &rowRef,
00725 const Cube<T> &inputDataCube,
00726 ArrayColumn<T> &outputDataCol,
00727 ArrayColumn<Bool> *outputFlagCol,
00728 const Cube<Float> &inputWeightCube);
00729
00730 template <class T> void combineCubeOfData( vi::VisBuffer2 *vb,
00731 RefRows &rowRef,
00732 const Cube<T> &inputDataCube,
00733 ArrayColumn<T> &outputDataCol,
00734 ArrayColumn<Bool> *outputFlagCol,
00735 const Cube<Float> &inputWeightCube);
00736
00737
00738
00739 void addWeightSpectrumContribution( Double &weight,
00740 uInt &pol,
00741 uInt &inputChannel,
00742 uInt &row,
00743 const Cube<Float> &inputWeightsCube);
00744 void dontAddWeightSpectrumContribution( Double &weight,
00745 uInt &pol,
00746 uInt &inputChannel,
00747 uInt &row,
00748 const Cube<Float> &inputWeightsCube);
00749 void (casa::MSTransformManager::*addWeightSpectrumContribution_p)( Double &weight,
00750 uInt &pol,
00751 uInt &inputChannel,
00752 uInt &row,
00753 const Cube<Float> &inputWeightsCube);
00754
00755
00756 void fillWeightsPlane( uInt pol,
00757 uInt inputChannel,
00758 uInt outputChannel,
00759 uInt inputRow,
00760 const Cube<Float> &inputWeightsCube,
00761 Matrix<Float> &inputWeightsPlane,
00762 Double weight);
00763 void dontfillWeightsPlane( uInt ,
00764 uInt ,
00765 uInt ,
00766 uInt ,
00767 const Cube<Float> &,
00768 Matrix<Float> &,
00769 Double ) {return;}
00770 void (casa::MSTransformManager::*fillWeightsPlane_p)( uInt pol,
00771 uInt inputChannel,
00772 uInt outputChannel,
00773 uInt inputRow,
00774 const Cube<Float> &inputWeightsCube,
00775 Matrix<Float> &inputWeightsPlane,
00776 Double weight);
00777
00778 void normalizeWeightsPlane( uInt pol,
00779 uInt outputChannel,
00780 Matrix<Float> &inputPlaneWeights,
00781 Matrix<Double> &normalizingFactorPlane);
00782 void dontNormalizeWeightsPlane( uInt ,
00783 uInt ,
00784 Matrix<Float> &,
00785 Matrix<Double> &) {return;}
00786 void (casa::MSTransformManager::*normalizeWeightsPlane_p)( uInt pol,
00787 uInt outputChannel,
00788 Matrix<Float> &inputPlaneWeights,
00789 Matrix<Double> &normalizingFactorPlane);
00790
00791 template <class T> void averageCubeOfData( vi::VisBuffer2 *vb,
00792 RefRows &rowRef,
00793 const Cube<T> &inputDataCube,
00794 ArrayColumn<T> &outputDataCol,
00795 ArrayColumn<Bool> *outputFlagCol,
00796 const Cube<Float> &inputWeightCube);
00797 template <class T> void smoothCubeOfData( vi::VisBuffer2 *vb,
00798 RefRows &rowRef,
00799 const Cube<T> &inputDataCube,
00800 ArrayColumn<T> &outputDataCol,
00801 ArrayColumn<Bool> *outputFlagCol,
00802 const Cube<Float> &inputWeightCube);
00803 template <class T> void regridCubeOfData( vi::VisBuffer2 *vb,
00804 RefRows &rowRef,
00805 const Cube<T> &inputDataCube,
00806 ArrayColumn<T> &outputDataCol,
00807 ArrayColumn<Bool> *outputFlagCol,
00808 const Cube<Float> &inputWeightCube);
00809 template <class T> void separateCubeOfData( vi::VisBuffer2 *vb,
00810 RefRows &rowRef,
00811 const Cube<T> &inputDataCube,
00812 ArrayColumn<T> &outputDataCol,
00813 ArrayColumn<Bool> *outputFlagCol,
00814 const Cube<Float> &inputWeightCube);
00815
00816 template <class T> void transformAndWriteCubeOfData( Int inputSpw,
00817 RefRows &rowRef,
00818 const Cube<T> &inputDataCube,
00819 const Cube<Bool> &inputFlagsCube,
00820 const Cube<Float> &inputWeightsCube,
00821 IPosition &outputPlaneShape,
00822 ArrayColumn<T> &outputDataCol,
00823 ArrayColumn<Bool> *outputFlagCol);
00824
00825
00826 void setWeightsPlaneByReference( uInt inputRow,
00827 const Cube<Float> &inputWeightsCube,
00828 Matrix<Float> &inputWeightsPlane);
00829 void dontsetWeightsPlaneByReference( uInt ,
00830 const Cube<Float> &,
00831 Matrix<Float> &) {return;}
00832 void (casa::MSTransformManager::*setWeightsPlaneByReference_p)( uInt inputRow,
00833 const Cube<Float> &inputWeightsCube,
00834 Matrix<Float> &inputWeightsPlane);
00835
00836 template <class T> void transformAndWritePlaneOfData( Int inputSpw,
00837 uInt row,
00838 Matrix<T> &inputDataPlane,
00839 Matrix<Bool> &inputFlagsPlane,
00840 Matrix<Float> &inputWeightsPlane,
00841 Matrix<T> &outputDataPlane,
00842 Matrix<Bool> &outputFlagsPlane,
00843 ArrayColumn<T> &outputDataCol,
00844 ArrayColumn<Bool> *outputFlagCol);
00845 void setWeightStripeByReference( uInt corrIndex,
00846 Matrix<Float> &inputWeightsPlane,
00847 Vector<Float> &inputWeightsStripe);
00848 void dontSetWeightStripeByReference( uInt ,
00849 Matrix<Float> &,
00850 Vector<Float> &) {return;}
00851 void (casa::MSTransformManager::*setWeightStripeByReference_p)( uInt corrIndex,
00852 Matrix<Float> &inputWeightsPlane,
00853 Vector<Float> &inputWeightsStripe);
00854
00855 void setOutputbuffer(Cube<Complex> *& dataBufferPointer,Cube<Bool> *& flagBufferPointer);
00856 void setOutputbuffer(Cube<Float> *& dataBufferPointer,Cube<Bool> *& flagBufferPointer);
00857
00858 template <class T> void bufferOutputPlanes( uInt row,
00859 Matrix<T> &outputDataPlane,
00860 Matrix<Bool> &outputFlagsPlane,
00861 ArrayColumn<T> &outputDataCol,
00862 ArrayColumn<Bool> &outputFlagCol);
00863 template <class T> void bufferOutputPlanesInSlices( uInt row,
00864 Matrix<T> &outputDataPlane,
00865 Matrix<Bool> &outputFlagsPlane,
00866 ArrayColumn<T> &outputDataCol,
00867 ArrayColumn<Bool> &outputFlagCol);
00868
00869 void writeOutputPlanes( uInt row,
00870 Matrix<Complex> &outputDataPlane,
00871 Matrix<Bool> &outputFlagsPlane,
00872 ArrayColumn<Complex> &outputDataCol,
00873 ArrayColumn<Bool> &outputFlagCol);
00874 void writeOutputPlanes( uInt row,
00875 Matrix<Float> &outputDataPlane,
00876 Matrix<Bool> &outputFlagsPlane,
00877 ArrayColumn<Float> &outputDataCol,
00878 ArrayColumn<Bool> &outputFlagCol);
00879 void (casa::MSTransformManager::*writeOutputPlanesComplex_p)( uInt row,
00880 Matrix<Complex> &outputDataPlane,
00881 Matrix<Bool> &outputFlagsPlane,
00882 ArrayColumn<Complex> &outputDataCol,
00883 ArrayColumn<Bool> &outputFlagCol);
00884 void (casa::MSTransformManager::*writeOutputPlanesFloat_p)( uInt row,
00885 Matrix<Float> &outputDataPlane,
00886 Matrix<Bool> &outputFlagsPlane,
00887 ArrayColumn<Float> &outputDataCol,
00888 ArrayColumn<Bool> &outputFlagCol);
00889
00890 template <class T> void writeOutputPlanesInBlock( uInt row,
00891 Matrix<T> &outputDataPlane,
00892 Matrix<Bool> &outputFlagsPlane,
00893 ArrayColumn<T> &outputDataCol,
00894 ArrayColumn<Bool> &outputFlagCol);
00895 void (casa::MSTransformManager::*writeOutputFlagsPlane_p)( Matrix<Bool> &outputPlane,
00896 ArrayColumn<Bool> &outputCol,
00897 IPosition &outputPlaneShape,
00898 uInt &outputRow);
00899 void writeOutputFlagsPlane( Matrix<Bool> &outputPlane,
00900 ArrayColumn<Bool> &outputCol,
00901 IPosition &outputPlaneShape,
00902 uInt &outputRow);
00903 void dontWriteOutputFlagsPlane( Matrix<Bool> &,
00904 ArrayColumn<Bool> &,
00905 IPosition &,
00906 uInt &) {return;}
00907
00908 template <class T> void writeOutputPlanesInSlices( uInt row,
00909 Matrix<T> &outputDataPlane,
00910 Matrix<Bool> &outputFlagsPlane,
00911 ArrayColumn<T> &outputDataCol,
00912 ArrayColumn<Bool> &outputFlagCol);
00913 template <class T> void writeOutputPlaneSlices( Matrix<T> &outputPlane,
00914 ArrayColumn<T> &outputDataCol,
00915 Slice &sliceX,
00916 Slice &sliceY,
00917 IPosition &outputPlaneShape,
00918 uInt &outputRow);
00919 template <class T> void writeOutputPlaneReshapedSlices( Matrix<T> &outputPlane,
00920 ArrayColumn<T> &outputDataCol,
00921 Slice &sliceX,
00922 Slice &sliceY,
00923 IPosition &outputPlaneShape,
00924 uInt &outputRow);
00925 void (casa::MSTransformManager::*writeOutputFlagsPlaneSlices_p)( Matrix<Bool> &outputPlane,
00926 ArrayColumn<Bool> &outputCol,
00927 Slice &sliceX,
00928 Slice &sliceY,
00929 IPosition &outputPlaneShape,
00930 uInt &outputRow);
00931 void writeOutputFlagsPlaneSlices( Matrix<Bool> &outputPlane,
00932 ArrayColumn<Bool> &outputCol,
00933 Slice &sliceX,
00934 Slice &sliceY,
00935 IPosition &outputPlaneShape,
00936 uInt &outputRow);
00937 void dontWriteOutputFlagsPlaneSlices( Matrix<Bool> &,
00938 ArrayColumn<Bool> &,
00939 Slice &,
00940 Slice &,
00941 IPosition &,
00942 uInt &) {return;}
00943 void (casa::MSTransformManager::*writeOutputFlagsPlaneReshapedSlices_p)( Matrix<Bool> &outputPlane,
00944 ArrayColumn<Bool> &outputCol,
00945 Slice &sliceX,
00946 Slice &sliceY,
00947 IPosition &outputPlaneShape,
00948 uInt &outputRow);
00949 void writeOutputFlagsPlaneReshapedSlices( Matrix<Bool> &outputPlane,
00950 ArrayColumn<Bool> &outputCol,
00951 Slice &sliceX,
00952 Slice &sliceY,
00953 IPosition &outputPlaneShape,
00954 uInt &outputRow);
00955 void dontWriteOutputPlaneReshapedSlices( Matrix<Bool> &,
00956 ArrayColumn<Bool> &,
00957 Slice &,
00958 Slice &,
00959 IPosition &,
00960 uInt &) {return;}
00961
00962 void transformStripeOfData( Int inputSpw,
00963 Vector<Complex> &inputDataStripe,
00964 Vector<Bool> &inputFlagsStripe,
00965 Vector<Float> &inputWeightsStripe,
00966 Vector<Complex> &outputDataStripe,
00967 Vector<Bool> &outputFlagsStripe);
00968 void transformStripeOfData( Int inputSpw,
00969 Vector<Float> &inputDataStripe,
00970 Vector<Bool> &inputFlagsStripe,
00971 Vector<Float> &inputWeightsStripe,
00972 Vector<Float> &outputDataStripe,
00973 Vector<Bool> &outputFlagsStripe);
00974 void (casa::MSTransformManager::*transformStripeOfDataComplex_p)( Int inputSpw,
00975 Vector<Complex> &inputDataStripe,
00976 Vector<Bool> &inputFlagsStripe,
00977 Vector<Float> &inputWeightsStripe,
00978 Vector<Complex> &outputDataStripe,
00979 Vector<Bool> &outputFlagsStripe);
00980 void (casa::MSTransformManager::*transformStripeOfDataFloat_p)( Int inputSpw,
00981 Vector<Float> &inputDataStripe,
00982 Vector<Bool> &inputFlagsStripe,
00983 Vector<Float> &inputWeightsStripe,
00984 Vector<Float> &outputDataStripe,
00985 Vector<Bool> &outputFlagsStripe);
00986
00987 template <class T> void average( Int inputSpw,
00988 Vector<T> &inputDataStripe,
00989 Vector<Bool> &inputFlagsStripe,
00990 Vector<Float> &inputWeightsStripe,
00991 Vector<T> &outputDataStripe,
00992 Vector<Bool> &outputFlagsStripe);
00993 template <class T> void simpleAverage( uInt width,
00994 Vector<T> &inputData,
00995 Vector<T> &outputData);
00996 void averageKernel( Vector<Complex> &inputData,
00997 Vector<Bool> &inputFlags,
00998 Vector<Float> &inputWeights,
00999 Vector<Complex> &outputData,
01000 Vector<Bool> &outputFlags,
01001 uInt startInputPos,
01002 uInt outputPos,
01003 uInt width);
01004 void averageKernel( Vector<Float> &inputData,
01005 Vector<Bool> &inputFlags,
01006 Vector<Float> &inputWeights,
01007 Vector<Float> &outputData,
01008 Vector<Bool> &outputFlags,
01009 uInt startInputPos,
01010 uInt outputPos,
01011 uInt width);
01012 void (casa::MSTransformManager::*averageKernelComplex_p)( Vector<Complex> &inputData,
01013 Vector<Bool> &inputFlags,
01014 Vector<Float> &inputWeights,
01015 Vector<Complex> &outputData,
01016 Vector<Bool> &outputFlags,
01017 uInt startInputPos,
01018 uInt outputPos,
01019 uInt width);
01020 void (casa::MSTransformManager::*averageKernelFloat_p)( Vector<Float> &inputData,
01021 Vector<Bool> &inputFlags,
01022 Vector<Float> &inputWeights,
01023 Vector<Float> &outputData,
01024 Vector<Bool> &outputFlags,
01025 uInt startInputPos,
01026 uInt outputPos,
01027 uInt width);
01028 template <class T> void simpleAverageKernel( Vector<T> &inputData,
01029 Vector<Bool> &,
01030 Vector<Float> &,
01031 Vector<T> &outputData,
01032 Vector<Bool> &,
01033 uInt startInputPos,
01034 uInt outputPos,
01035 uInt width);
01036 template <class T> void flagAverageKernel( Vector<T> &inputData,
01037 Vector<Bool> &inputFlags,
01038 Vector<Float> &,
01039 Vector<T> &outputData,
01040 Vector<Bool> &outputFlags,
01041 uInt startInputPos,
01042 uInt outputPos,
01043 uInt width);
01044 template <class T> void weightAverageKernel( Vector<T> &inputData,
01045 Vector<Bool> &,
01046 Vector<Float> &inputWeights,
01047 Vector<T> &outputData,
01048 Vector<Bool> &outputFlags,
01049 uInt startInputPos,
01050 uInt outputPos,
01051 uInt width);
01052 template <class T> void cumSumKernel( Vector<T> &inputData,
01053 Vector<Bool> &,
01054 Vector<Float> &,
01055 Vector<T> &outputData,
01056 Vector<Bool> &,
01057 uInt startInputPos,
01058 uInt outputPos,
01059 uInt width);
01060 template <class T> void flagWeightAverageKernel( Vector<T> &inputData,
01061 Vector<Bool> &inputFlags,
01062 Vector<Float> &inputWeights,
01063 Vector<T> &outputData,
01064 Vector<Bool> &outputFlags,
01065 uInt startInputPos,
01066 uInt outputPos,
01067 uInt width);
01068 template <class T> void flagCumSumKernel( Vector<T> &inputData,
01069 Vector<Bool> &inputFlags,
01070 Vector<Float> &,
01071 Vector<T> &outputData,
01072 Vector<Bool> &,
01073 uInt startInputPos,
01074 uInt outputPos,
01075 uInt width);
01076
01077 template <class T> void flagNonZeroAverageKernel( Vector<T> &inputData,
01078 Vector<Bool> &inputFlags,
01079 Vector<Float> &,
01080 Vector<T> &outputData,
01081 Vector<Bool> &,
01082 uInt startInputPos,
01083 uInt outputPos,
01084 uInt width);
01085 template <class T> void flagWeightNonZeroAverageKernel( Vector<T> &inputData,
01086 Vector<Bool> &inputFlags,
01087 Vector<Float> &,
01088 Vector<T> &outputData,
01089 Vector<Bool> &,
01090 uInt startInputPos,
01091 uInt outputPos,
01092 uInt width);
01093 template <class T> void flagCumSumNonZeroKernel( Vector<T> &inputData,
01094 Vector<Bool> &inputFlags,
01095 Vector<Float> &,
01096 Vector<T> &outputData,
01097 Vector<Bool> &,
01098 uInt startInputPos,
01099 uInt outputPos,
01100 uInt width);
01101
01102
01103 template <class T> void smooth( Int inputSpw,
01104 Vector<T> &inputDataStripe,
01105 Vector<Bool> &inputFlagsStripe,
01106 Vector<Float> &inputWeightsStripe,
01107 Vector<T> &outputDataStripe,
01108 Vector<Bool> &outputFlagsStripe);
01109 void smoothKernel( Vector<Complex> &inputData,
01110 Vector<Bool> &inputFlags,
01111 Vector<Float> &inputWeights,
01112 Vector<Complex> &outputData,
01113 Vector<Bool> &outputFlags,
01114 uInt outputPos);
01115 void smoothKernel( Vector<Float> &inputData,
01116 Vector<Bool> &inputFlags,
01117 Vector<Float> &inputWeights,
01118 Vector<Float> &outputData,
01119 Vector<Bool> &outputFlags,
01120 uInt outputPos);
01121 void (casa::MSTransformManager::*smoothKernelComplex_p)( Vector<Complex> &inputData,
01122 Vector<Bool> &inputFlags,
01123 Vector<Float> &inputWeights,
01124 Vector<Complex> &outputData,
01125 Vector<Bool> &outputFlags,
01126 uInt outputPos);
01127 void (casa::MSTransformManager::*smoothKernelFloat_p)( Vector<Float> &inputData,
01128 Vector<Bool> &inputFlags,
01129 Vector<Float> &inputWeights,
01130 Vector<Float> &outputData,
01131 Vector<Bool> &outputFlags,
01132 uInt outputPos);
01133 template <class T> void plainSmooth( Vector<T> &inputData,
01134 Vector<Bool> &inputFlags,
01135 Vector<Float> &inputWeights,
01136 Vector<T> &outputData,
01137 Vector<Bool> &outputFlags,
01138 uInt outputPos);
01139
01140 template <class T> void plainSmoothSpectrum( Vector<T> &inputData,
01141 Vector<Bool> &inputFlags,
01142 Vector<Float> &inputWeights,
01143 Vector<T> &outputData,
01144 Vector<Bool> &outputFlags,
01145 uInt outputPos);
01146
01147
01148 template <class T> void regrid( Int ,
01149 Vector<T> &inputDataStripe,
01150 Vector<Bool> &inputFlagsStripe,
01151 Vector<Float> &,
01152 Vector<T> &outputDataStripe,
01153 Vector<Bool> &outputFlagsStripe);
01154
01155 void regridCore( Int inputSpw,
01156 Vector<Complex> &inputDataStripe,
01157 Vector<Bool> &inputFlagsStripe,
01158 Vector<Float> &inputWeightsStripe,
01159 Vector<Complex> &outputDataStripe,
01160 Vector<Bool> &outputFlagsStripe);
01161 void regridCore( Int inputSpw,
01162 Vector<Float> &inputDataStripe,
01163 Vector<Bool> &inputFlagsStripe,
01164 Vector<Float> &inputWeightsStripe,
01165 Vector<Float> &outputDataStripe,
01166 Vector<Bool> &outputFlagsStripe);
01167
01168 void (casa::MSTransformManager::*regridCoreComplex_p)( Int inputSpw,
01169 Vector<Complex> &inputDataStripe,
01170 Vector<Bool> &inputFlagsStripe,
01171 Vector<Float> &inputWeightsStripe,
01172 Vector<Complex> &outputDataStripe,
01173 Vector<Bool> &outputFlagsStripe);
01174 void (casa::MSTransformManager::*regridCoreFloat_p)( Int inputSpw,
01175 Vector<Float> &inputDataStripe,
01176 Vector<Bool> &inputFlagsStripe,
01177 Vector<Float> &inputWeightsStripe,
01178 Vector<Float> &outputDataStripe,
01179 Vector<Bool> &outputFlagsStripe);
01180
01181 void fftshift( Int inputSpw,
01182 Vector<Complex> &inputDataStripe,
01183 Vector<Bool> &inputFlagsStripe,
01184 Vector<Float> &inputWeightsStripe,
01185 Vector<Complex> &outputDataStripe,
01186 Vector<Bool> &outputFlagsStripe);
01187 void fftshift( Int inputSpw,
01188 Vector<Float> &inputDataStripe,
01189 Vector<Bool> &inputFlagsStripe,
01190 Vector<Float> &inputWeightsStripe,
01191 Vector<Float> &outputDataStripe,
01192 Vector<Bool> &outputFlagsStripe);
01193
01194 template <class T> void interpol1D( Int inputSpw,
01195 Vector<T> &inputDataStripe,
01196 Vector<Bool> &inputFlagsStripe,
01197 Vector<Float> &,
01198 Vector<T> &outputDataStripe,
01199 Vector<Bool> &outputFlagsStripe);
01200
01201 template <class T> void interpol1Dfftshift( Int inputSpw,
01202 Vector<T> &inputDataStripe,
01203 Vector<Bool> &inputFlagsStripe,
01204 Vector<Float> &inputWeightsStripe,
01205 Vector<T> &outputDataStripe,
01206 Vector<Bool> &outputFlagsStripe);
01207
01208 template <class T> void averageSmooth( Int inputSpw,
01209 Vector<T> &inputDataStripe,
01210 Vector<Bool> &inputFlagsStripe,
01211 Vector<Float> &inputWeightsStripe,
01212 Vector<T> &outputDataStripe,
01213 Vector<Bool> &outputFlagsStripe);
01214 template <class T> void averageRegrid( Int inputSpw,
01215 Vector<T> &inputDataStripe,
01216 Vector<Bool> &inputFlagsStripe,
01217 Vector<Float> &inputWeightsStripe,
01218 Vector<T> &outputDataStripe,
01219 Vector<Bool> &outputFlagsStripe);
01220 template <class T> void smoothRegrid( Int inputSpw,
01221 Vector<T> &inputDataStripe,
01222 Vector<Bool> &inputFlagsStripe,
01223 Vector<Float> &inputWeightsStripe,
01224 Vector<T> &outputDataStripe,
01225 Vector<Bool> &outputFlagsStripe);
01226 template <class T> void averageSmoothRegrid( Int inputSpw,
01227 Vector<T> &inputDataStripe,
01228 Vector<Bool> &inputFlagsStripe,
01229 Vector<Float> &inputWeightsStripe,
01230 Vector<T> &outputDataStripe,
01231 Vector<Bool> &outputFlagsStripe);
01232
01233
01234 void smoothFourierFloat(Int , Vector<Float> &inputDataStripe,
01235 Vector<Bool> &inputFlagsStripe, Vector<Float> &inputWeightStripe,
01236 Vector<Float> &outputDataStripe, Vector<Bool> &outputFlagsStripe);
01237 void smoothFourierComplex(Int , Vector<Complex> &inputDataStripe,
01238 Vector<Bool> &inputFlagsStripe, Vector<Float> &inputWeightStripe,
01239 Vector<Complex> &outputDataStripe, Vector<Bool> &outputFlagsStripe);
01240 Convolver<Float> *getConvolver(Int const numChan);
01241
01242
01243 String inpMsName_p;
01244 String outMsName_p;
01245 String datacolumn_p;
01246 Bool makeVirtualModelColReal_p;
01247 Bool makeVirtualCorrectedColReal_p;
01248 Vector<Int> tileShape_p;
01249
01250
01251 String arraySelection_p;
01252 String fieldSelection_p;
01253 String scanSelection_p;
01254 String timeSelection_p;
01255 String spwSelection_p;
01256 String baselineSelection_p;
01257 String uvwSelection_p;
01258 String polarizationSelection_p;
01259 String scanIntentSelection_p;
01260 String observationSelection_p;
01261 String taqlSelection_p;
01262 String feedSelection_p;
01263
01264
01265 map<uInt,uInt> inputOutputObservationIndexMap_p;
01266 map<uInt,uInt> inputOutputArrayIndexMap_p;
01267 map<uInt,uInt> inputOutputScanIndexMap_p;
01268 map<uInt,uInt> inputOutputScanIntentIndexMap_p;
01269 map<uInt,uInt> inputOutputFieldIndexMap_p;
01270 map<uInt,uInt> inputOutputSPWIndexMap_p;
01271 map<uInt,uInt> inputOutputDDIndexMap_p;
01272 map<uInt,uInt> inputOutputAntennaIndexMap_p;
01273 map<uInt,uInt> outputInputSPWIndexMap_p;
01274 map<Int,vector<Int> > inputOutputChanIndexMap_p;
01275
01276
01277 uInt nspws_p;
01278 Int ddiStart_p;
01279 Bool combinespws_p;
01280 Bool channelAverage_p;
01281 Bool hanningSmooth_p;
01282 Bool refFrameTransformation_p;
01283 Vector<Int> freqbin_p;
01284 String useweights_p;
01285 uInt weightmode_p;
01286 String interpolationMethodPar_p;
01287 casac::variant *phaseCenterPar_p;
01288 String restFrequency_p;
01289 String outputReferenceFramePar_p;
01290 Bool radialVelocityCorrection_p;
01291 Bool regridding_p;
01292 uInt smoothBin_p;
01293 uInt smoothmode_p;
01294 Vector<Float> smoothCoeff_p;
01295
01296
01297 String mode_p;
01298 String start_p;
01299 String width_p;
01300 int nChan_p;
01301 String velocityType_p;
01302
01303
01304 Bool phaseShifting_p;
01305 Double dx_p, dy_p;
01306
01307
01308 Bool timeAverage_p;
01309 Double timeBin_p;
01310 String timespan_p;
01311 vi::AveragingOptions timeAvgOptions_p;
01312 Double maxuvwdistance_p;
01313
01314
01315
01316 Bool calibrate_p;
01317 String callib_p;
01318 Record callibRec_p;
01319
01320
01321 Bool uvcontsub_p;
01322 Record uvcontsubRec_p;
01323
01324
01325 Bool spwAverage_p;
01326
01327
01328 Bool usewtspectrum_p;
01329
01330
01331 Bool bufferMode_p;
01332 Bool userBufferMode_p;
01333 Bool reindex_p;
01334 Bool factory_p;
01335 Bool interactive_p;
01336
01337
01338 MSTransformDataHandler *dataHandler_p;
01339 MeasurementSet *inputMs_p;
01340 MeasurementSet *selectedInputMs_p;
01341 MeasurementSet *outputMs_p;
01342 ROMSColumns *selectedInputMsCols_p;
01343 MSColumns *outputMsCols_p;
01344 MSFieldColumns *inputMSFieldCols_p;
01345
01346
01347 Block<Int> sortColumns_p;
01348 vi::VisibilityIterator2 *visibilityIterator_p;
01349 vi::FrequencySelectionUsingChannels *channelSelector_p;
01350
01351
01352 Bool inputFlagCategoryAvailable_p;
01353 Bool correctedToData_p;
01354 Bool doingData_p;
01355 Bool doingCorrected_p;
01356 Bool doingModel_p;
01357 dataColMap dataColMap_p;
01358 MSMainEnums::PredefinedColumns mainColumn_p;
01359 uInt nRowsToAdd_p;
01360
01361
01362 uInt chansPerOutputSpw_p;
01363 uInt tailOfChansforLastSpw_p;
01364 uInt interpolationMethod_p;
01365 baselineMap baselineMap_p;
01366 vector<uInt> rowIndex_p;
01367 inputSpwChanMap spwChannelMap_p;
01368 inputOutputSpwMap inputOutputSpwMap_p;
01369 inputOutputChanFactorMap inputOutputChanFactorMap_p;
01370 map<uInt,uInt> freqbinMap_p;
01371 map<uInt,uInt> numOfInpChanMap_p;
01372 map<uInt,uInt> numOfSelChanMap_p;
01373 map<uInt,uInt> numOfOutChanMap_p;
01374 map<uInt,uInt> numOfCombInputChanMap_p;
01375 map<uInt,uInt> numOfCombInterChanMap_p;
01376 map<uInt,Float> weightFactorMap_p;
01377 map<uInt,Float> sigmaFactorMap_p;
01378 map<uInt,Float> newWeightFactorMap_p;
01379 map<uInt,Float> newSigmaFactorMap_p;
01380
01381
01382 MFrequency::Types inputReferenceFrame_p;
01383 MFrequency::Types outputReferenceFrame_p;
01384 MPosition observatoryPosition_p;
01385 MEpoch referenceTime_p;
01386 MDirection phaseCenter_p;
01387 MRadialVelocity radialVelocity_p;
01388 MFrequency::Convert freqTransEngine_p;
01389 MFrequency::Convert refTimeFreqTransEngine_p;
01390 FFTServer<Float, Complex> fFFTServer_p;
01391 Bool fftShiftEnabled_p;
01392 Double fftShift_p;
01393 ROScalarMeasColumn<MEpoch> timeMeas_p;
01394
01395
01396 Bool spectrumTransformation_p;
01397 Bool propagateWeights_p;
01398 Bool inputWeightSpectrumAvailable_p;
01399 Bool flushWeightSpectrum_p;
01400 Bool weightSpectrumFlatFilled_p;
01401 Bool weightSpectrumFromSigmaFilled_p;
01402 Bool combinationOfSPWsWithDifferentExposure_p;
01403 Cube<Float> weightSpectrumCube_p;
01404 Cube<Float> weightSpectrumCubeFlat_p;
01405 Cube<Float> weightSpectrumCubeDummy_p;
01406
01407
01408 uInt dataBuffer_p;
01409 uInt relativeRow_p;
01410 Bool spectrumReshape_p;
01411 Bool cubeTransformation_p;
01412 Bool dataColumnAvailable_p;
01413 Bool correctedDataColumnAvailable_p;
01414 Bool modelDataColumnAvailable_p;
01415 Bool floatDataColumnAvailable_p;
01416 Bool lagDataColumnAvailable_p;
01417 Cube<Bool> *flagCube_p;
01418 Cube<Complex> *visCube_p;
01419 Cube<Complex> *visCubeCorrected_p;
01420 Cube<Complex> *visCubeModel_p;
01421 Cube<Float> *visCubeFloat_p;
01422 Cube<Float> *weightSpectrum_p;
01423 Cube<Float> *sigmaSpectrum_p;
01424 Matrix<Float> *weight_p;
01425 Matrix<Float> *sigma_p;
01426 ArrayColumn<Float> dummyWeightCol_p;
01427
01428
01429 Bool smoothFourier_p;
01430 map<Int, Convolver<Float> > convolverPool_;
01431
01432
01433 LogIO logger_p;
01434 };
01435
01436 }
01437
01438 #endif
1.6.1
