void RFIGuiController::PlotPowerRMS()
{
if(IsImageLoaded())
{
Plot2D &plot = _plotManager->NewPlot2D("Spectrum RMS");
plot.SetLogarithmicYAxis(true);
TimeFrequencyData activeData = ActiveData();
Image2DCPtr image = activeData.GetSingleImage();
Mask2DPtr mask =
Mask2D::CreateSetMaskPtr<false>(image->Width(), image->Height());
Plot2DPointSet &beforeSet = plot.StartLine("Before");
RFIPlots::MakeRMSSpectrumPlot(beforeSet, image, mask);
mask = Mask2D::CreateCopy(activeData.GetSingleMask());
if(!mask->AllFalse())
{
Plot2DPointSet &afterSet = plot.StartLine("After");
RFIPlots::MakeRMSSpectrumPlot(afterSet, image, mask);
//mask->Invert();
//Plot2DPointSet &rfiSet = plot.StartLine("RFI");
//RFIPlots::MakeRMSSpectrumPlot(rfiSet, _timeFrequencyWidget.Image(), mask);
}
_plotManager->Update();
}
}
void ChangeResolutionAction::IncreaseFrequency(TimeFrequencyData &originalData, const TimeFrequencyData &changedData, bool restoreImage, bool restoreMask)
{
if(restoreImage)
{
size_t imageCount = originalData.ImageCount();
if(imageCount != changedData.ImageCount())
throw std::runtime_error("When restoring resolution in change resolution action, original data and changed data do not have the same number of images");
for(size_t i=0;i<imageCount;++i)
{
Image2DCPtr image = changedData.GetImage(i);
Image2DPtr newImage(new Image2D(image->EnlargeVertically(_frequencyDecreaseFactor, originalData.ImageHeight())));
originalData.SetImage(i, newImage);
}
}
if(restoreMask)
{
originalData.SetMask(changedData);
size_t maskCount = originalData.MaskCount();
for(size_t i=0;i<maskCount;++i)
{
Mask2DCPtr mask = changedData.GetMask(i);
Mask2DPtr newMask = Mask2D::CreateUnsetMaskPtr(originalData.ImageWidth(), originalData.ImageHeight());
newMask->EnlargeVerticallyAndSet(*mask, _frequencyDecreaseFactor);
originalData.SetMask(i, newMask);
}
}
}
void ChangeResolutionAction::PerformFrequencyChange(class ArtifactSet &artifacts, class ProgressListener &listener)
{
if(_frequencyDecreaseFactor != 1)
{
ArtifactSet artifactsCopy(artifacts);
artifactsCopy.SetNoImageSet();
TimeFrequencyData oldContaminated = artifacts.ContaminatedData();
DecreaseFrequency(artifactsCopy.OriginalData());
DecreaseFrequency(artifactsCopy.ContaminatedData());
DecreaseFrequency(artifactsCopy.RevisedData());
ActionBlock::Perform(artifactsCopy, listener);
IncreaseFrequency(artifacts.OriginalData(), artifactsCopy.OriginalData(), false, false);
IncreaseFrequency(artifacts.ContaminatedData(), artifactsCopy.ContaminatedData(), _restoreContaminated, _restoreMasks);
IncreaseFrequency(artifacts.RevisedData(), artifactsCopy.RevisedData(), _restoreRevised, _restoreMasks);
if(_restoreRevised)
{
TimeFrequencyData *contaminatedData =
TimeFrequencyData::CreateTFDataFromDiff(oldContaminated, artifacts.RevisedData());
contaminatedData->SetMask(oldContaminated);
artifacts.SetContaminatedData(*contaminatedData);
delete contaminatedData;
}
} else {
ActionBlock::Perform(artifacts, listener);
}
}
void RFIGuiController::plotMeanSpectrum(bool weight)
{
if(IsImageLoaded())
{
std::string title = weight ? "Sum spectrum" : "Mean spectrum";
Plot2D &plot = _plotManager->NewPlot2D(title);
TimeFrequencyData data = ActiveData();
Mask2DCPtr mask =
Mask2D::CreateSetMaskPtr<false>(data.ImageWidth(), data.ImageHeight());
Plot2DPointSet &beforeSet = plot.StartLine("Without flagging");
if(weight)
RFIPlots::MakeMeanSpectrumPlot<true>(beforeSet, data, mask, MetaData());
else
RFIPlots::MakeMeanSpectrumPlot<false>(beforeSet, data, mask, MetaData());
mask = Mask2D::CreateCopy(data.GetSingleMask());
if(!mask->AllFalse())
{
Plot2DPointSet &afterSet = plot.StartLine("Flagged");
if(weight)
RFIPlots::MakeMeanSpectrumPlot<true>(afterSet, data, mask, MetaData());
else
RFIPlots::MakeMeanSpectrumPlot<false>(afterSet, data, mask, MetaData());
}
_plotManager->Update();
}
}
void ChangeResolutionAction::Perform(class ArtifactSet &artifacts, class ProgressListener &listener)
{
TimeFrequencyData oldContaminated = artifacts.ContaminatedData();
if(_timeDecreaseFactor != 1)
{
ArtifactSet artifactsCopy(artifacts);
artifactsCopy.SetNoImageSet();
DecreaseTime(artifactsCopy.OriginalData());
DecreaseTime(artifactsCopy.ContaminatedData());
DecreaseTime(artifactsCopy.RevisedData());
PerformFrequencyChange(artifactsCopy, listener);
IncreaseTime(artifacts.OriginalData(), artifactsCopy.OriginalData(), false, false);
IncreaseTime(artifacts.ContaminatedData(), artifactsCopy.ContaminatedData(), _restoreContaminated, _restoreMasks);
IncreaseTime(artifacts.RevisedData(), artifactsCopy.RevisedData(), _restoreRevised, _restoreMasks);
} else {
PerformFrequencyChange(artifacts, listener);
}
if(_restoreRevised && !_restoreContaminated)
{
oldContaminated.Subtract(artifacts.RevisedData());
if(_restoreMasks)
oldContaminated.SetMask(artifacts.ContaminatedData());
artifacts.SetContaminatedData(oldContaminated);
}
}
void RFIGuiController::PlotPowerTime()
{
if(IsImageLoaded())
{
Plot2D &plot = _plotManager->NewPlot2D("Power over time");
plot.SetLogarithmicYAxis(true);
TimeFrequencyData activeData = ActiveData();
Image2DCPtr image = activeData.GetSingleImage();
Mask2DPtr mask =
Mask2D::CreateSetMaskPtr<false>(image->Width(), image->Height());
Plot2DPointSet &totalPlot = plot.StartLine("Total");
RFIPlots::MakePowerTimePlot(totalPlot, image, mask, MetaData());
mask = Mask2D::CreateCopy(activeData.GetSingleMask());
if(!mask->AllFalse())
{
Plot2DPointSet &uncontaminatedPlot = plot.StartLine("Uncontaminated");
RFIPlots::MakePowerTimePlot(uncontaminatedPlot, image, mask, MetaData());
mask->Invert();
Plot2DPointSet &rfiPlot = plot.StartLine("RFI");
RFIPlots::MakePowerTimePlot(rfiPlot, image, mask, MetaData());
}
_plotManager->Update();
}
}
void IterationsPlot::Add(TimeFrequencyData &data, TimeFrequencyMetaDataCPtr)
{
Item item;
Mask2DCPtr mask = data.GetSingleMask();
item.mode = ThresholdTools::Mode(data.GetSingleImage(), mask);
item.winsorizedMode = ThresholdTools::WinsorizedMode(data.GetSingleImage(), mask);
item.flaggedRatio = (double) mask->GetCount<true>() / ((double) mask->Width() * (double) mask->Height());
_stats.push_back(item);
}
void SlidingWindowFitAction::Perform(ArtifactSet &artifacts, class ProgressListener &listener)
{
LocalFitMethod method;
switch(_parameters.method)
{
case SlidingWindowFitParameters::None:
method.SetToNone();
break;
case SlidingWindowFitParameters::Average:
method.SetToAverage(
_parameters.timeDirectionWindowSize,
_parameters.frequencyDirectionWindowSize);
break;
case SlidingWindowFitParameters::GaussianWeightedAverage:
method.SetToWeightedAverage(
_parameters.timeDirectionWindowSize,
_parameters.frequencyDirectionWindowSize,
_parameters.timeDirectionKernelSize,
_parameters.frequencyDirectionKernelSize);
break;
case SlidingWindowFitParameters::Median:
method.SetToMedianFilter(
_parameters.timeDirectionWindowSize,
_parameters.frequencyDirectionWindowSize);
break;
case SlidingWindowFitParameters::Minimum:
method.SetToMinimumFilter(
_parameters.timeDirectionWindowSize,
_parameters.frequencyDirectionWindowSize);
break;
}
method.Initialize(artifacts.ContaminatedData());
size_t taskCount = method.TaskCount();
for(size_t i=0;i<taskCount;++i)
{
method.PerformFit(i);
listener.OnProgress(*this, i+1, taskCount);
}
TimeFrequencyData newRevisedData = method.Background();
newRevisedData.SetMask(artifacts.RevisedData());
TimeFrequencyData *contaminatedData =
TimeFrequencyData::CreateTFDataFromDiff(artifacts.ContaminatedData(), newRevisedData);
contaminatedData->SetMask(artifacts.ContaminatedData());
artifacts.SetRevisedData(newRevisedData);
artifacts.SetContaminatedData(*contaminatedData);
delete contaminatedData;
}
void ForEachBaselineAction::PerformFunction::operator()()
{
boost::mutex::scoped_lock ioLock(_action._artifacts->IOMutex());
ImageSet *privateImageSet = _action._artifacts->ImageSet()->Copy();
ioLock.unlock();
try {
boost::mutex::scoped_lock lock(_action._mutex);
ArtifactSet newArtifacts(*_action._artifacts);
lock.unlock();
BaselineData *baseline = _action.GetNextBaseline();
while(baseline != 0) {
baseline->Index().Reattach(*privateImageSet);
std::ostringstream progressStr;
if(_action._hasInitAntennae)
progressStr << "Processing baseline " << baseline->MetaData()->Antenna1().name << " x " << baseline->MetaData()->Antenna2().name;
else
progressStr << "Processing next baseline";
_action.SetProgress(_progress, _action.BaselineProgress(), _action._baselineCount, progressStr.str(), _threadIndex);
newArtifacts.SetOriginalData(baseline->Data());
newArtifacts.SetContaminatedData(baseline->Data());
TimeFrequencyData *zero = new TimeFrequencyData(baseline->Data());
zero->SetImagesToZero();
newArtifacts.SetRevisedData(*zero);
delete zero;
newArtifacts.SetImageSetIndex(&baseline->Index());
newArtifacts.SetMetaData(baseline->MetaData());
_action.ActionBlock::Perform(newArtifacts, *this);
delete baseline;
baseline = _action.GetNextBaseline();
_action.IncBaselineProgress();
}
if(_threadIndex == 0)
_action._resultSet = new ArtifactSet(newArtifacts);
} catch(std::exception &e)
{
_progress.OnException(_action, e);
_action.SetExceptionOccured();
}
delete privateImageSet;
}
TimeFrequencyData BaselineReader::GetNextResult(std::vector<class UVW>& uvw)
{
size_t requestIndex = 0;
TimeFrequencyData data;
data = TimeFrequencyData(
_polarizations.data(),
_polarizations.size(),
_results[requestIndex]._realImages.data(),
_results[requestIndex]._imaginaryImages.data());
data.SetIndividualPolarizationMasks(_results[requestIndex]._flags.data());
uvw = _results[0]._uvw;
_results.erase(_results.begin() + requestIndex);
return data;
}
void RFIGuiController::OpenTestSet(unsigned index, bool gaussianTestSets)
{
unsigned width = 1024*16, height = 1024;
if(IsImageLoaded())
{
TimeFrequencyData activeData = ActiveData();
width = activeData.ImageWidth();
height = activeData.ImageHeight();
}
Mask2DPtr rfi = Mask2D::CreateSetMaskPtr<false>(width, height);
Image2DPtr testSetReal(MitigationTester::CreateTestSet(index, rfi, width, height, gaussianTestSets));
Image2DPtr testSetImaginary(MitigationTester::CreateTestSet(2, rfi, width, height, gaussianTestSets));
TimeFrequencyData data(SinglePolarisation, testSetReal, testSetImaginary);
data.SetGlobalMask(rfi);
_rfiGuiWindow.GetTimeFrequencyWidget().SetNewData(data, MetaData());
_rfiGuiWindow.GetTimeFrequencyWidget().Update();
}
void RFIGuiController::PlotPowerSpectrumComparison()
{
if(IsImageLoaded())
{
Plot2D &plot = _plotManager->NewPlot2D("Power spectrum comparison");
TimeFrequencyData data = OriginalData();
Image2DCPtr image = data.GetSingleImage();
Mask2DCPtr mask = data.GetSingleMask();
Plot2DPointSet &originalSet = plot.StartLine("Original");
RFIPlots::MakePowerSpectrumPlot(originalSet, image, mask, MetaData());
data = ContaminatedData();
image = data.GetSingleImage();
mask = data.GetSingleMask();
Plot2DPointSet &alternativeSet = plot.StartLine("Alternative");
RFIPlots::MakePowerSpectrumPlot(alternativeSet, image, mask, MetaData());
_plotManager->Update();
}
}
std::pair<TimeFrequencyData,TimeFrequencyMetaDataPtr> RSPReader::ReadSingleBeamlet(unsigned long timestepStart, unsigned long timestepEnd, unsigned beamletCount, unsigned beamletIndex)
{
std::pair<TimeFrequencyData,TimeFrequencyMetaDataPtr> data = ReadAllBeamlets(timestepStart, timestepEnd, beamletCount);
const unsigned width = timestepEnd - timestepStart;
Image2DPtr realX = Image2D::CreateZeroImagePtr(width, 1);
Image2DPtr imaginaryX = Image2D::CreateZeroImagePtr(width, 1);
Image2DPtr realY = Image2D::CreateZeroImagePtr(width, 1);
Image2DPtr imaginaryY = Image2D::CreateZeroImagePtr(width, 1);
Mask2DPtr mask = Mask2D::CreateUnsetMaskPtr(width, 1);
TimeFrequencyData allX = data.first.Make(Polarization::XX);
TimeFrequencyData allY = data.first.Make(Polarization::YY);
Image2DCPtr xr = allX.GetRealPart();
Image2DCPtr xi = allX.GetImaginaryPart();
Image2DCPtr yr = allY.GetRealPart();
Image2DCPtr yi = allY.GetImaginaryPart();
Mask2DCPtr maskWithBeamlets = data.first.GetSingleMask();
for(unsigned x=0;x<width;++x)
{
realX->SetValue(x, 0, xr->Value(x, beamletIndex));
imaginaryX->SetValue(x, 0, xi->Value(x, beamletIndex));
realY->SetValue(x, 0, yr->Value(x, beamletIndex));
imaginaryY->SetValue(x, 0, yi->Value(x, beamletIndex));
mask->SetValue(x, 0, maskWithBeamlets->Value(x, beamletIndex));
}
data.first = TimeFrequencyData(Polarization::XX, realX, imaginaryX, Polarization::YY, realY, imaginaryY);
data.first.SetGlobalMask(mask);
BandInfo band = data.second->Band();
band.channels[0] = data.second->Band().channels[beamletIndex];
band.channels.resize(1);
data.second->SetBand(band);
return data;
}
void UVImager::Image(const TimeFrequencyData &data, TimeFrequencyMetaDataCPtr metaData, unsigned frequencyIndex)
{
if(_uvReal == 0)
Empty();
Image2DCPtr
real = data.GetRealPart(),
imaginary = data.GetImaginaryPart();
Mask2DCPtr
flags = data.GetSingleMask();
for(unsigned i=0;i<data.ImageWidth();++i) {
switch(_imageKind) {
case Homogeneous:
if(flags->Value(i, frequencyIndex)==0.0L) {
num_t
vr = real->Value(i, frequencyIndex),
vi = imaginary->Value(i, frequencyIndex);
if(std::isfinite(vr) && std::isfinite(vi))
{
num_t u,v;
GetUVPosition(u, v, i, frequencyIndex, metaData);
SetUVValue(u, v, vr, vi, 1.0);
SetUVValue(-u, -v, vr, -vi, 1.0);
}
}
break;
case Flagging:
if((flags->Value(i, frequencyIndex)!=0.0L && !_invertFlagging) ||
(flags->Value(i, frequencyIndex)==0.0L && _invertFlagging)) {
num_t u,v;
GetUVPosition(u, v, i, frequencyIndex, metaData);
SetUVValue(u, v, 1, 0, 1.0);
SetUVValue(-u, -v, 1, 0, 1.0);
}
break;
}
}
}
void ChangeResolutionAction::DecreaseTimeWithMask(TimeFrequencyData &data)
{
size_t polCount = data.PolarisationCount();
for(size_t i=0;i<polCount;++i)
{
TimeFrequencyData *polData = data.CreateTFDataFromPolarisationIndex(i);
Mask2DCPtr mask = polData->GetSingleMask();
for(unsigned j=0;j<polData->ImageCount();++j)
{
Image2DCPtr image = polData->GetImage(j);
polData->SetImage(j, ThresholdTools::ShrinkHorizontally(_timeDecreaseFactor, image, mask));
}
delete polData;
}
size_t maskCount = data.MaskCount();
for(size_t i=0;i<maskCount;++i)
{
Mask2DCPtr mask = data.GetMask(i);
Mask2DPtr newMask = mask->ShrinkHorizontallyForAveraging(_timeDecreaseFactor);
data.SetMask(i, newMask);
}
}
void SVDAction::Perform(ArtifactSet &artifacts, class ProgressListener &listener)
{
SVDMitigater mitigater;
mitigater.Initialize(artifacts.ContaminatedData());
mitigater.SetRemoveCount(_singularValueCount);
for(size_t i=0;i<mitigater.TaskCount();++i)
{
mitigater.PerformFit(i);
listener.OnProgress(*this, i+1, mitigater.TaskCount());
}
TimeFrequencyData newRevisedData = mitigater.Background();
newRevisedData.SetMask(artifacts.RevisedData());
TimeFrequencyData *contaminatedData =
TimeFrequencyData::CreateTFDataFromDiff(artifacts.ContaminatedData(), newRevisedData);
contaminatedData->SetMask(artifacts.ContaminatedData());
artifacts.SetRevisedData(newRevisedData);
artifacts.SetContaminatedData(*contaminatedData);
delete contaminatedData;
}
void RFIGuiController::PlotDist()
{
if(IsImageLoaded())
{
Plot2D &plot = _plotManager->NewPlot2D("Distribution");
TimeFrequencyData activeData = ActiveData();
Image2DCPtr image = activeData.GetSingleImage();
Mask2DPtr mask =
Mask2D::CreateSetMaskPtr<false>(image->Width(), image->Height());
Plot2DPointSet &totalSet = plot.StartLine("Total");
RFIPlots::MakeDistPlot(totalSet, image, mask);
Plot2DPointSet &uncontaminatedSet = plot.StartLine("Uncontaminated");
mask = Mask2D::CreateCopy(activeData.GetSingleMask());
RFIPlots::MakeDistPlot(uncontaminatedSet, image, mask);
mask->Invert();
Plot2DPointSet &rfiSet = plot.StartLine("RFI");
RFIPlots::MakeDistPlot(rfiSet, image, mask);
_plotManager->Update();
}
}
void RFIGuiController::PlotPowerSpectrum()
{
if(IsImageLoaded())
{
Plot2D &plot = _plotManager->NewPlot2D("Power spectrum");
plot.SetLogarithmicYAxis(true);
TimeFrequencyData data = ActiveData();
Image2DCPtr image = data.GetSingleImage();
Mask2DPtr mask =
Mask2D::CreateSetMaskPtr<false>(image->Width(), image->Height());
Plot2DPointSet &beforeSet = plot.StartLine("Before");
RFIPlots::MakePowerSpectrumPlot(beforeSet, image, mask, MetaData());
mask = Mask2D::CreateCopy(data.GetSingleMask());
if(!mask->AllFalse())
{
Plot2DPointSet &afterSet = plot.StartLine("After");
RFIPlots::MakePowerSpectrumPlot(afterSet, image, mask, MetaData());
}
_plotManager->Update();
}
}
void PlotAction::plotBaselineRMS(ArtifactSet &artifacts)
{
if(artifacts.PolarizationStatistics() == 0)
throw BadUsageException("No polarization statistics in the artifact set");
TimeFrequencyData &data = artifacts.ContaminatedData();
TimeFrequencyMetaDataCPtr metaData = artifacts.MetaData();
double rms = 0.0;
for(unsigned i=0;i<data.PolarisationCount();++i)
{
TimeFrequencyData *polarisation = data.CreateTFDataFromPolarisationIndex(i);
Mask2DCPtr mask = polarisation->GetSingleMask();
for(unsigned j=0;j<polarisation->ImageCount();++j)
{
Image2DCPtr image = polarisation->GetImage(j);
rms += ThresholdTools::RMS(image, mask);
}
delete polarisation;
}
rms /= data.PolarisationCount();
;
AOLogger::Info << "RMS of " << metaData->Antenna1().name << " x " << metaData->Antenna2().name << ": "
<< rms << '\n';
}
void RFIGuiController::PlotLogLogDist()
{
if(IsImageLoaded())
{
TimeFrequencyData activeData = ActiveData();
HistogramCollection histograms(activeData.PolarisationCount());
for(unsigned p=0;p!=activeData.PolarisationCount();++p)
{
TimeFrequencyData *polData = activeData.CreateTFDataFromPolarisationIndex(p);
Image2DCPtr image = polData->GetSingleImage();
Mask2DCPtr mask = Mask2D::CreateCopy(polData->GetSingleMask());
histograms.Add(0, 1, p, image, mask);
}
_rfiGuiWindow.ShowHistogram(histograms);
}
}
void ChangeResolutionAction::DecreaseFrequency(TimeFrequencyData &timeFrequencyData)
{
size_t imageCount = timeFrequencyData.ImageCount();
for(size_t i=0;i<imageCount;++i)
{
Image2DCPtr image = timeFrequencyData.GetImage(i);
Image2DPtr newImage = image->ShrinkVertically(_frequencyDecreaseFactor);
timeFrequencyData.SetImage(i, newImage);
}
size_t maskCount = timeFrequencyData.MaskCount();
for(size_t i=0;i<maskCount;++i)
{
Mask2DCPtr mask = timeFrequencyData.GetMask(i);
Mask2DPtr newMask = mask->ShrinkVertically(_frequencyDecreaseFactor);
timeFrequencyData.SetMask(i, newMask);
}
}
void ChangeResolutionAction::DecreaseTimeWithMask(TimeFrequencyData& data)
{
size_t polCount = data.PolarizationCount();
for(size_t i=0;i<polCount;++i)
{
TimeFrequencyData polData(data.MakeFromPolarizationIndex(i));
const Mask2DCPtr mask = polData.GetSingleMask();
for(unsigned j=0;j<polData.ImageCount();++j)
{
const Image2DCPtr image = polData.GetImage(j);
polData.SetImage(j, ThresholdTools::ShrinkHorizontally(_timeDecreaseFactor, image.get(), mask.get()));
}
data.SetPolarizationData(i, std::move(polData));
}
size_t maskCount = data.MaskCount();
for(size_t i=0;i<maskCount;++i)
{
Mask2DCPtr mask = data.GetMask(i);
Mask2DPtr newMask(new Mask2D(mask->ShrinkHorizontallyForAveraging(_timeDecreaseFactor)));
data.SetMask(i, std::move(newMask));
}
}
void ChangeResolutionAction::DecreaseTime(TimeFrequencyData &timeFrequencyData)
{
if(_useMaskInAveraging)
{
DecreaseTimeWithMask(timeFrequencyData);
}
else {
size_t imageCount = timeFrequencyData.ImageCount();
for(size_t i=0;i<imageCount;++i)
{
Image2DCPtr image = timeFrequencyData.GetImage(i);
Image2DPtr newImage(new Image2D(image->ShrinkHorizontally(_timeDecreaseFactor)));
timeFrequencyData.SetImage(i, std::move(newImage));
}
size_t maskCount = timeFrequencyData.MaskCount();
for(size_t i=0;i<maskCount;++i)
{
Mask2DCPtr mask = timeFrequencyData.GetMask(i);
Mask2DPtr newMask(new Mask2D(mask->ShrinkHorizontally(_timeDecreaseFactor)));
timeFrequencyData.SetMask(i, std::move(newMask));
}
}
}
TimeFrequencyData TimeFrequencyImager::GetData() const
{
TimeFrequencyData data;
if(
_realXX != 0 && _imaginaryXX != 0 &&
_realXY != 0 && _imaginaryXY != 0 &&
_realYX != 0 && _imaginaryYX != 0 &&
_realYY != 0 && _imaginaryYY != 0)
{
data = TimeFrequencyData(_realXX, _imaginaryXX, _realXY, _imaginaryXY, _realYX, _imaginaryYX, _realYY, _imaginaryYY);
} else if(
_realXX != 0 && _imaginaryXX != 0 &&
_realYY != 0 && _imaginaryYY != 0)
{
data = TimeFrequencyData(AutoDipolePolarisation, _realXX, _imaginaryXX, _realYY, _imaginaryYY);
} else if(_realStokesI != 0 && _imaginaryStokesI != 0)
{
data = TimeFrequencyData(StokesIPolarisation, _realStokesI, _imaginaryStokesI);
}
if(_flagXX != 0 && _flagXY != 0 && _flagYX != 0 && _flagYY != 0)
{
if(data.Polarisation() != DipolePolarisation)
throw BadUsageException("Trying to read dipole polarisation masks, but TF data does not have the dipole polarisations");
data.SetIndividualPolarisationMasks(_flagXX, _flagXY, _flagYX, _flagYY);
} else if(_flagXX != 0 && _flagYY != 0)
{
if(data.Polarisation() != AutoDipolePolarisation)
throw BadUsageException("Trying to read auto dipole polarisation masks, but TF data does not have the auto dipole polarisations");
data.SetIndividualPolarisationMasks(_flagXX, _flagYY);
} else if(_flagCombined != 0)
{
data.SetGlobalMask(_flagCombined);
}
return data;
}
void SpatialCompositionAction::Perform(ArtifactSet &artifacts, ProgressListener &progress)
{
size_t imageCount = artifacts.ContaminatedData().ImageCount();
std::vector<Image2DPtr> images(imageCount);
for(size_t p=0;p<imageCount;++p)
images[p] = Image2D::CreateZeroImagePtr(artifacts.ContaminatedData().ImageWidth(), artifacts.ContaminatedData().ImageHeight());
std::string filename = artifacts.ImageSet()->File();
SpatialMSImageSet set(filename);
ImageSetIndex *index = set.StartIndex();
size_t progressStep = 0, totalProgress = artifacts.ContaminatedData().ImageWidth() * artifacts.ContaminatedData().ImageHeight()/256;
while(index->IsValid())
{
TimeFrequencyData *data = set.LoadData(*index);
SpatialMatrixMetaData metaData(set.SpatialMetaData(*index));
for(size_t p=0;p!=imageCount;++p)
{
switch(_operation)
{
case SumCrossCorrelationsOperation:
images[p]->SetValue(metaData.TimeIndex(), metaData.ChannelIndex(), sumCrossCorrelations(data->GetImage(p)));
break;
case SumAutoCorrelationsOperation:
images[p]->SetValue(metaData.TimeIndex(), metaData.ChannelIndex(), sumAutoCorrelations(data->GetImage(p)));
break;
case EigenvalueDecompositionOperation: {
num_t value = eigenvalue(data->GetImage(p), data->GetImage(p+1));
images[p]->SetValue(metaData.TimeIndex(), metaData.ChannelIndex(), value);
images[p+1]->SetValue(metaData.TimeIndex(), metaData.ChannelIndex(), 0.0);
++p;
} break;
case EigenvalueRemovalOperation: {
std::pair<num_t, num_t> value = removeEigenvalue(data->GetImage(p), data->GetImage(p+1));
images[p]->SetValue(metaData.TimeIndex(), metaData.ChannelIndex(), value.first);
images[p+1]->SetValue(metaData.TimeIndex(), metaData.ChannelIndex(), value.second);
++p;
} break;
}
}
delete data;
index->Next();
++progressStep;
progress.OnProgress(*this, progressStep/256, totalProgress);
}
delete index;
TimeFrequencyData newRevisedData = artifacts.RevisedData();
for(size_t p=0;p<imageCount;++p)
newRevisedData.SetImage(p, images[p]);
newRevisedData.SetMask(artifacts.RevisedData());
TimeFrequencyData *contaminatedData =
TimeFrequencyData::CreateTFDataFromDiff(artifacts.ContaminatedData(), newRevisedData);
contaminatedData->SetMask(artifacts.ContaminatedData());
artifacts.SetRevisedData(newRevisedData);
artifacts.SetContaminatedData(*contaminatedData);
delete contaminatedData;
}
void CalibratePassbandAction::calibrate(TimeFrequencyData& data) const
{
const size_t height = data.ImageHeight();
std::vector<num_t> stddev(_steps);
for(size_t step=0; step!=_steps; ++step)
{
const size_t startY = step*height/_steps, endY = (step+1)*height/_steps;
std::vector<num_t> dataVector((1+endY-startY) * data.ImageWidth() * data.ImageCount());
std::vector<num_t>::iterator vecIter = dataVector.begin();
const Mask2DCPtr maskPtr = data.GetSingleMask();
const Mask2D &mask = *maskPtr;
for(size_t i=0; i!=data.ImageCount(); ++i)
{
const Image2D &image = *data.GetImage(i);
for(size_t y=startY; y!=endY; ++y)
{
const num_t *inputPtr = image.ValuePtr(0, y);
const bool *maskPtr = mask.ValuePtr(0, y);
for(size_t x=0; x!=image.Width(); ++x)
{
if(!*maskPtr && std::isfinite(*inputPtr))
{
*vecIter = *inputPtr;
++vecIter;
}
++inputPtr;
++maskPtr;
}
}
}
dataVector.resize(vecIter - dataVector.begin());
num_t mean;
ThresholdTools::WinsorizedMeanAndStdDev<num_t>(dataVector, mean, stddev[step]);
}
for(size_t i=0; i!=data.ImageCount(); ++i)
{
const Image2D &image = *data.GetImage(i);
Image2D *destImage = Image2D::CreateUnsetImage(image.Width(), image.Height());
for(size_t step=0; step!=_steps; ++step)
{
const size_t startY = step*height/_steps, endY = (step+1)*height/_steps;
float correctionFactor;
if(stddev[step] == 0.0)
correctionFactor = 0.0;
else
correctionFactor = 1.0 / stddev[step];
const __m128 corrFact4 = _mm_set_ps(correctionFactor, correctionFactor, correctionFactor, correctionFactor);
for(size_t y=startY; y!=endY; ++y)
{
const float *inputPtr = image.ValuePtr(0, y);
float *destPtr = destImage->ValuePtr(0, y);
for(size_t x=0;x<image.Width();x+=4)
{
_mm_store_ps(destPtr, _mm_mul_ps(corrFact4, _mm_load_ps(inputPtr)));
inputPtr += 4;
destPtr += 4;
}
}
}
data.SetImage(i, Image2DPtr(destImage));
}
}
std::pair<TimeFrequencyData,TimeFrequencyMetaDataPtr> RSPReader::ReadChannelBeamlet(unsigned long timestepStart, unsigned long timestepEnd, unsigned beamletCount, unsigned beamletIndex)
{
const unsigned width = timestepEnd - timestepStart;
std::pair<TimeFrequencyData,TimeFrequencyMetaDataPtr> data = ReadSingleBeamlet(timestepStart*(unsigned long) 256, timestepEnd*(unsigned long) 256, beamletCount, beamletIndex);
TimeFrequencyData allX = data.first.Make(Polarization::XX);
TimeFrequencyData allY = data.first.Make(Polarization::YY);
Image2DCPtr xr = allX.GetRealPart();
Image2DCPtr xi = allX.GetImaginaryPart();
Image2DCPtr yr = allY.GetRealPart();
Image2DCPtr yi = allY.GetImaginaryPart();
Mask2DCPtr mask = data.first.GetSingleMask();
Image2DPtr
outXR = Image2D::CreateUnsetImagePtr(width, 256),
outXI = Image2D::CreateUnsetImagePtr(width, 256),
outYR = Image2D::CreateUnsetImagePtr(width, 256),
outYI = Image2D::CreateUnsetImagePtr(width, 256);
Mask2DPtr
outMask = Mask2D::CreateUnsetMaskPtr(width, 256);
std::vector<double> observationTimes;
for(unsigned long timestep = 0;timestep < timestepEnd-timestepStart;++timestep)
{
unsigned long timestepIndex = timestep * 256;
SampleRow
realX = SampleRow::MakeFromRow(xr.get(), timestepIndex, 256, 0),
imaginaryX = SampleRow::MakeFromRow(xi.get(), timestepIndex, 256, 0),
realY = SampleRow::MakeFromRow(yr.get(), timestepIndex, 256, 0),
imaginaryY = SampleRow::MakeFromRow(yi.get(), timestepIndex, 256, 0);
FFTTools::FFT(realX, imaginaryX);
FFTTools::FFT(realY, imaginaryY);
realX.SetVerticalImageValues(outXR.get(), timestep);
imaginaryX.SetVerticalImageValues(outXI.get(), timestep);
realY.SetVerticalImageValues(outYR.get(), timestep);
imaginaryY.SetVerticalImageValues(outYI.get(), timestep);
observationTimes.push_back(data.second->ObservationTimes()[timestepIndex + 256/2]);
size_t validValues = 0;
for(unsigned y=0;y<256;++y)
{
if(!mask->Value(timestepIndex + y, 0))
++validValues;
}
for(unsigned y=0;y<256;++y)
{
outMask->SetValue(timestep, y , validValues == 0);
}
}
data.first = TimeFrequencyData(Polarization::XX, outXR, outXI, Polarization::YY, outYR, outYI);
data.first.SetGlobalMask(outMask);
BandInfo band = data.second->Band();
band.channels.clear();
for(unsigned i=0;i<256;++i)
{
ChannelInfo channel;
channel.frequencyHz = i+1;
channel.frequencyIndex = i;
band.channels.push_back(channel);
}
data.second->SetBand(band);
data.second->SetObservationTimes(observationTimes);
return data;
}
void BHFitsImageSet::loadImageData(TimeFrequencyData &data, const TimeFrequencyMetaDataPtr &metaData, const BHFitsImageSetIndex &index)
{
std::vector<num_t> buffer(_width * _height);
_file->ReadCurrentImageData(0, &buffer[0], _width * _height);
int
rangeStart = _timeRanges[index._imageIndex].start,
rangeEnd = _timeRanges[index._imageIndex].end;
Image2DPtr image = Image2D::CreateZeroImagePtr(rangeEnd-rangeStart, _height);
std::vector<num_t>::const_iterator bufferPtr = buffer.begin() + _height*rangeStart;
for(int x=rangeStart; x!=rangeEnd; ++x)
{
for(int y=0; y!=_height; ++y)
{
image->SetValue(x-rangeStart, y, *bufferPtr);
++bufferPtr;
}
}
data = TimeFrequencyData(TimeFrequencyData::AmplitudePart, SinglePolarisation, image);
try {
FitsFile flagFile(flagFilePath());
flagFile.Open(FitsFile::ReadOnlyMode);
flagFile.ReadCurrentImageData(0, &buffer[0], _width * _height);
bufferPtr = buffer.begin() + _height*rangeStart;
Mask2DPtr mask = Mask2D::CreateUnsetMaskPtr(rangeEnd-rangeStart, _height);
for(int x=rangeStart; x!=rangeEnd; ++x)
{
for(int y=0; y!=_height; ++y)
{
bool flag = false;
if(*bufferPtr == 0.0)
flag = false;
else if(*bufferPtr == 1.0)
flag = true;
else std::runtime_error("Expecting a flag file with only ones and zeros, but this file contained other values.");
mask->SetValue(x-rangeStart, y, flag);
++bufferPtr;
}
}
data.SetGlobalMask(mask);
} catch(std::exception &)
{
// Flag file could not be read; probably does not exist. Ignore this, flags will be initialized to false.
}
double
frequencyDelta = _file->GetDoubleKeywordValue("CDELT1"),
timeDelta = _file->GetDoubleKeywordValue("CDELT2");
BandInfo band;
for(int ch=0; ch!=_height; ++ch)
{
ChannelInfo channel;
channel.frequencyHz = ch * frequencyDelta * 1000000.0;
band.channels.push_back(channel);
}
metaData->SetBand(band);
const int rangeWidth = rangeEnd-rangeStart;
std::vector<double> observationTimes(rangeWidth);
for(int t=0; t!=rangeWidth; ++t)
observationTimes[t] = (t + rangeStart) * timeDelta;
metaData->SetObservationTimes(observationTimes);
AntennaInfo antennaInfo;
antennaInfo.id = 0;
antennaInfo.name = RangeName(index._imageIndex);
antennaInfo.diameter = 0.0;
antennaInfo.mount = "Unknown";
antennaInfo.station = GetTelescopeName();
metaData->SetAntenna1(antennaInfo);
metaData->SetAntenna2(antennaInfo);
}
