diff --git a/.gitattributes b/.gitattributes
index 939c2d43dc426761fa5c29de73637656979f9f92..1e65316cf1d8f7d134243c3fda31af278d92f089 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -235,6 +235,7 @@ CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/foreachmsaction.h -text
CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/foreachpolarisationblock.h -text
CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/foreachsimulatedbaselineaction.h -text
CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/fouriertransformaction.h -text
+CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/frequencyconvolutionaction.h -text
CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/frequencyselectionaction.h -text
CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/fringestopaction.h -text
CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/imageraction.h -text
diff --git a/CEP/DP3/AOFlagger/include/AOFlagger/CMakeLists.txt b/CEP/DP3/AOFlagger/include/AOFlagger/CMakeLists.txt
index f91c7b76997325412e842590b5c454dea567961c..d458637c0c981f1765f717592fca98ad5df77193 100644
--- a/CEP/DP3/AOFlagger/include/AOFlagger/CMakeLists.txt
+++ b/CEP/DP3/AOFlagger/include/AOFlagger/CMakeLists.txt
@@ -147,6 +147,7 @@ install(FILES
rfi/strategy/foreachmsaction.h
rfi/strategy/foreachpolarisationblock.h
rfi/strategy/fouriertransformaction.h
+ rfi/strategy/frequencyconvolutionaction.h
rfi/strategy/frequencyselectionaction.h
rfi/strategy/fringestopaction.h
rfi/strategy/imageraction.h
diff --git a/CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/action.h b/CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/action.h
index b57284c93d17625991769f28e9381094917c4090..0127f70870f969930663bf089054429f47efd2fb 100644
--- a/CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/action.h
+++ b/CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/action.h
@@ -43,6 +43,7 @@ namespace rfiStrategy {
ForEachPolarisationBlockType,
ForEachSimulatedBaselineActionType,
FourierTransformActionType,
+ FrequencyConvolutionActionType,
FrequencySelectionActionType,
FringeStopActionType,
ImagerActionType,
diff --git a/CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/directionalcleanaction.h b/CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/directionalcleanaction.h
index 474e7eda56306a542afee929363c63bce2d44719..9f549e80f1bbfef9db5caa2bdb860fe55f59f74f 100644
--- a/CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/directionalcleanaction.h
+++ b/CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/directionalcleanaction.h
@@ -23,6 +23,7 @@
#include <iostream>
#include <AOFlagger/util/ffttools.h>
+#include <AOFlagger/util/plot.h>
#include <AOFlagger/msio/samplerow.h>
#include <AOFlagger/msio/timefrequencydata.h>
@@ -31,6 +32,7 @@
#include <AOFlagger/rfi/strategy/action.h>
#include <AOFlagger/rfi/strategy/actionblock.h>
+#include <AOFlagger/rfi/thresholdtools.h>
#include <AOFlagger/rfi/uvprojection.h>
namespace rfiStrategy {
@@ -38,9 +40,39 @@ namespace rfiStrategy {
class DirectionalCleanAction : public Action
{
public:
- DirectionalCleanAction() : Action(), _limitingDistance(1.0)
+ DirectionalCleanAction() : Action(), _limitingDistance(1.0), _attenuationOfCenter(0.01), _channelConvolutionSize(1), _makePlot(true), _values(0)
{
}
+ virtual ~DirectionalCleanAction()
+ {
+ Finish();
+ }
+ virtual void Finish()
+ {
+ if(_values != 0)
+ {
+ if(_makePlot)
+ {
+ Plot plot("clean.pdf");
+ unsigned left = 0, right = 0;
+ for(unsigned i=0;i!=_valueWidth/2;++i)
+ {
+ if(_values[i] != 0) left = i;
+ if(_values[_valueWidth-i-1] != 0) right = i;
+ }
+ plot.StartScatter("Positive");
+ for(unsigned i=0;i<=left;++i)
+ plot.PushDataPoint(i, _values[i]);
+ plot.StartScatter("Negative");
+ for(unsigned i=0;i<=right;++i)
+ plot.PushDataPoint(i, _values[_valueWidth-i-1]);
+ plot.Close();
+ plot.Show();
+ }
+ delete[] _values;
+ _values = 0;
+ }
+ }
virtual std::string Description()
{
return "Directional cleaning";
@@ -65,9 +97,22 @@ namespace rfiStrategy {
imagDest = Image2D::CreateCopy(revised.GetImaginaryPart()),
realOriginal = Image2D::CreateCopy(original.GetRealPart()),
imagOriginal = Image2D::CreateCopy(original.GetImaginaryPart());
- for(unsigned y=0;y<artifacts.ContaminatedData().ImageHeight();++y)
+
+ Image2DPtr amplitudes = FFTTools::CreateAbsoluteImage(contaminated.GetImage(0), contaminated.GetImage(1));
+
+ if(_channelConvolutionSize != 1)
+ amplitudes = ThresholdTools::FrequencyRectangularConvolution(amplitudes, _channelConvolutionSize);
+
+ if(_values == 0)
+ {
+ _valueWidth = amplitudes->Width();
+ _values = new num_t[amplitudes->Width()];
+ for(unsigned i=0;i<amplitudes->Width();++i) _values[i] = 0.0;
+ }
+
+ for(unsigned y=0;y<contaminated.ImageHeight();++y)
{
- performFrequency(artifacts, realDest, imagDest, realOriginal, imagOriginal, y);
+ performFrequency(artifacts, amplitudes, realDest, imagDest, realOriginal, imagOriginal, y);
}
revised.SetImage(0, realDest);
revised.SetImage(1, imagDest);
@@ -77,10 +122,24 @@ namespace rfiStrategy {
}
double LimitingDistance() const { return _limitingDistance; }
void SetLimitingDistance(double limitingDistance) { _limitingDistance = limitingDistance; }
+
+ unsigned ChannelConvolutionSize() const { return _channelConvolutionSize; }
+ void SetChannelConvolutionSize(unsigned channelConvolutionSize) { _channelConvolutionSize = channelConvolutionSize; }
+
+ numl_t AttenuationOfCenter() const { return _attenuationOfCenter; }
+ void SetAttenuationOfCenter(numl_t attenuationOfCenter) { _attenuationOfCenter = attenuationOfCenter; }
+
+ bool MakePlot() const { return _makePlot; }
+ void SetMakePlot(bool makePlot) { _makePlot = makePlot; }
private:
double _limitingDistance;
+ numl_t _attenuationOfCenter;
+ unsigned _channelConvolutionSize;
+ unsigned _valueWidth;
+ bool _makePlot;
+ num_t *_values;
- void performFrequency(ArtifactSet &artifacts, Image2DPtr realDest, Image2DPtr imagDest, Image2DPtr realOriginal, Image2DPtr imagOriginal, unsigned y)
+ void performFrequency(ArtifactSet &artifacts, Image2DCPtr amplitudeValues, Image2DPtr realDest, Image2DPtr imagDest, Image2DPtr realOriginal, Image2DPtr imagOriginal, unsigned y)
{
Image2DCPtr
realInput = artifacts.ContaminatedData().GetRealPart(),
@@ -96,7 +155,7 @@ namespace rfiStrategy {
bool
*isConjugated = new bool[inputWidth];
- SampleRowPtr row = SampleRow::CreateAmplitudeFromRow(realInput, imagInput, y);
+ SampleRowPtr row = SampleRow::CreateFromRow(amplitudeValues, y);
UVProjection::ProjectPositions(artifacts.MetaData(), inputWidth, y, uPositions, vPositions, isConjugated, artifacts.ProjectedDirectionRad());
@@ -107,12 +166,12 @@ namespace rfiStrategy {
UVProjection::GetIndicesInProjectedImage(_limitingDistance, minU, maxU, inputWidth, destWidth, lowestIndex, highestIndex);
for(unsigned i=0;i!=lowestIndex;++i)
{
- const numl_t weight = (numl_t) i / lowestIndex;
+ const numl_t weight = (1.0-_attenuationOfCenter)*((numl_t) i / lowestIndex) + _attenuationOfCenter;
row->SetValue(i, weight * row->Value(i));
}
for(unsigned i=highestIndex;i!=destWidth;++i)
{
- const numl_t weight = (numl_t) (destWidth - i) / (destWidth - highestIndex);
+ const numl_t weight = _attenuationOfCenter;
row->SetValue(i, weight * row->Value(i));
}
@@ -132,17 +191,20 @@ namespace rfiStrategy {
numl_t amplitudeRemoved = amplitude * 0.75;
- if(amplitude < mean + 2.5*sigma || amplitude < 0.0)
+ numl_t limit = mean;
+
+ if(amplitude < limit || amplitude < 0.0)
{
- AOLogger::Debug << "Strongest component is < mean + 2.5 x sigma, not continuing with clean\n";
+ AOLogger::Debug << "Strongest component is < limit not continuing with clean\n";
} else
{
- subtractComponent(artifacts, realDest, imagDest, inputWidth, uPositions, isConjugated, fIndex, amplitudeRemoved, phase, y);
+ subtractComponent(realDest, imagDest, inputWidth, uPositions, isConjugated, fIndex, amplitudeRemoved, phase, y);
if(fIndex >= lowestIndex && fIndex < highestIndex)
{
AOLogger::Debug << "Within limits " << lowestIndex << "-" << highestIndex << '\n';
- subtractComponent(artifacts, realOriginal, imagOriginal, inputWidth, uPositions, isConjugated, fIndex, amplitudeRemoved, phase, y);
+ _values[fIndex] += amplitudeRemoved;
+ subtractComponent(realOriginal, imagOriginal, inputWidth, uPositions, isConjugated, fIndex, amplitudeRemoved, phase, y);
}
}
@@ -151,7 +213,7 @@ namespace rfiStrategy {
delete[] isConjugated;
}
- void subtractComponent(ArtifactSet &artifacts, Image2DPtr real, Image2DPtr imaginary, const size_t inputWidth, const numl_t *uPositions, const bool *isConjugated, unsigned fIndex, numl_t amplitude, numl_t phase, unsigned y)
+ void subtractComponent(Image2DPtr real, Image2DPtr imaginary, const size_t inputWidth, const numl_t *uPositions, const bool *isConjugated, unsigned fIndex, numl_t amplitude, numl_t phase, unsigned y)
{
numl_t minU, maxU;
UVProjection::MaximalUPositions(inputWidth, uPositions, minU, maxU);
diff --git a/CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/frequencyconvolutionaction.h b/CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/frequencyconvolutionaction.h
new file mode 100644
index 0000000000000000000000000000000000000000..b93c1e5c26f626aedc3fd26dcdc7aaae6509d3d9
--- /dev/null
+++ b/CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/frequencyconvolutionaction.h
@@ -0,0 +1,62 @@
+/***************************************************************************
+ * Copyright (C) 2008 by A.R. Offringa *
+ * offringa@astro.rug.nl *
+ * *
+ * This program is free software; you can redistribute it and/or modify *
+ * it under the terms of the GNU General Public License as published by *
+ * the Free Software Foundation; either version 2 of the License, or *
+ * (at your option) any later version. *
+ * *
+ * This program is distributed in the hope that it will be useful, *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
+ * GNU General Public License for more details. *
+ * *
+ * You should have received a copy of the GNU General Public License *
+ * along with this program; if not, write to the *
+ * Free Software Foundation, Inc., *
+ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
+ ***************************************************************************/
+#ifndef RFI_FREQUENCY_CONVOLUTION_ACTION
+#define RFI_FREQUENCY_CONVOLUTION_ACTION
+
+#include <stdexcept>
+
+#include <AOFlagger/rfi/strategy/action.h>
+#include <AOFlagger/rfi/strategy/actionblock.h>
+#include <AOFlagger/rfi/strategy/artifactset.h>
+
+#include <AOFlagger/rfi/thresholdtools.h>
+
+namespace rfiStrategy {
+
+ class FrequencyConvolutionAction : public Action
+ {
+ public:
+ FrequencyConvolutionAction() : Action(), _convolutionSize(16)
+ {
+ }
+ virtual std::string Description()
+ {
+ return "Frequency convolution";
+ }
+ virtual ActionType Type() const { return FrequencyConvolutionActionType; }
+ virtual void Perform(ArtifactSet &artifacts, class ProgressListener &)
+ {
+ TimeFrequencyData &data = artifacts.ContaminatedData();
+ if(data.ImageCount() != 1)
+ throw std::runtime_error("A frequency convolution can only be applied on single component data");
+
+ Image2DPtr image = ThresholdTools::FrequencyRectangularConvolution(data.GetImage(0), _convolutionSize);
+ data.SetImage(0, image);
+ }
+
+ unsigned ConvolutionSize() const { return _convolutionSize; }
+ void SetConvolutionSize(unsigned size) { _convolutionSize = size; }
+ private:
+ unsigned _convolutionSize;
+ };
+
+} // namespace
+
+#endif // RFI_FREQUENCY_CONVOLUTION_ACTION
diff --git a/CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/strategyreader.h b/CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/strategyreader.h
index 44a476b3b10a86b6e9684179a40a6deabc407718..103906f1e4970bd1ec87f003f0035f6ee47ab29e 100644
--- a/CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/strategyreader.h
+++ b/CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/strategyreader.h
@@ -68,6 +68,7 @@ class StrategyReader {
class Action *parseForEachMSAction(xmlNode *node);
class Action *parseForEachPolarisationBlock(xmlNode *node);
class Action *parseFourierTransformAction(xmlNode *node);
+ class Action *parseFrequencyConvolutionAction(xmlNode *node);
class Action *parseFrequencySelectionAction(xmlNode *node);
class Action *parseFringeStopAction(xmlNode *node);
class Action *parseImagerAction(xmlNode *node);
diff --git a/CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/strategywriter.h b/CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/strategywriter.h
index 23d99cfbd8e9199fadb630c2218e1fe5d14f4cb9..8ecd588d2d39656a77c38f718fd81a4c6b99cd41 100644
--- a/CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/strategywriter.h
+++ b/CEP/DP3/AOFlagger/include/AOFlagger/rfi/strategy/strategywriter.h
@@ -83,6 +83,7 @@ namespace rfiStrategy {
void writeForEachMSAction(const class ForEachMSAction &action);
void writeForEachPolarisationBlock(const class ForEachPolarisationBlock &action);
void writeFourierTransformAction(const class FourierTransformAction &action);
+ void writeFrequencyConvolutionAction(const class FrequencyConvolutionAction &action);
void writeFrequencySelectionAction(const class FrequencySelectionAction &action);
void writeFringeStopAction(const class FringeStopAction &action);
void writeImagerAction(const class ImagerAction &action);
diff --git a/CEP/DP3/AOFlagger/include/AOFlagger/rfi/thresholdtools.h b/CEP/DP3/AOFlagger/include/AOFlagger/rfi/thresholdtools.h
index 0eca7b22068cca1858af6d2972e1c4279f51eec1..0c828454dde1af62fa5ad2207e4e13d035f9b092 100644
--- a/CEP/DP3/AOFlagger/include/AOFlagger/rfi/thresholdtools.h
+++ b/CEP/DP3/AOFlagger/include/AOFlagger/rfi/thresholdtools.h
@@ -51,8 +51,42 @@ class ThresholdTools {
static void FilterConnectedSamples(Mask2DPtr mask, size_t minConnectedSampleArea, bool eightConnected=true);
static void FilterConnectedSample(Mask2DPtr mask, unsigned x, unsigned y, size_t minConnectedSampleArea, bool eightConnected=true);
static void UnrollPhase(Image2DPtr image);
+
+ static Image2DPtr FrequencyRectangularConvolution(Image2DCPtr source, unsigned convolutionSize)
+ {
+ Image2DPtr image = Image2D::CreateCopy(source);
+ const unsigned upperWindowHalf = (convolutionSize+1) / 2;
+ for(size_t x=0;x<image->Width();++x)
+ {
+ num_t sum = 0.0;
+ for(unsigned y=0;y<upperWindowHalf;++y)
+ sum += image->Value(x, y);
+ for(unsigned y=upperWindowHalf;y<convolutionSize;++y)
+ {
+ image->SetValue(x, y-upperWindowHalf, sum/(num_t) y);
+ sum += image->Value(x, y);
+ }
+ unsigned count = convolutionSize;
+ for(unsigned y=convolutionSize;y!=image->Height();++y)
+ {
+ image->SetValue(x, y-upperWindowHalf, sum/(num_t) count);
+ sum += image->Value(x, y) - image->Value(x, y - convolutionSize);
+ }
+ for(unsigned y=image->Height();y!=image->Height() + upperWindowHalf;++y)
+ {
+ image->SetValue(x, y-upperWindowHalf, sum/(num_t) count);
+ sum -= image->Value(x, y - convolutionSize);
+ --count;
+ }
+ }
+ return image;
+ }
private:
ThresholdTools() { }
+
+ // We need this less than operator, because the normal operator
+ // does not enforce a strictly ordered set, because a<b != !(b<a) in the case
+ // of nans/infs.
static bool numLessThanOperator(const num_t &a, const num_t &b) {
if(std::isfinite(a)) {
if(std::isfinite(b))
diff --git a/CEP/DP3/AOFlagger/include/AOFlagger/util/ffttools.h b/CEP/DP3/AOFlagger/include/AOFlagger/util/ffttools.h
index 3a3e8f76bb90ffa461769accc60dc77a8c1cf6d5..740125ef62652a04dcf24724a71b206adef87756 100644
--- a/CEP/DP3/AOFlagger/include/AOFlagger/util/ffttools.h
+++ b/CEP/DP3/AOFlagger/include/AOFlagger/util/ffttools.h
@@ -69,6 +69,10 @@ class FFTTools{
static Image2D *CreateFullImageFromFFT(const Image2D &fft);
static Image2D *CreateShiftedImageFromFFT(const Image2D &fft);
static Image2D *CreateAbsoluteImage(const Image2D &real, const Image2D &imaginary);
+ static Image2DPtr CreateAbsoluteImage(Image2DCPtr real, Image2DCPtr imaginary)
+ {
+ return Image2DPtr(CreateAbsoluteImage(*real, *imaginary));
+ }
static Image2DPtr CreatePhaseImage(Image2DCPtr real, Image2DCPtr imaginary);
static void FFTConvolve(const Image2D &realIn, const Image2D &imaginaryIn, const Image2D &realKernel, const Image2D &imaginaryKernel, Image2D &outReal, Image2D &outImaginary);
static void FFTConvolveFFTKernel(const Image2D &realIn, const Image2D &imaginaryIn, const Image2D &realFFTKernel, const Image2D &imaginaryFFTKernel, Image2D &outReal, Image2D &outImaginary);
diff --git a/CEP/DP3/AOFlagger/src/rfi/strategy/actionfactory.cpp b/CEP/DP3/AOFlagger/src/rfi/strategy/actionfactory.cpp
index 405e48db2cd93b87b1bb38a5c6ee799d20a2f2e7..f506d42cd6b9d55efc391c2520e63bf1b715958f 100644
--- a/CEP/DP3/AOFlagger/src/rfi/strategy/actionfactory.cpp
+++ b/CEP/DP3/AOFlagger/src/rfi/strategy/actionfactory.cpp
@@ -27,13 +27,14 @@
#include <AOFlagger/rfi/strategy/combineflagresults.h>
#include <AOFlagger/rfi/strategy/cutareaaction.h>
#include <AOFlagger/rfi/strategy/directionalcleanaction.h>
-#include <AOFlagger/rfi/strategy/frequencyselectionaction.h>
#include <AOFlagger/rfi/strategy/foreachbaselineaction.h>
#include <AOFlagger/rfi/strategy/foreachcomplexcomponentaction.h>
#include <AOFlagger/rfi/strategy/foreachpolarisationblock.h>
#include <AOFlagger/rfi/strategy/foreachsimulatedbaselineaction.h>
#include <AOFlagger/rfi/strategy/foreachmsaction.h>
#include <AOFlagger/rfi/strategy/fouriertransformaction.h>
+#include <AOFlagger/rfi/strategy/frequencyconvolutionaction.h>
+#include <AOFlagger/rfi/strategy/frequencyselectionaction.h>
#include <AOFlagger/rfi/strategy/fringestopaction.h>
#include <AOFlagger/rfi/strategy/imageraction.h>
#include <AOFlagger/rfi/strategy/iterationblock.h>
@@ -69,6 +70,7 @@ const std::vector<std::string> ActionFactory::GetActionList()
list.push_back("For each simulated baseline");
list.push_back("For each measurement set");
list.push_back("Fourier transformation");
+ list.push_back("Frequency convolution");
list.push_back("Frequency selection");
list.push_back("Fringe stopping recovery");
list.push_back("Image");
@@ -115,6 +117,8 @@ Action *ActionFactory::CreateAction(const std::string &action)
return new ForEachPolarisationBlock();
else if(action == "For each simulated baseline")
return new ForEachSimulatedBaselineAction();
+ else if(action == "Frequency convolution")
+ return new FrequencyConvolutionAction();
else if(action == "Frequency selection")
return new FrequencySelectionAction();
else if(action == "Fringe stopping recovery")
diff --git a/CEP/DP3/AOFlagger/src/rfi/strategy/strategyreader.cpp b/CEP/DP3/AOFlagger/src/rfi/strategy/strategyreader.cpp
index 1c5a705920f639efc3b8f9a58319a371d102d0d2..089ed924d15d6f1950fb5b0b6905cb66374fc4d0 100644
--- a/CEP/DP3/AOFlagger/src/rfi/strategy/strategyreader.cpp
+++ b/CEP/DP3/AOFlagger/src/rfi/strategy/strategyreader.cpp
@@ -32,6 +32,7 @@
#include <AOFlagger/rfi/strategy/foreachmsaction.h>
#include <AOFlagger/rfi/strategy/foreachpolarisationblock.h>
#include <AOFlagger/rfi/strategy/fouriertransformaction.h>
+#include <AOFlagger/rfi/strategy/frequencyconvolutionaction.h>
#include <AOFlagger/rfi/strategy/frequencyselectionaction.h>
#include <AOFlagger/rfi/strategy/fringestopaction.h>
#include <AOFlagger/rfi/strategy/imageraction.h>
@@ -247,6 +248,8 @@ Action *StrategyReader::parseAction(xmlNode *node)
newAction = parseForEachPolarisationBlock(node);
else if(typeStr == "FourierTransformAction")
newAction = parseFourierTransformAction(node);
+ else if(typeStr == "FrequencyConvolutionAction")
+ newAction = parseFrequencyConvolutionAction(node);
else if(typeStr == "FrequencySelectionAction")
newAction = parseFrequencySelectionAction(node);
else if(typeStr == "FringeStopAction")
@@ -353,6 +356,9 @@ Action *StrategyReader::parseDirectionalCleanAction(xmlNode *node)
{
DirectionalCleanAction *newAction = new DirectionalCleanAction();
newAction->SetLimitingDistance(getDouble(node, "limiting-distance"));
+ newAction->SetChannelConvolutionSize(getInt(node, "channel-convolution-size"));
+ newAction->SetAttenuationOfCenter(getDouble(node, "attenuation-of-center"));
+ newAction->SetMakePlot(getBool(node, "make-plot"));
return newAction;
}
@@ -450,6 +456,13 @@ Action *StrategyReader::parseFourierTransformAction(xmlNode *)
return newAction;
}
+class Action *StrategyReader::parseFrequencyConvolutionAction(xmlNode *node)
+{
+ FrequencyConvolutionAction *newAction = new FrequencyConvolutionAction();
+ newAction->SetConvolutionSize(getInt(node, "convolution-size"));
+ return newAction;
+}
+
class Action *StrategyReader::parseFrequencySelectionAction(xmlNode *node)
{
FrequencySelectionAction *newAction = new FrequencySelectionAction();
diff --git a/CEP/DP3/AOFlagger/src/rfi/strategy/strategywriter.cpp b/CEP/DP3/AOFlagger/src/rfi/strategy/strategywriter.cpp
index d9593f7b1503620fe8aeae2e13388e04eb01c700..300f219c06b872c73cd371b320b2d17581c80222 100644
--- a/CEP/DP3/AOFlagger/src/rfi/strategy/strategywriter.cpp
+++ b/CEP/DP3/AOFlagger/src/rfi/strategy/strategywriter.cpp
@@ -31,6 +31,7 @@
#include <AOFlagger/rfi/strategy/foreachmsaction.h>
#include <AOFlagger/rfi/strategy/foreachpolarisationblock.h>
#include <AOFlagger/rfi/strategy/fouriertransformaction.h>
+#include <AOFlagger/rfi/strategy/frequencyconvolutionaction.h>
#include <AOFlagger/rfi/strategy/frequencyselectionaction.h>
#include <AOFlagger/rfi/strategy/fringestopaction.h>
#include <AOFlagger/rfi/strategy/imageraction.h>
@@ -127,6 +128,9 @@ namespace rfiStrategy {
case FourierTransformActionType:
writeFourierTransformAction(static_cast<const FourierTransformAction&>(action));
break;
+ case FrequencyConvolutionActionType:
+ writeFrequencyConvolutionAction(static_cast<const FrequencyConvolutionAction&>(action));
+ break;
case FrequencySelectionActionType:
writeFrequencySelectionAction(static_cast<const FrequencySelectionAction&>(action));
break;
@@ -248,6 +252,9 @@ namespace rfiStrategy {
{
Attribute("type", "DirectionalCleanAction");
Write<double>("limiting-distance", action.LimitingDistance());
+ Write<int>("channel-convolution-size", action.ChannelConvolutionSize());
+ Write<double>("attenuation-of-center", action.AttenuationOfCenter());
+ Write<bool>("make-plot", action.MakePlot());
}
void StrategyWriter::writeForEachBaselineAction(const ForEachBaselineAction &action)
@@ -302,6 +309,12 @@ namespace rfiStrategy {
Attribute("type", "FourierTransformAction");
}
+ void StrategyWriter::writeFrequencyConvolutionAction(const FrequencyConvolutionAction &action)
+ {
+ Attribute("type", "FrequencyConvolutionAction");
+ Write<double>("convolution-size", action.ConvolutionSize());
+ }
+
void StrategyWriter::writeFrequencySelectionAction(const FrequencySelectionAction &action)
{
Attribute("type", "FrequencySelectionAction");