Feature/112 reconfigure the detectors to use global code for the binary serializers 2

src/Vts.Test/MonteCarlo/Factories/DetectorFactoryTests.cs

@@ -299,43 +299,17 @@ public void Normalize(long numPhotons)
             // this is to allow saving of large arrays separately as a binary file
             public BinaryArraySerializer[] GetBinarySerializers()
             {
-                return new[] {
-                new BinaryArraySerializer {
-                    DataArray = Mean,
-                    Name = "Mean",
-                    FileTag = "",
-                    WriteData = binaryWriter => {
-                        for (var i = 0; i < X.Count - 1; i++) {
-                            binaryWriter.Write(Mean[i]);
-                        }
-                    },
-                    ReadData = binaryReader => {
-                        Mean ??= new double[ X.Count - 1];
-                        for (var i = 0; i <  X.Count - 1; i++) {
-                            Mean[i] = binaryReader.ReadDouble();
-                        }
-                    }
-                },
-                // return a null serializer, if we're not serializing the second moment
-                !TallySecondMoment ? null :  new BinaryArraySerializer {
-                    DataArray = SecondMoment,
-                    Name = "SecondMoment",
-                    FileTag = "_2",
-                    WriteData = binaryWriter => {
-                        if (!TallySecondMoment || SecondMoment == null) return;
-                        for (var i = 0; i < X.Count - 1; i++) {
-                            binaryWriter.Write(SecondMoment[i]);
-                        }
-                    },
-                    ReadData = binaryReader => {
-                        if (!TallySecondMoment || SecondMoment == null) return;
-                        SecondMoment = new double[ X.Count - 1];
-                        for (var i = 0; i < X.Count - 1; i++) {
-                            SecondMoment[i] = binaryReader.ReadDouble();
-                        }
-                    },
-                },
-            };
+                Mean ??= new double[X.Count - 1];
+                SecondMoment ??= new double[X.Count - 1];
+                var allSerializers = new List<BinaryArraySerializer>
+                {
+                    BinaryArraySerializerFactory.GetSerializer(
+                        Mean, "Mean", ""),
+                    TallySecondMoment ? BinaryArraySerializerFactory.GetSerializer(
+                        SecondMoment, "SecondMoment", "_2") : null,
+                };
+                return allSerializers.Where(s => s is not null).ToArray();
+
             }
 
             /// <summary>

src/Vts.Test/Unit/MonteCarlo/Detectors/AOfRhoAndZDetectorTests.cs

@@ -0,0 +1,59 @@
+using NUnit.Framework;
+using System.IO;
+using System.Reflection;
+using Vts.Common;
+using Vts.IO;
+using Vts.MonteCarlo.Detectors;
+
+namespace Vts.Test.Unit.MonteCarlo.Detectors;
+
+[TestFixture]
+public class AOfRhoAndZDetectorTests
+{
+    /// <summary>
+    /// clear all test generated files
+    /// </summary>
+    [OneTimeSetUp]
+    [OneTimeTearDown]
+    public void Clear_previously_generated_files()
+    {
+        var currentPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+        FolderCleanup.DeleteFileContaining(currentPath, "testaofrhoandz");
+    }
+
+    /// <summary>
+    /// Test to verify that GetBinarySerializers are working correctly for this detector.
+    /// </summary>
+    [Test]
+    [TestCase(true)]
+    [TestCase(false)]
+    public void Validate_deserialized_binary_arrays_are_correct_when_using_GetBinarySerializers(bool tallySecondMoment)
+    {
+        const string detectorName = "testaofrhoandz";
+        var detector = new AOfRhoAndZDetector
+        {
+            Rho = new DoubleRange(0, 10, 3),
+            Z = new DoubleRange(0, 1, 4),
+            TallySecondMoment = tallySecondMoment,
+            Name = detectorName,
+            Mean = new double[,] { { 1, 2, 3 }, { 4, 5, 6 } },
+            SecondMoment = new double[,] { { 7, 8, 9 }, { 10, 11, 12 } }
+        };
+
+        DetectorBinarySerializationHelper.WriteClearAndReReadArrays(detector, detector.Mean, detector.SecondMoment);
+
+        Assert.AreEqual(1, detector.Mean[0, 0]);
+        Assert.AreEqual(2, detector.Mean[0, 1]);
+        Assert.AreEqual(3, detector.Mean[0, 2]);
+        Assert.AreEqual(4, detector.Mean[1, 0]);
+        Assert.AreEqual(5, detector.Mean[1, 1]);
+        Assert.AreEqual(6, detector.Mean[1, 2]);
+        if (!tallySecondMoment) return;
+        Assert.AreEqual(7, detector.SecondMoment[0, 0]);
+        Assert.AreEqual(8, detector.SecondMoment[0, 1]);
+        Assert.AreEqual(9, detector.SecondMoment[0, 2]);
+        Assert.AreEqual(10, detector.SecondMoment[1, 0]);
+        Assert.AreEqual(11, detector.SecondMoment[1, 1]);
+        Assert.AreEqual(12, detector.SecondMoment[1, 2]);
+    }
+}

