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