Example #1
0
            public static Data Load(string folder)
            {
                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 visCount2 = 0;

                for (int i = 0; i < flags.GetLength(0); i++)
                {
                    for (int j = 0; j < flags.GetLength(1); j++)
                    {
                        for (int k = 0; k < flags.GetLength(2); k++)
                        {
                            if (!flags[i, j, k])
                            {
                                visCount2++;
                            }
                        }
                    }
                }
                var visibilitiesCount = visCount2;

                var d = new Data();

                d.frequencies       = frequencies;
                d.visibilities      = visibilities;
                d.uvw               = uvw;
                d.flags             = flags;
                d.visibilitiesCount = visibilitiesCount;

                return(d);
            }
        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 LocalDataset LoadSubsetTinyMeerKAT(string folder)
        {
            var frequencies  = FitsIO.ReadFrequencies(Path.Combine(folder, "freq.fits"));
            var uvw          = FitsIO.ReadUVW(Path.Combine(folder, "uvw0.fits"));
            var flags        = FitsIO.ReadFlags(Path.Combine(folder, "flags0.fits"), uvw.GetLength(0), uvw.GetLength(1), frequencies.Length);
            var visibilities = FitsIO.ReadVisibilities(Path.Combine(folder, "vis0.fits"), uvw.GetLength(0), uvw.GetLength(1), frequencies.Length, 2.0);

            return(new LocalDataset(frequencies, uvw, flags, visibilities));
        }
        public static LocalDataset LoadSimulated(string folder)
        {
            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]; //completely unflagged dataset
            double norm         = 2.0;
            var    visibilities = FitsIO.ReadVisibilities(Path.Combine(folder, "vis.fits"), uvw.GetLength(0), uvw.GetLength(1), frequencies.Length, 2.0);

            return(new LocalDataset(frequencies, uvw, flags, visibilities));
        }
        public static MeasurementData LoadSimulatedPoints(string folder)
        {
            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);

            return(new MeasurementData(visibilities, uvw, frequencies, flags));
        }