src/Vts.Test/Unit/MonteCarlo/Detectors/AOfXAndYAndZDetectorTests.cs

@@ -0,0 +1,72 @@
+using NUnit.Framework;
+using System.IO;
+using System.Reflection;
+using Vts.Common;
+using Vts.IO;
+using Vts.MonteCarlo.Detectors;
+
+namespace Vts.Test.Unit.MonteCarlo.Detectors;
+
+[TestFixture]
+public class AOfXAndYAndZDetectorTests
+{
+    /// <summary>
+    /// clear all test generated files
+    /// </summary>
+    [OneTimeSetUp]
+    [OneTimeTearDown]
+    public void Clear_previously_generated_files()
+    {
+        var currentPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+        FolderCleanup.DeleteFileContaining(currentPath, "testaofxandyandz");
+    }
+
+    /// <summary>
+    /// Test to verify that GetBinarySerializers are working correctly for this detector.
+    /// </summary>
+    [Test]
+    [TestCase(true)]
+    [TestCase(false)]
+    public void Validate_deserialized_binary_arrays_are_correct_when_using_GetBinarySerializers(bool tallySecondMoment)
+    {
+        const string detectorName = "testaofxandyandz";
+        var detector = new AOfXAndYAndZDetector
+        {
+            X = new DoubleRange(-10, 10, 3),
+            Y = new DoubleRange(-10, 10, 3),
+            Z = new DoubleRange(0, 1, 4),
+            TallySecondMoment = tallySecondMoment,
+            Name = detectorName,
+            Mean = new double[,,] { { { 1, 2, 3 }, { 4, 5, 6 } }, { { 7, 8, 9 }, { 10, 11, 12 } } },
+            SecondMoment = new double[,,] { { { 13, 14, 15 }, { 16, 17, 18 } }, { { 19, 20, 21 }, { 22, 23, 24 } } }
+        };
+
+        DetectorBinarySerializationHelper.WriteClearAndReReadArrays(detector, detector.Mean, detector.SecondMoment);
+
+        Assert.AreEqual(1, detector.Mean[0, 0, 0]);
+        Assert.AreEqual(2, detector.Mean[0, 0, 1]);
+        Assert.AreEqual(3, detector.Mean[0, 0, 2]);
+        Assert.AreEqual(4, detector.Mean[0, 1, 0]);
+        Assert.AreEqual(5, detector.Mean[0, 1, 1]);
+        Assert.AreEqual(6, detector.Mean[0, 1, 2]);
+        Assert.AreEqual(7, detector.Mean[1, 0, 0]);
+        Assert.AreEqual(8, detector.Mean[1, 0, 1]);
+        Assert.AreEqual(9, detector.Mean[1, 0, 2]);
+        Assert.AreEqual(10, detector.Mean[1, 1, 0]);
+        Assert.AreEqual(11, detector.Mean[1, 1, 1]);
+        Assert.AreEqual(12, detector.Mean[1, 1, 2]);
+        if (!tallySecondMoment) return;
+        Assert.AreEqual(13, detector.SecondMoment[0, 0, 0]);
+        Assert.AreEqual(14, detector.SecondMoment[0, 0, 1]);
+        Assert.AreEqual(15, detector.SecondMoment[0, 0, 2]);
+        Assert.AreEqual(16, detector.SecondMoment[0, 1, 0]);
+        Assert.AreEqual(17, detector.SecondMoment[0, 1, 1]);
+        Assert.AreEqual(18, detector.SecondMoment[0, 1, 2]);
+        Assert.AreEqual(19, detector.SecondMoment[1, 0, 0]);
+        Assert.AreEqual(20, detector.SecondMoment[1, 0, 1]);
+        Assert.AreEqual(21, detector.SecondMoment[1, 0, 2]);
+        Assert.AreEqual(22, detector.SecondMoment[1, 1, 0]);
+        Assert.AreEqual(23, detector.SecondMoment[1, 1, 1]);
+        Assert.AreEqual(24, detector.SecondMoment[1, 1, 2]);
+    }
+}

