private static DirtyImage ForwardCalculateB(Intracommunicator comm, GriddingConstants c, List <List <Subgrid> > metadata, Complex[,,] visibilities, double[,,] uvw, double[] frequencies, Complex[,] PsfCorrelation, float[,] psfCut, float maxSidelobe, Stopwatch watchIdg)
{
Stopwatch another = new Stopwatch();
comm.Barrier();
if (comm.Rank == 0)
{
watchIdg.Start();
}
var localGrid = IDG.Grid(c, metadata, visibilities, uvw, frequencies);
float[,] image = null;
float maxSideLobeLevel = 0.0f;
var grid_total = comm.Reduce <Complex[, ]>(localGrid, SequentialSum, 0);
if (comm.Rank == 0)
{
var dirtyImage = FFT.BackwardFloat(grid_total, c.VisibilitiesCount);
FFT.Shift(dirtyImage);
if (comm.Rank == 0)
{
FitsIO.Write(dirtyImage, "dirtyImage.fits");
}
maxSideLobeLevel = maxSidelobe * Residuals.GetMax(dirtyImage);
//remove spheroidal
image = Residuals.CalcGradientMap(dirtyImage, PsfCorrelation, new Rectangle(0, 0, psfCut.GetLength(0), psfCut.GetLength(1)));
watchIdg.Stop();
}
comm.Broadcast(ref maxSideLobeLevel, 0);
comm.Broadcast(ref image, 0);
return(new DirtyImage(image, maxSideLobeLevel));
}
public static void Run()
{
var folder = @"C:\dev\GitHub\p9-data\small\fits\simulation_point\";
var data = DataLoading.SimulatedPoints.Load(folder);
var gridSizes = new int[] { 256, 512, 1024, 2048, 4096 };
Directory.CreateDirectory("GPUSpeedup");
var writer = new StreamWriter("GPUSpeedup/GPUSpeedup.txt", false);
writer.WriteLine("imgSize;iterCPU;timeCPU;iterGPU;timeGPU");
foreach (var gridSize in gridSizes)
{
var visibilitiesCount = data.visibilitiesCount;
int subgridsize = 8;
int kernelSize = 4;
int max_nr_timesteps = 1024;
double cellSize = (1.0 * 256 / gridSize) / 3600.0 * Math.PI / 180.0;
var c = new GriddingConstants(visibilitiesCount, gridSize, subgridsize, kernelSize, max_nr_timesteps, (float)cellSize, 1, 0.0f);
var metadata = Partitioner.CreatePartition(c, data.uvw, data.frequencies);
var frequencies = FitsIO.ReadFrequencies(Path.Combine(folder, "freq.fits"));
var uvw = FitsIO.ReadUVW(Path.Combine(folder, "uvw.fits"));
var flags = new bool[uvw.GetLength(0), uvw.GetLength(1), frequencies.Length];
double norm = 2.0;
var visibilities = FitsIO.ReadVisibilities(Path.Combine(folder, "vis.fits"), uvw.GetLength(0), uvw.GetLength(1), frequencies.Length, norm);
var psfGrid = IDG.GridPSF(c, metadata, uvw, flags, frequencies);
var psf = FFT.BackwardFloat(psfGrid, c.VisibilitiesCount);
FFT.Shift(psf);
var residualVis = data.visibilities;
var dirtyGrid = IDG.Grid(c, metadata, residualVis, data.uvw, data.frequencies);
var dirtyImage = FFT.BackwardFloat(dirtyGrid, c.VisibilitiesCount);
FFT.Shift(dirtyImage);
var totalSize = new Rectangle(0, 0, gridSize, gridSize);
var bMapCalculator = new PaddedConvolver(PSF.CalcPaddedFourierCorrelation(psf, totalSize), new Rectangle(0, 0, psf.GetLength(0), psf.GetLength(1)));
var bMapCPU = bMapCalculator.Convolve(dirtyImage);
var bMapGPU = bMapCalculator.Convolve(dirtyImage);
var fastCD = new FastSerialCD(totalSize, psf);
var gpuCD = new GPUSerialCD(totalSize, psf, 1000);
var lambda = 0.5f * fastCD.MaxLipschitz;
var alpha = 0.5f;
var xCPU = new float[gridSize, gridSize];
var cpuResult = fastCD.Deconvolve(xCPU, bMapCPU, lambda, alpha, 10000, 1e-8f);
FitsIO.Write(xCPU, "GPUSpeedup/cpuResult" + gridSize + ".fits");
var xGPU = new float[gridSize, gridSize];
var gpuResult = gpuCD.Deconvolve(xGPU, bMapGPU, lambda, alpha, 10000, 1e-8f);
FitsIO.Write(xCPU, "GPUSpeedup/gpuResult" + gridSize + ".fits");
writer.WriteLine(gridSize + ";" + cpuResult.IterationCount + ";" + cpuResult.ElapsedTime.TotalSeconds + ";" + gpuResult.IterationCount + ";" + gpuResult.ElapsedTime.TotalSeconds);
writer.Flush();
}
writer.Close();
}
public static void GenerateSerialCDExample(string simulatedLocation, string outputFolder)
{
var data = MeasurementData.LoadSimulatedPoints(simulatedLocation);
var cellSize = 1.0 / 3600.0 * Math.PI / 180.0;
var c = new GriddingConstants(data.VisibilitiesCount, 256, 8, 4, 512, (float)cellSize, 1, 0.0);
var metadata = Partitioner.CreatePartition(c, data.UVW, data.Frequencies);
var psfGrid = IDG.GridPSF(c, metadata, data.UVW, data.Flags, data.Frequencies);
var psf = FFT.BackwardFloat(psfGrid, c.VisibilitiesCount);
FFT.Shift(psf);
var corrKernel = PSF.CalcPaddedFourierCorrelation(psf, new Rectangle(0, 0, c.GridSize, c.GridSize));
Directory.CreateDirectory(outputFolder);
var reconstruction = new float[c.GridSize, c.GridSize];
var residualVis = data.Visibilities;
var totalSize = new Rectangle(0, 0, c.GridSize, c.GridSize);
var fastCD = new FastSerialCD(totalSize, psf);
var lambda = 0.50f * fastCD.MaxLipschitz;
var alpha = 0.2f;
for (int cycle = 0; cycle < 100; cycle++)
{
var dirtyGrid = IDG.Grid(c, metadata, residualVis, data.UVW, data.Frequencies);
var dirtyImage = FFT.BackwardFloat(dirtyGrid, c.VisibilitiesCount);
FFT.Shift(dirtyImage);
var gradients = Residuals.CalcGradientMap(dirtyImage, corrKernel, totalSize);
Tools.WriteToMeltCSV(Common.PSF.Cut(reconstruction), Path.Combine(outputFolder, "model_CD_" + cycle + ".csv"));
Tools.WriteToMeltCSV(gradients, Path.Combine(outputFolder, "gradients_CD_" + cycle + ".csv"));
fastCD.Deconvolve(reconstruction, gradients, lambda, alpha, 4);
FFT.Shift(reconstruction);
var xGrid = FFT.Forward(reconstruction);
FFT.Shift(reconstruction);
var modelVis = IDG.DeGrid(c, metadata, xGrid, data.UVW, data.Frequencies);
residualVis = Visibilities.Substract(data.Visibilities, modelVis, data.Flags);
}
}
public static void GeneratePSFs(string simulatedLocation, string outputFolder)
{
var data = MeasurementData.LoadSimulatedPoints(simulatedLocation);
var c = MeasurementData.CreateSimulatedStandardParams(data.VisibilitiesCount);
var metadata = Partitioner.CreatePartition(c, data.UVW, data.Frequencies);
var psfGrid = IDG.GridPSF(c, metadata, data.UVW, data.Flags, data.Frequencies);
var psf = FFT.BackwardFloat(psfGrid, c.VisibilitiesCount);
FFT.Shift(psf);
Directory.CreateDirectory(outputFolder);
var maskedPsf = Copy(psf);
Tools.Mask(maskedPsf, 2);
var reverseMasked = Copy(psf);
Tools.ReverseMask(reverseMasked, 2);
var psf2 = PSF.CalcPSFSquared(psf);
var psf2Cut = PSF.CalcPSFSquared(maskedPsf);
Tools.WriteToMeltCSV(psf, Path.Combine(outputFolder, "psf.csv"));
Tools.WriteToMeltCSV(maskedPsf, Path.Combine(outputFolder, "psfCut.csv"));
Tools.WriteToMeltCSV(reverseMasked, Path.Combine(outputFolder, "psfReverseCut.csv"));
Tools.WriteToMeltCSV(psf2, Path.Combine(outputFolder, "psfSquared.csv"));
Tools.WriteToMeltCSV(psf2Cut, Path.Combine(outputFolder, "psfSquaredCut.csv"));
var x = new float[c.GridSize, c.GridSize];
x[10, 10] = 1.0f;
var convKernel = PSF.CalcPaddedFourierConvolution(psf, new Rectangle(0, 0, c.GridSize, c.GridSize));
var corrKernel = PSF.CalcPaddedFourierCorrelation(psf, new Rectangle(0, 0, c.GridSize, c.GridSize));
using (var convolver = new PaddedConvolver(convKernel, new Rectangle(0, 0, c.GridSize, c.GridSize)))
using (var correlator = new PaddedConvolver(corrKernel, new Rectangle(0, 0, c.GridSize, c.GridSize)))
{
var zeroPadded = convolver.Convolve(x);
var psf2Edge = correlator.Convolve(zeroPadded);
Tools.WriteToMeltCSV(zeroPadded, Path.Combine(outputFolder, "psfZeroPadding.csv"));
Tools.WriteToMeltCSV(psf2Edge, Path.Combine(outputFolder, "psfSquaredEdge.csv"));
}
convKernel = PSF.CalcPaddedFourierConvolution(psf, new Rectangle(0, 0, 0, 0));
using (var convolver = new PaddedConvolver(convKernel, new Rectangle(0, 0, 0, 0)))
Tools.WriteToMeltCSV(convolver.Convolve(x), Path.Combine(outputFolder, "psfCircular.csv"));
//================================================= Reconstruct =============================================================
var totalSize = new Rectangle(0, 0, c.GridSize, c.GridSize);
var reconstruction = new float[c.GridSize, c.GridSize];
var fastCD = new FastSerialCD(totalSize, psf);
var lambda = 0.50f * fastCD.MaxLipschitz;
var alpha = 0.2f;
var residualVis = data.Visibilities;
for (int cycle = 0; cycle < 5; cycle++)
{
Console.WriteLine("in cycle " + cycle);
var dirtyGrid = IDG.Grid(c, metadata, residualVis, data.UVW, data.Frequencies);
var dirtyImage = FFT.BackwardFloat(dirtyGrid, c.VisibilitiesCount);
FFT.Shift(dirtyImage);
var gradients = Residuals.CalcGradientMap(dirtyImage, corrKernel, totalSize);
if (cycle == 0)
{
Tools.WriteToMeltCSV(dirtyImage, Path.Combine(outputFolder, "dirty.csv"));
Tools.WriteToMeltCSV(gradients, Path.Combine(outputFolder, "gradients.csv"));
}
fastCD.Deconvolve(reconstruction, gradients, lambda, alpha, 10000, 1e-5f);
FFT.Shift(reconstruction);
var xGrid = FFT.Forward(reconstruction);
FFT.Shift(reconstruction);
var modelVis = IDG.DeGrid(c, metadata, xGrid, data.UVW, data.Frequencies);
residualVis = Visibilities.Substract(data.Visibilities, modelVis, data.Flags);
}
//FitsIO.Write(reconstruction, Path.Combine(outputFolder,"xImage.fits"));
Tools.WriteToMeltCSV(reconstruction, Path.Combine(outputFolder, "elasticNet.csv"));
}
public static void GenerateCLEANExample(string simulatedLocation, string outputFolder)
{
var data = MeasurementData.LoadSimulatedPoints(simulatedLocation);
var cellSize = 1.0 / 3600.0 * Math.PI / 180.0;
var c = new GriddingConstants(data.VisibilitiesCount, 256, 8, 4, 512, (float)cellSize, 1, 0.0);
var metadata = Partitioner.CreatePartition(c, data.UVW, data.Frequencies);
var psfGrid = IDG.GridPSF(c, metadata, data.UVW, data.Flags, data.Frequencies);
var psf = FFT.BackwardFloat(psfGrid, c.VisibilitiesCount);
FFT.Shift(psf);
Directory.CreateDirectory(outputFolder);
var reconstruction = new float[c.GridSize, c.GridSize];
var residualVis = data.Visibilities;
for (int cycle = 0; cycle < 10; cycle++)
{
Console.WriteLine("in cycle " + cycle);
var dirtyGrid = IDG.Grid(c, metadata, residualVis, data.UVW, data.Frequencies);
var dirtyImage = FFT.BackwardFloat(dirtyGrid, c.VisibilitiesCount);
FFT.Shift(dirtyImage);
//FitsIO.Write(dirtyImage, Path.Combine(outputFolder, "dirty_CLEAN_" + cycle + ".fits"));
Tools.WriteToMeltCSV(dirtyImage, Path.Combine(outputFolder, "dirty_CLEAN_" + cycle + ".csv"));
var maxY = -1;
var maxX = -1;
var max = 0.0f;
for (int y = 0; y < dirtyImage.GetLength(0); y++)
{
for (int x = 0; x < dirtyImage.GetLength(1); x++)
{
if (max < Math.Abs(dirtyImage[y, x]))
{
maxY = y;
maxX = x;
max = Math.Abs(dirtyImage[y, x]);
}
}
}
//FitsIO.Write(reconstruction, Path.Combine(outputFolder, "model_CLEAN_" + cycle + ".fits"));
Tools.WriteToMeltCSV(PSF.Cut(reconstruction), Path.Combine(outputFolder, "model_CLEAN_" + cycle + ".csv"));
reconstruction[maxY, maxX] += 0.5f * dirtyImage[maxY, maxX];
FFT.Shift(reconstruction);
var xGrid = FFT.Forward(reconstruction);
FFT.Shift(reconstruction);
var modelVis = IDG.DeGrid(c, metadata, xGrid, data.UVW, data.Frequencies);
residualVis = Visibilities.Substract(data.Visibilities, modelVis, data.Flags);
}
var cleanbeam = new float[c.GridSize, c.GridSize];
var x0 = c.GridSize / 2;
var y0 = c.GridSize / 2;
for (int y = 0; y < cleanbeam.GetLength(0); y++)
{
for (int x = 0; x < cleanbeam.GetLength(1); x++)
{
cleanbeam[y, x] = (float)(1.0 * Math.Exp(-(Math.Pow(x0 - x, 2) / 16 + Math.Pow(y0 - y, 2) / 16)));
}
}
FitsIO.Write(cleanbeam, Path.Combine(outputFolder, "clbeam.fits"));
FFT.Shift(cleanbeam);
var CL = FFT.Forward(cleanbeam);
var REC = FFT.Forward(reconstruction);
var CONF = Common.Fourier2D.Multiply(REC, CL);
var cleaned = FFT.BackwardFloat(CONF, reconstruction.Length);
//FFT.Shift(cleaned);
//FitsIO.Write(cleaned, Path.Combine(outputFolder, "rec_CLEAN.fits"));
Tools.WriteToMeltCSV(PSF.Cut(cleaned), Path.Combine(outputFolder, "rec_CLEAN.csv"));
}
/// <summary>
/// Major cycle implemnentation for the parallel coordinate descent algorithm
/// </summary>
/// <param name="data"></param>
/// <param name="c"></param>
/// <param name="psfCutFactor"></param>
/// <param name="maxMajorCycle"></param>
/// <param name="maxMinorCycle"></param>
/// <param name="lambda"></param>
/// <param name="alpha"></param>
/// <param name="deconvIterations"></param>
/// <param name="deconvEpsilon"></param>
public static void ReconstructPCDM(string obsName, MeasurementData data, GriddingConstants c, int psfCutFactor, int maxMajorCycle, int maxMinorCycle, float lambda, float alpha, int deconvIterations, float deconvEpsilon)
{
var metadata = Partitioner.CreatePartition(c, data.UVW, data.Frequencies);
var psfVis = new Complex[data.UVW.GetLength(0), data.UVW.GetLength(1), data.Frequencies.Length];
for (int i = 0; i < data.Visibilities.GetLength(0); i++)
{
for (int j = 0; j < data.Visibilities.GetLength(1); j++)
{
for (int k = 0; k < data.Visibilities.GetLength(2); k++)
{
if (!data.Flags[i, j, k])
{
psfVis[i, j, k] = new Complex(1.0, 0);
}
else
{
psfVis[i, j, k] = new Complex(0, 0);
}
}
}
}
Console.WriteLine("gridding psf");
var psfGrid = IDG.Grid(c, metadata, psfVis, data.UVW, data.Frequencies);
var psf = FFT.BackwardFloat(psfGrid, c.VisibilitiesCount);
FFT.Shift(psf);
var totalWatch = new Stopwatch();
var currentWatch = new Stopwatch();
var totalSize = new Rectangle(0, 0, c.GridSize, c.GridSize);
var psfCut = PSF.Cut(psf, psfCutFactor);
var maxSidelobe = PSF.CalcMaxSidelobe(psf, psfCutFactor);
var sidelobeHalf = PSF.CalcMaxSidelobe(psf, 2);
var pcdm = new ParallelCoordinateDescent(totalSize, psfCut, Environment.ProcessorCount, 1000);
using (var gCalculator = new PaddedConvolver(PSF.CalcPaddedFourierCorrelation(psfCut, totalSize), new Rectangle(0, 0, psfCut.GetLength(0), psfCut.GetLength(1))))
using (var gCalculator2 = new PaddedConvolver(PSF.CalcPaddedFourierCorrelation(psf, totalSize), new Rectangle(0, 0, psf.GetLength(0), psf.GetLength(1))))
using (var residualsConvolver = new PaddedConvolver(totalSize, psf))
{
var currentGCalculator = gCalculator;
var maxLipschitz = PSF.CalcMaxLipschitz(psfCut);
var lambdaLipschitz = (float)(lambda * maxLipschitz);
var lambdaTrue = (float)(lambda * PSF.CalcMaxLipschitz(psf));
var switchedToOtherPsf = false;
var xImage = new float[c.GridSize, c.GridSize];
var residualVis = data.Visibilities;
ParallelCoordinateDescent.PCDMStatistics lastResult = null;
for (int cycle = 0; cycle < maxMajorCycle; cycle++)
{
Console.WriteLine("Beginning Major cycle " + cycle);
var dirtyGrid = IDG.GridW(c, metadata, residualVis, data.UVW, data.Frequencies);
var dirtyImage = FFT.WStackIFFTFloat(dirtyGrid, c.VisibilitiesCount);
FFT.Shift(dirtyImage);
FitsIO.Write(dirtyImage, obsName + "_dirty_pcdm_majorCycle" + cycle + ".fits");
currentWatch.Restart();
totalWatch.Start();
var breakMajor = false;
var minLambda = 0.0f;
var dirtyCopy = Copy(dirtyImage);
var xCopy = Copy(xImage);
var currentLambda = 0f;
var currentObjective = 0.0;
var absMax = 0.0f;
for (int minorCycle = 0; minorCycle < maxMinorCycle; minorCycle++)
{
Console.WriteLine("Beginning Minor Cycle " + minorCycle);
var maxDirty = Residuals.GetMax(dirtyImage);
var bMap = currentGCalculator.Convolve(dirtyImage);
var maxB = Residuals.GetMax(bMap);
var correctionFactor = Math.Max(maxB / (maxDirty * maxLipschitz), 1.0f);
var currentSideLobe = maxB * maxSidelobe * correctionFactor;
currentLambda = (float)Math.Max(currentSideLobe / alpha, lambdaLipschitz);
if (minorCycle == 0)
{
minLambda = (float)(maxB * sidelobeHalf * correctionFactor / alpha);
}
if (currentLambda < minLambda)
{
currentLambda = minLambda;
}
currentObjective = Residuals.CalcPenalty(dirtyImage) + ElasticNet.CalcPenalty(xImage, lambdaTrue, alpha);
absMax = pcdm.GetAbsMax(xImage, bMap, lambdaTrue, alpha);
if (absMax < MAJOR_EPSILON)
{
breakMajor = true;
break;
}
lastResult = pcdm.Deconvolve(xImage, bMap, currentLambda, alpha, 40, deconvEpsilon);
if (currentLambda == lambda | currentLambda == minLambda)
{
break;
}
var residualsUpdate = new float[xImage.GetLength(0), xImage.GetLength(1)];
Parallel.For(0, xCopy.GetLength(0), (i) =>
{
for (int j = 0; j < xCopy.GetLength(1); j++)
{
residualsUpdate[i, j] = xImage[i, j] - xCopy[i, j];
}
});
residualsConvolver.ConvolveInPlace(residualsUpdate);
Parallel.For(0, xCopy.GetLength(0), (i) =>
{
for (int j = 0; j < xCopy.GetLength(1); j++)
{
dirtyImage[i, j] = dirtyCopy[i, j] - residualsUpdate[i, j];
}
});
}
currentWatch.Stop();
totalWatch.Stop();
if (breakMajor)
{
break;
}
if (currentLambda == lambda & !switchedToOtherPsf)
{
pcdm.ResetAMap(psf);
currentGCalculator = gCalculator2;
lambda = lambdaTrue;
switchedToOtherPsf = true;
}
FitsIO.Write(xImage, obsName + "_model_pcdm_majorCycle" + cycle + ".fits");
FFT.Shift(xImage);
var xGrid = FFT.Forward(xImage);
FFT.Shift(xImage);
var modelVis = IDG.DeGridW(c, metadata, xGrid, data.UVW, data.Frequencies);
residualVis = Visibilities.Substract(data.Visibilities, modelVis, data.Flags);
}
Console.WriteLine("Reconstruction finished in (seconds): " + totalWatch.Elapsed.TotalSeconds);
}
}
public static void DebugILGPU()
{
var frequencies = FitsIO.ReadFrequencies(@"C:\dev\GitHub\p9-data\small\fits\simulation_point\freq.fits");
var uvw = FitsIO.ReadUVW(@"C:\dev\GitHub\p9-data\small\fits\simulation_point\uvw.fits");
var flags = new bool[uvw.GetLength(0), uvw.GetLength(1), frequencies.Length]; //completely unflagged dataset
double norm = 2.0;
var visibilities = FitsIO.ReadVisibilities(@"C:\dev\GitHub\p9-data\small\fits\simulation_point\vis.fits", uvw.GetLength(0), uvw.GetLength(1), frequencies.Length, norm);
var visibilitiesCount = visibilities.Length;
int gridSize = 256;
int subgridsize = 8;
int kernelSize = 4;
int max_nr_timesteps = 1024;
double cellSize = 1.0 / 3600.0 * PI / 180.0;
var c = new GriddingConstants(visibilitiesCount, gridSize, subgridsize, kernelSize, max_nr_timesteps, (float)cellSize, 1, 0.0f);
var watchTotal = new Stopwatch();
var watchForward = new Stopwatch();
var watchBackwards = new Stopwatch();
var watchDeconv = new Stopwatch();
watchTotal.Start();
var metadata = Partitioner.CreatePartition(c, uvw, frequencies);
var psfGrid = IDG.GridPSF(c, metadata, uvw, flags, frequencies);
var psf = FFT.Backward(psfGrid, c.VisibilitiesCount);
FFT.Shift(psf);
var psfCutDouble = CutImg(psf);
var psfCut = ToFloatImage(psfCutDouble);
FitsIO.Write(psfCut, "psfCut.fits");
var totalSize = new Rectangle(0, 0, gridSize, gridSize);
var imageSection = new Rectangle(0, 128, gridSize, gridSize);
var bMapCalculator = new PaddedConvolver(PSF.CalcPaddedFourierCorrelation(psfCut, totalSize), new Rectangle(0, 0, psfCut.GetLength(0), psfCut.GetLength(1)));
var fastCD = new FastSerialCD(totalSize, psfCut);
fastCD.ResetLipschitzMap(ToFloatImage(psf));
var gpuCD = new GPUSerialCD(totalSize, psfCut, 100);
var lambda = 0.5f * fastCD.MaxLipschitz;
var alpha = 0.8f;
var xImage = new float[gridSize, gridSize];
var residualVis = visibilities;
/*var truth = new double[gridSize, gridSize];
* truth[30, 30] = 1.0;
* truth[35, 36] = 1.5;
* var truthVis = IDG.ToVisibilities(c, metadata, truth, uvw, frequencies);
* visibilities = truthVis;
* var residualVis = truthVis;*/
for (int cycle = 0; cycle < 4; cycle++)
{
//FORWARD
watchForward.Start();
var dirtyGrid = IDG.Grid(c, metadata, residualVis, uvw, frequencies);
var dirtyImage = FFT.BackwardFloat(dirtyGrid, c.VisibilitiesCount);
FFT.Shift(dirtyImage);
FitsIO.Write(dirtyImage, "dirty_" + cycle + ".fits");
watchForward.Stop();
//DECONVOLVE
watchDeconv.Start();
bMapCalculator.ConvolveInPlace(dirtyImage);
FitsIO.Write(dirtyImage, "bMap_" + cycle + ".fits");
//var result = fastCD.Deconvolve(xImage, dirtyImage, lambda, alpha, 1000, 1e-4f);
var result = gpuCD.Deconvolve(xImage, dirtyImage, lambda, alpha, 1000, 1e-4f);
if (result.Converged)
{
Console.WriteLine("-----------------------------CONVERGED!!!!------------------------");
}
else
{
Console.WriteLine("-------------------------------not converged----------------------");
}
FitsIO.Write(xImage, "xImageGreedy" + cycle + ".fits");
FitsIO.Write(dirtyImage, "residualDebug_" + cycle + ".fits");
watchDeconv.Stop();
//BACKWARDS
watchBackwards.Start();
FFT.Shift(xImage);
var xGrid = FFT.Forward(xImage);
FFT.Shift(xImage);
var modelVis = IDG.DeGrid(c, metadata, xGrid, uvw, frequencies);
residualVis = Visibilities.Substract(visibilities, modelVis, flags);
watchBackwards.Stop();
var hello = FFT.Forward(xImage, 1.0);
hello = Common.Fourier2D.Multiply(hello, psfGrid);
var hImg = FFT.Backward(hello, (double)(128 * 128));
//FFT.Shift(hImg);
FitsIO.Write(hImg, "modelDirty_FFT.fits");
var imgRec = IDG.ToImage(c, metadata, modelVis, uvw, frequencies);
FitsIO.Write(imgRec, "modelDirty" + cycle + ".fits");
}
}
public static void DebugSimulatedApprox()
{
var frequencies = FitsIO.ReadFrequencies(@"C:\dev\GitHub\p9-data\small\fits\simulation_point\freq.fits");
var uvw = FitsIO.ReadUVW(@"C:\dev\GitHub\p9-data\small\fits\simulation_point\uvw.fits");
var flags = new bool[uvw.GetLength(0), uvw.GetLength(1), frequencies.Length]; //completely unflagged dataset
double norm = 2.0;
var visibilities = FitsIO.ReadVisibilities(@"C:\dev\GitHub\p9-data\small\fits\simulation_point\vis.fits", uvw.GetLength(0), uvw.GetLength(1), frequencies.Length, norm);
var visibilitiesCount = visibilities.Length;
int gridSize = 256;
int subgridsize = 8;
int kernelSize = 4;
int max_nr_timesteps = 1024;
double cellSize = 1.0 / 3600.0 * PI / 180.0;
var c = new GriddingConstants(visibilitiesCount, gridSize, subgridsize, kernelSize, max_nr_timesteps, (float)cellSize, 1, 0.0f);
var watchTotal = new Stopwatch();
var watchForward = new Stopwatch();
var watchBackwards = new Stopwatch();
var watchDeconv = new Stopwatch();
watchTotal.Start();
var metadata = Partitioner.CreatePartition(c, uvw, frequencies);
var psfGrid = IDG.GridPSF(c, metadata, uvw, flags, frequencies);
var psf = FFT.BackwardFloat(psfGrid, c.VisibilitiesCount);
FFT.Shift(psf);
var psfCut = PSF.Cut(psf);
FitsIO.Write(psfCut, "psfCut.fits");
var random = new Random(123);
var totalSize = new Rectangle(0, 0, gridSize, gridSize);
var bMapCalculator = new PaddedConvolver(PSF.CalcPaddedFourierCorrelation(psfCut, totalSize), new Rectangle(0, 0, psfCut.GetLength(0), psfCut.GetLength(1)));
var fastCD = new FastSerialCD(totalSize, psfCut);
//fastCD.ResetAMap(psf);
var lambda = 0.5f * fastCD.MaxLipschitz;
var alpha = 0.8f;
var approx = new ApproxParallel();
var approx2 = new ApproxFast(totalSize, psfCut, 4, 8, 0f, 0.25f, false, true);
var xImage = new float[gridSize, gridSize];
var residualVis = visibilities;
/*var truth = new double[gridSize, gridSize];
* truth[30, 30] = 1.0;
* truth[35, 36] = 1.5;
* var truthVis = IDG.ToVisibilities(c, metadata, truth, uvw, frequencies);
* visibilities = truthVis;
* var residualVis = truthVis;*/
var data = new ApproxFast.TestingData(new StreamWriter("approxConvergence.txt"));
for (int cycle = 0; cycle < 4; cycle++)
{
//FORWARD
watchForward.Start();
var dirtyGrid = IDG.Grid(c, metadata, residualVis, uvw, frequencies);
var dirtyImage = FFT.BackwardFloat(dirtyGrid, c.VisibilitiesCount);
FFT.Shift(dirtyImage);
FitsIO.Write(dirtyImage, "dirty_" + cycle + ".fits");
watchForward.Stop();
//DECONVOLVE
watchDeconv.Start();
//approx.ISTAStep(xImage, dirtyImage, psf, lambda, alpha);
//FitsIO.Write(xImage, "xIsta.fits");
//FitsIO.Write(dirtyImage, "dirtyFista.fits");
//bMapCalculator.ConvolveInPlace(dirtyImage);
//FitsIO.Write(dirtyImage, "bMap_" + cycle + ".fits");
//var result = fastCD.Deconvolve(xImage, dirtyImage, 0.5f * fastCD.MaxLipschitz, 0.8f, 1000, 1e-4f);
//var converged = approx.DeconvolveActiveSet(xImage, dirtyImage, psfCut, lambda, alpha, random, 8, 1, 1);
//var converged = approx.DeconvolveGreedy(xImage, dirtyImage, psfCut, lambda, alpha, random, 4, 4, 500);
//var converged = approx.DeconvolveApprox(xImage, dirtyImage, psfCut, lambda, alpha, random, 1, threads, 500, 1e-4f, cycle == 0);
approx2.DeconvolveTest(data, cycle, 0, xImage, dirtyImage, psfCut, psf, lambda, alpha, random, 10, 1e-4f);
if (data.converged)
{
Console.WriteLine("-----------------------------CONVERGED!!!!------------------------");
}
else
{
Console.WriteLine("-------------------------------not converged----------------------");
}
FitsIO.Write(xImage, "xImageApprox_" + cycle + ".fits");
watchDeconv.Stop();
//BACKWARDS
watchBackwards.Start();
FFT.Shift(xImage);
var xGrid = FFT.Forward(xImage);
FFT.Shift(xImage);
var modelVis = IDG.DeGrid(c, metadata, xGrid, uvw, frequencies);
residualVis = Visibilities.Substract(visibilities, modelVis, flags);
watchBackwards.Stop();
}
var dirtyGridCheck = IDG.Grid(c, metadata, residualVis, uvw, frequencies);
var dirtyCheck = FFT.Backward(dirtyGridCheck, c.VisibilitiesCount);
FFT.Shift(dirtyCheck);
var l2Penalty = Residuals.CalcPenalty(ToFloatImage(dirtyCheck));
var elasticPenalty = ElasticNet.CalcPenalty(xImage, (float)lambda, (float)alpha);
var sum = l2Penalty + elasticPenalty;
data.writer.Close();
}