Example #6
0
            public static Data Load(string folder)
            {
                var    frequencies  = FitsIO.ReadFrequencies(Path.Combine(folder, "freq.fits"));
                var    uvw          = FitsIO.ReadUVW(Path.Combine(folder, "uvw0.fits"));
                var    flags        = FitsIO.ReadFlags(Path.Combine(folder, "flags0.fits"), uvw.GetLength(0), uvw.GetLength(1), frequencies.Length);
                double norm         = 2.0;
                var    visibilities = FitsIO.ReadVisibilities(Path.Combine(folder, "vis0.fits"), uvw.GetLength(0), uvw.GetLength(1), frequencies.Length, norm);

                for (int i = 1; i < 8; i++)
                {
                    var uvw0          = FitsIO.ReadUVW(Path.Combine(folder, "uvw" + i + ".fits"));
                    var flags0        = FitsIO.ReadFlags(Path.Combine(folder, "flags" + i + ".fits"), uvw0.GetLength(0), uvw0.GetLength(1), frequencies.Length);
                    var visibilities0 = FitsIO.ReadVisibilities(Path.Combine(folder, "vis" + i + ".fits"), uvw0.GetLength(0), uvw0.GetLength(1), frequencies.Length, norm);
                    uvw          = FitsIO.Stitch(uvw, uvw0);
                    flags        = FitsIO.Stitch(flags, flags0);
                    visibilities = FitsIO.Stitch(visibilities, visibilities0);
                }

                var visCount2 = 0;

                for (int i = 0; i < flags.GetLength(0); i++)
                {
                    for (int j = 0; j < flags.GetLength(1); j++)
                    {
                        for (int k = 0; k < flags.GetLength(2); k++)
                        {
                            if (!flags[i, j, k])
                            {
                                visCount2++;
                            }
                        }
                    }
                }
                var visibilitiesCount = visCount2;

                var d = new Data();

                d.frequencies       = frequencies;
                d.visibilities      = visibilities;
                d.uvw               = uvw;
                d.flags             = flags;
                d.visibilitiesCount = visibilitiesCount;

                return(d);
            }
        public static MeasurementData LoadLMC(string folder)
        {
            var    frequencies  = FitsIO.ReadFrequencies(Path.Combine(folder, "freq.fits"));
            var    uvw          = FitsIO.ReadUVW(Path.Combine(folder, "uvw0.fits"));
            var    flags        = FitsIO.ReadFlags(Path.Combine(folder, "flags0.fits"), uvw.GetLength(0), uvw.GetLength(1), frequencies.Length);
            double norm         = 2.0;
            var    visibilities = FitsIO.ReadVisibilities(Path.Combine(folder, "vis0.fits"), uvw.GetLength(0), uvw.GetLength(1), frequencies.Length, norm);

            for (int i = 1; i < 8; i++)
            {
                var uvw0          = FitsIO.ReadUVW(Path.Combine(folder, "uvw" + i + ".fits"));
                var flags0        = FitsIO.ReadFlags(Path.Combine(folder, "flags" + i + ".fits"), uvw0.GetLength(0), uvw0.GetLength(1), frequencies.Length);
                var visibilities0 = FitsIO.ReadVisibilities(Path.Combine(folder, "vis" + i + ".fits"), uvw0.GetLength(0), uvw0.GetLength(1), frequencies.Length, norm);
                uvw          = FitsIO.Stitch(uvw, uvw0);
                flags        = FitsIO.Stitch(flags, flags0);
                visibilities = FitsIO.Stitch(visibilities, visibilities0);
            }

            return(new MeasurementData(visibilities, uvw, frequencies, flags));
        }
        public static LocalDataset LoadTinyMeerKAT(Intracommunicator comm, string folder)
        {
            var beginIdx = comm.Rank * 8 / comm.Size;

            var frequencies  = FitsIO.ReadFrequencies(Path.Combine(folder, "freq.fits"));
            var uvw          = FitsIO.ReadUVW(Path.Combine(folder, "uvw" + comm.Rank + ".fits"));
            var flags        = FitsIO.ReadFlags(Path.Combine(folder, "flags" + comm.Rank + ".fits"), uvw.GetLength(0), uvw.GetLength(1), frequencies.Length);
            var visibilities = FitsIO.ReadVisibilities(Path.Combine(folder, "vis" + comm.Rank + ".fits"), uvw.GetLength(0), uvw.GetLength(1), frequencies.Length, 2.0);

            for (int i = beginIdx + 1; i < beginIdx + 8 / comm.Size; i++)
            {
                var uvw0          = FitsIO.ReadUVW(Path.Combine(folder, "uvw" + i + ".fits"));
                var flags0        = FitsIO.ReadFlags(Path.Combine(folder, "flags" + i + ".fits"), uvw0.GetLength(0), uvw0.GetLength(1), frequencies.Length);
                var visibilities0 = FitsIO.ReadVisibilities(Path.Combine(folder, "vis" + i + ".fits"), uvw0.GetLength(0), uvw0.GetLength(1), frequencies.Length, 2.0);
                uvw          = FitsIO.Stitch(uvw, uvw0);
                flags        = FitsIO.Stitch(flags, flags0);
                visibilities = FitsIO.Stitch(visibilities, visibilities0);
            }

            return(new LocalDataset(frequencies, uvw, flags, visibilities));
        }