src/Vts.Test/Unit/MonteCarlo/Detectors/ATotalBoundingVolumeDetectorTests.cs

@@ -0,0 +1,44 @@
+using NUnit.Framework;
+using System;
+using System.IO;
+using System.Reflection;
+using Vts.IO;
+using Vts.MonteCarlo.Detectors;
+
+namespace Vts.Test.Unit.MonteCarlo.Detectors;
+
+[TestFixture]
+public class ATotalBoundingVolumeDetectorTests
+{
+    /// <summary>
+    /// clear all test generated files
+    /// </summary>
+    [OneTimeSetUp]
+    [OneTimeTearDown]
+    public void Clear_previously_generated_files()
+    {
+        var currentPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+        FolderCleanup.DeleteFileContaining(currentPath, "testatotalboundingvolume");
+    }
+
+    /// <summary>
+    /// Test to verify that GetBinarySerializers are working correctly for this detector.
+    /// </summary>
+    [Test]
+    [TestCase(true)]
+    [TestCase(false)]
+    public void Validate_deserialized_binary_arrays_are_correct_when_using_GetBinarySerializers(bool tallySecondMoment)
+    {
+        const string detectorName = "testatotalboundingvolume";
+        var detector = new ATotalBoundingVolumeDetector
+        {
+            TallySecondMoment = tallySecondMoment,
+            Name = detectorName,
+            Mean = new double(),
+            SecondMoment = new double()
+        };
+
+        var serializers = detector.GetBinarySerializers();
+        Assert.AreEqual(Array.Empty<BinaryArraySerializer>(), serializers);
+    }
+}

src/Vts.Test/Unit/MonteCarlo/Detectors/ATotalDetectorTests.cs

@@ -0,0 +1,44 @@
+using NUnit.Framework;
+using System;
+using System.IO;
+using System.Reflection;
+using Vts.IO;
+using Vts.MonteCarlo.Detectors;
+
+namespace Vts.Test.Unit.MonteCarlo.Detectors;
+
+[TestFixture]
+public class ATotalDetectorTests
+{
+    /// <summary>
+    /// clear all test generated files
+    /// </summary>
+    [OneTimeSetUp]
+    [OneTimeTearDown]
+    public void Clear_previously_generated_files()
+    {
+        var currentPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+        FolderCleanup.DeleteFileContaining(currentPath, "testatotal");
+    }
+
+    /// <summary>
+    /// Test to verify that GetBinarySerializers are working correctly for this detector.
+    /// </summary>
+    [Test]
+    [TestCase(true)]
+    [TestCase(false)]
+    public void Validate_deserialized_binary_arrays_are_correct_when_using_GetBinarySerializers(bool tallySecondMoment)
+    {
+        const string detectorName = "testatotal";
+        var detector = new ATotalDetector
+        {
+            TallySecondMoment = tallySecondMoment,
+            Name = detectorName,
+            Mean = new double(),
+            SecondMoment = new double()
+        };
+
+        var serializers = detector.GetBinarySerializers();
+        Assert.AreEqual(Array.Empty<BinaryArraySerializer>(), serializers);
+    }
+}

src/Vts.Test/Unit/MonteCarlo/Detectors/DetectorBinarySerializationHelper.cs

@@ -0,0 +1,38 @@
+using System;
+using System.IO;
+using Vts.MonteCarlo;
+
+namespace Vts.Test.Unit.MonteCarlo.Detectors
+{
+    internal static class DetectorBinarySerializationHelper
+    {
+        /// <summary>
+        /// detector input abstract class
+        /// </summary>
+        /// <param name="detector">IDetector being serialized</param>
+        /// <param name="arrays">arrays to be serialized (e.g. Mean, SecondMoment, etc.)</param>
+        internal static void WriteClearAndReReadArrays(IDetector detector, params Array[] arrays)
+        {
+            var serializers = detector.GetBinarySerializers();
+            using var stream = new MemoryStream();
+            using var writer = new BinaryWriter(stream);
+            foreach (var serializer in serializers)
+            {
+                serializer.WriteData(writer);
+            }
+
+            foreach (var array in arrays)
+            {
+                Array.Clear(array);
+            }
+
+            stream.Seek(0, SeekOrigin.Begin);
+
+            using var reader = new BinaryReader(stream);
+            foreach (var serializer in serializers)
+            {
+                serializer.ReadData(reader);
+            }
+        }
+    }
+}

src/Vts.Test/Unit/MonteCarlo/Detectors/FluenceOfFxAndZDetectorTests.cs

@@ -0,0 +1,68 @@
+using NUnit.Framework;
+using System.IO;
+using System.Numerics;
+using System.Reflection;
+using Vts.Common;
+using Vts.IO;
+using Vts.MonteCarlo.Detectors;
+
+namespace Vts.Test.Unit.MonteCarlo.Detectors;
+
+[TestFixture]
+public class FluenceOfFxAndZDetectorTests
+{
+    /// <summary>
+    /// clear all test generated files
+    /// </summary>
+    [OneTimeSetUp]
+    [OneTimeTearDown]
+    public void Clear_previously_generated_files()
+    {
+        var currentPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+        FolderCleanup.DeleteFileContaining(currentPath, "testfluenceoffxandz");
+    }
+
+    /// <summary>
+    /// Test to verify that GetBinarySerializers are working correctly for this detector.
+    /// </summary>
+    [Test]
+    [TestCase(true)]
+    [TestCase(false)]
+    public void Validate_deserialized_binary_arrays_are_correct_when_using_GetBinarySerializers(bool tallySecondMoment)
+    {
+        const string detectorName = "testfluenceoffxandz";
+        var detector = new FluenceOfFxAndZDetector
+        {
+            Fx = new DoubleRange(0, 10, 3),
+            Z = new DoubleRange(0, 1, 4),
+            TallySecondMoment = tallySecondMoment,
+            Name = detectorName,
+            Mean = new[,]
+            {
+                { 1 + Complex.ImaginaryOne, 2 + 2 * Complex.ImaginaryOne, 3 + 3 * Complex.ImaginaryOne },
+                { 4 + 4 * Complex.ImaginaryOne, 5 + 5 * Complex.ImaginaryOne, 6 + 6 * Complex.ImaginaryOne }
+            },
+            SecondMoment = new[,]
+            {
+                { 7 + 7 * Complex.ImaginaryOne, 8 + 8 * Complex.ImaginaryOne, 9 + 9 * Complex.ImaginaryOne },
+                { 10 + 10 * Complex.ImaginaryOne, 11 + 11 * Complex.ImaginaryOne, 12 + 12 * Complex.ImaginaryOne }
+            }
+        };
+
+        DetectorBinarySerializationHelper.WriteClearAndReReadArrays(detector, detector.Mean, detector.SecondMoment);
+
+        Assert.AreEqual(1 + Complex.ImaginaryOne, detector.Mean[0, 0]);
+        Assert.AreEqual(2 + 2 * Complex.ImaginaryOne, detector.Mean[0, 1]);
+        Assert.AreEqual(3 + 3 * Complex.ImaginaryOne, detector.Mean[0, 2]);
+        Assert.AreEqual(4 + 4 * Complex.ImaginaryOne, detector.Mean[1, 0]);
+        Assert.AreEqual(5 + 5 * Complex.ImaginaryOne, detector.Mean[1, 1]);
+        Assert.AreEqual(6 + 6 * Complex.ImaginaryOne, detector.Mean[1, 2]);
+        if (!tallySecondMoment) return;
+        Assert.AreEqual(7 + 7 * Complex.ImaginaryOne, detector.SecondMoment[0, 0]);
+        Assert.AreEqual(8 + 8 * Complex.ImaginaryOne, detector.SecondMoment[0, 1]);
+        Assert.AreEqual(9 + 9 * Complex.ImaginaryOne, detector.SecondMoment[0, 2]);
+        Assert.AreEqual(10 + 10 * Complex.ImaginaryOne, detector.SecondMoment[1, 0]);
+        Assert.AreEqual(11 + 11 * Complex.ImaginaryOne, detector.SecondMoment[1, 1]);
+        Assert.AreEqual(12 + 12 * Complex.ImaginaryOne, detector.SecondMoment[1, 2]);
+    }
+}