Example #9
0
        public static void Run()
        {
            //var frequencies = FitsIO.ReadFrequencies(@"C:\Users\Jon\github\p9-data\small\fits\simulation_point\freq.fits");
            //var uvw = FitsIO.ReadUVW(@"C:\Users\Jon\github\p9-data\small\fits\simulation_point\uvw.fits");
            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

            var    visibilitiesCount = flags.Length;
            int    gridSize          = 64;
            int    subgridsize       = 16;
            int    kernelSize        = 8;
            int    max_nr_timesteps  = 64;
            double cellSize          = 2.0 / 3600.0 * PI / 180.0;
            var    c = new GriddingConstants(visibilitiesCount, gridSize, subgridsize, kernelSize, max_nr_timesteps, (float)cellSize, 1, 0.0f);

            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 maxPsf = psf[gridSize / 2, gridSize / 2];

            for (int i = 0; i < psf.GetLength(0); i++)
            {
                for (int j = 0; j < psf.GetLength(1); j++)
                {
                    psf[i, j] = psf[i, j] / maxPsf;
                }
            }
            FitsIO.Write(psf, "psf.fits");

            var truth = new double[64, 64];

            //truth[40, 50] = 1.5;
            truth[0, 0] = 1.7;
            var dirty = ConvolveFFTPadded(truth, psf);

            FitsIO.Write(truth, "truth.fits");
            FitsIO.Write(dirty, "dirty.fits");

            var psf2 = ConvolveFFT(psf, psf);
            var b    = ConvolveFFTPadded(dirty, psf);
            var a    = psf2[gridSize / 2, gridSize / 2];

            /*
             * var integral = CalcPSf2Integral(psf);
             * FitsIO.Write(integral, "psfIntegral.fits");
             * var c0 = new double[64, 64];
             * var qY = 0;
             * var qX = 0;
             * c0[qY, qX] = 1.0;
             * c0 = Convolve(c0, psf);
             * FitsIO.Write(c0, "cx0.fits");
             * var cx = ConvolveFFT(c0, psf);
             * FitsIO.Write(cx, "cx1.fits");
             * var a2 = cx[qY, qX];
             * var res = QueryIntegral(integral, qY, qX);*/

            var x = new double[gridSize, gridSize];
            //Deconv(x, dirty, psf, psf2, a, 0.0);

            var dCopy = new double[gridSize, gridSize];

            for (int i = 0; i < b.GetLength(0); i++)
            {
                for (int j = 0; j < b.GetLength(1); j++)
                {
                    dCopy[i, j] = dirty[i, j];
                }
            }
            var x2        = new double[gridSize, gridSize];
            var converged = GreedyCD.Deconvolve2(x2, dirty, psf, 0.0, 1.0, 500, dCopy);
        }
        public static LocalDataset LoadTinyMeerKAT2(int rank, int nodeCount, string folder)
        {
            var blSum        = 0;
            var blFileScans  = new int[8];
            var blFileCounts = new int[8];

            for (int i = 0; i < 8; i++)
            {
                blFileCounts[i] = FitsIO.CountBaselines(Path.Combine(folder, "uvw" + i + ".fits"));
                blSum          += blFileCounts[i];
                blFileScans[i]  = blSum;
            }

            var frequencies   = FitsIO.ReadFrequencies(Path.Combine(folder, "freq.fits"));
            var blBeginIdx    = rank * (int)(blSum / (double)nodeCount);
            var blEndIdx      = rank + 1 < nodeCount ? (rank + 1) * (int)(blSum / (double)nodeCount) : blSum;
            var baselineCount = blEndIdx - blBeginIdx;

            LocalDataset output = null;

            for (int i = 0; i < 8; i++)
            {
                if (blBeginIdx < blFileScans[i])
                {
                    var blBefore     = i > 0 ? blFileScans[i - 1] : 0;
                    var start        = blBeginIdx - blBefore;
                    var end          = Math.Min(start + baselineCount, blFileCounts[i]);
                    var uvw          = FitsIO.ReadUVW(Path.Combine(folder, "uvw" + i + ".fits"), start, end);
                    var flags        = FitsIO.ReadFlags(Path.Combine(folder, "flags" + i + ".fits"), start, end, uvw.GetLength(1), frequencies.Length);
                    var visibilities = FitsIO.ReadVisibilities(Path.Combine(folder, "vis" + i + ".fits"), start, end, uvw.GetLength(1), frequencies.Length, 2.0);

                    if (blBeginIdx + baselineCount > blFileCounts[i])
                    {
                        //continue reading files until all baselines, which belong to the current node, are loaded
                        var baselinesLoaded = end - start;
                        for (int j = i + 1; j < 8; j++)
                        {
                            var end2          = Math.Min(baselineCount - baselinesLoaded, blFileCounts[j]);
                            var uvw0          = FitsIO.ReadUVW(Path.Combine(folder, "uvw" + j + ".fits"), 0, end2);
                            var flags0        = FitsIO.ReadFlags(Path.Combine(folder, "flags" + j + ".fits"), 0, end2, uvw.GetLength(1), frequencies.Length);
                            var visibilities0 = FitsIO.ReadVisibilities(Path.Combine(folder, "vis" + j + ".fits"), 0, end2, uvw.GetLength(1), frequencies.Length, 2.0);

                            uvw              = FitsIO.Stitch(uvw, uvw0);
                            flags            = FitsIO.Stitch(flags, flags0);
                            visibilities     = FitsIO.Stitch(visibilities, visibilities0);
                            baselinesLoaded += end2;
                            if (baselinesLoaded >= baselineCount)
                            {
                                //last file read;
                                break;
                            }
                        }
                    }

                    output = new LocalDataset(frequencies, uvw, flags, visibilities);
                    break;
                }
            }

            return(output);
        }