Ch 210312 raytrace mc

src/Vts.MonteCarlo.CommandLineApplication.Test/ProgramTests.cs

@@ -35,7 +35,8 @@ public class ProgramTests
             "two_layer_ROfRho",
             "two_layer_ROfRho_TOfRho_with_databases",
             "voxel_ROfXAndY_FluenceOfXAndYAndZ",
-            "surface_fiber_detector"
+            "surface_fiber_detector",
+            "ray_database_generator"
         };
         private readonly List<string> _listOfInfilesThatRequireExistingResultsToRun = new List<string>()
         {

src/Vts.MonteCarlo.PostProcessor.Test/ProgramTests.cs

@@ -42,7 +42,8 @@ public class ProgramTests
             "two_layer_ROfRho",
             "two_layer_ROfRho_TOfRho_with_databases",
             "voxel_ROfXAndY_FluenceOfXAndYAndZ",
-            "surface_fiber_detector"
+            "surface_fiber_detector",
+            "ray_database_generator"
         };
 
         /// <summary>

src/Vts.MonteCarlo.ZemaxDatabaseConverter.Test/ProgramTests.cs

@@ -0,0 +1,165 @@
+using NUnit.Framework;
+using System.Collections.Generic;
+using System;
+using Vts.IO;
+using Vts.MonteCarlo.RayData;
+using System.Threading.Tasks;
+using System.IO;
+using System.Reflection;
+
+namespace Vts.MonteCarlo.ZemaxDatabaseConverter.Test
+{
+    [TestFixture]
+    public class ProgramTests
+    {
+        // This tests code that would be executed to convert ZRD DB to/from MCCL compatible DB
+        // An actual Zemax output ZRD file was first used to verify tests, however file too large
+        // to add to resources.  Instead this program is used to convert a MCCL DB to Zemax DB
+        // and that is used to test
+
+        /// <summary>
+        /// list of temporary files created by these unit tests
+        /// </summary>
+        readonly List<string> listOfTestGeneratedFiles = new List<string>()
+        {
+            "testzrdraydatabase",
+            "testzrdraydatabase.txt",
+            "testmcclraydatabase",
+            "testmcclraydatabase.txt",
+         };
+        readonly List<string> listOfTestGeneratedFolders = new List<string>()
+        {
+            "mcclraydatabase",
+            "zrdraydatabase"
+        };
+
+
+        /// <summary>
+        /// Set up simulation specifying RayDatabase to be written
+        /// </summary>
+        [OneTimeSetUp]
+        public void Setup_simulation_input_components()
+        {
+            // delete previously generated files
+            Clear_folders_and_files();
+        }
+
+        /// <summary>
+        /// clear all previously generated files.
+        /// </summary>
+        [OneTimeTearDown]
+        public void Clear_folders_and_files()
+        {
+            // delete any previously generated files
+            foreach (var file in listOfTestGeneratedFiles)
+            {
+                if (File.Exists(file))
+                {
+                    FileIO.FileDelete(file);
+                }
+            }
+            // delete any previously generated folders
+            foreach (var folder in listOfTestGeneratedFolders)
+            {
+                if (Directory.Exists(folder))
+                {
+                    FileIO.DeleteDirectory(folder);
+                }
+            }
+
+        }
+        /// <summary>
+        /// Test to verify sanity check on input works correctly
+        /// </summary>
+        [Test]
+        public async Task Validate_VerifyInputs_method_returns_correct_values()
+        {
+            // the following will fail because only 1 argument and file does not exist
+            string[] arguments = new string[] { "infile=databaseToConvert" };
+            var status = await Task.Run(() => Program.Main(arguments));
+            Assert.IsTrue(status == 1);
+            // no successful mccl-to-zrd test is tested here because tested in other tests
+        }
+        /// <summary>
+        /// Test that uses app to convert RayDatabase written in OneTimeSetup to a Zemax ZRD ray database
+        /// Validation values used from prior test
+        /// </summary>
+        [Test]
+        public async Task Validate_conversion_from_MCCL_RayDatabase_to_Zemax_ZrdDatabase_successful()
+        {
+            // copy MCCL RayDatabase from Resources
+            var folder = "mcclraydatabase";
+            FileIO.CopyFolderFromEmbeddedResources(folder, "",
+                    Assembly.GetExecutingAssembly().FullName, true);
+            // run database converter on MCCL Ray Database generated in OneTimeSetup
+            var arguments = new string[] {
+                "infile=mcclraydatabase/RayDiffuseReflectanceDatabase",
+                "infiletype=mccl",
+                "outfile=testzrdraydatabase" };
+            await Task.Run(() => Program.Main(arguments));
+            // read file written
+            var rayDatabase = Zemax.ZrdRayDatabase.FromFile("testzrdraydatabase");
+            Assert.AreEqual(88, rayDatabase.NumberOfElements);
+
+            // manually enumerate through the first element
+            var enumerator = rayDatabase.DataPoints.GetEnumerator();
+            // advance to the first point and test that the point is valid
+            enumerator.MoveNext();
+            var dp1 = enumerator.Current;
+            Assert.IsTrue(Math.Abs(dp1.X - 4.18911) < 1e-5);
+            Assert.IsTrue(Math.Abs(dp1.Y + 22.1217) < 1e-4);
+            Assert.IsTrue(Math.Abs(dp1.Z - 0.0) < 1e-6);
+            Assert.IsTrue(Math.Abs(dp1.Ux - 0.654227) < 1e-6);
+            Assert.IsTrue(Math.Abs(dp1.Uy - 0.223239) < 1e-6);
+            Assert.IsTrue(Math.Abs(dp1.Uz + 0.722600) < 1e-6); // negative because exiting
+            Assert.IsTrue(Math.Abs(dp1.Weight - 0.021116) < 1e-6);
+            // advance to the second point and test that the point is valid
+            enumerator.MoveNext();
+            var dp2 = enumerator.Current;
+            Assert.IsTrue(Math.Abs(dp2.X - 0.382333) < 1e-6);
+            Assert.IsTrue(Math.Abs(dp2.Y + 2.13952) < 1e-5);
+            Assert.IsTrue(Math.Abs(dp2.Z - 0.0) < 1e-6);
+            Assert.IsTrue(Math.Abs(dp2.Ux + 0.711575) < 1e-6);
+            Assert.IsTrue(Math.Abs(dp2.Uy + 0.493464) < 1e-6);
+            Assert.IsTrue(Math.Abs(dp2.Uz + 0.500153) < 1e-6);
+            Assert.IsTrue(Math.Abs(dp2.Weight - 0.911520) < 1e-6);
+            enumerator.Dispose();
+        }
+        /// <summary>
+        /// test to verify reading actual Zemax ZRD file on hold until we can generate
+        /// a small one ourselves.  In the meantime, convert MCCL Ray Database generated
+        /// in OneTimeSetup and then convert back to ZRD formatted database
+        /// </summary>
+        [Test]
+        public async Task Validate_conversion_from_Zemax_ZrdDatabase_to_MCCL_RayDatabase_successful()
+        {
+            //actual ZRD DB is in @"C:\Users\hayakawa\Desktop\RP\Zemax\ZWOutput\lightfromsourcefile"
+            // copy ZRD RayDatabase from Resources
+            var folder = "zrdraydatabase";
+            FileIO.CopyFolderFromEmbeddedResources(folder, "",
+                    Assembly.GetExecutingAssembly().FullName, true);
+            // use actual zrd database and convert to mccl database
+            var arguments = new string[] {
+                "infile=zrdraydatabase/Lightfromsourcefile", 
+                "infiletype=zrd", 
+                "outfile=testmcclraydatabase" };
+            await Task.Run(() => Program.Main(arguments));           
+            var rayDatabase = RayDatabase.FromFile("testmcclraydatabase");
+            Assert.AreEqual(10, rayDatabase.NumberOfElements);
+            var enumerator = rayDatabase.DataPoints.GetEnumerator();
+            // advance to the first point and test that the point is valid
+            enumerator.MoveNext();
+            var dp1 = enumerator.Current;
+            Assert.IsTrue(Math.Abs(dp1.Position.X - 0.003760) < 1e-6);
+            Assert.IsTrue(Math.Abs(dp1.Position.Y - 0.001500) < 1e-6);
+            Assert.IsTrue(Math.Abs(dp1.Position.Z - 0.490243) < 1e-6);
+            Assert.IsTrue(Math.Abs(dp1.Direction.Ux - 0.005315) < 1e-6);
+            Assert.IsTrue(Math.Abs(dp1.Direction.Uy - 0.992280) < 1e-6);
+            Assert.IsTrue(Math.Abs(dp1.Direction.Uz - 0.123897) < 1e-6); // why is this neg?
+            Assert.IsTrue(Math.Abs(dp1.Weight - 0.000730) < 1e-6);
+            enumerator.Dispose();
+        }
+
+
+    }
+}

src/Vts.MonteCarlo.ZemaxDatabaseConverter.Test/Resources/mcclraydatabase/RayDiffuseReflectanceDatabase.txt

@@ -0,0 +1,3 @@
+{
+  "NumberOfElements": 88
+}

src/Vts.MonteCarlo.ZemaxDatabaseConverter.Test/Resources/zrdraydatabase/Lightfromsourcefile.txt

@@ -0,0 +1,3 @@
+{
+ "NumberOfElements": 10
+}

src/Vts.MonteCarlo.ZemaxDatabaseConverter.Test/Vts.MonteCarlo.ZemaxDatabaseConverter.Test.csproj

@@ -0,0 +1,38 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Remove="Resources\RayDiffuseReflectanceDatabase" />
+    <None Remove="Resources\RayDiffuseReflectanceDatabase.txt" />
+    <None Remove="Resources\zrdraydatabase\Lightfromsourcefile" />
+    <None Remove="Resources\zrdraydatabase\Lightfromsourcefile.txt" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <EmbeddedResource Include="Resources\mcclraydatabase\RayDiffuseReflectanceDatabase" />
+    <EmbeddedResource Include="Resources\mcclraydatabase\RayDiffuseReflectanceDatabase.txt" />
+    <EmbeddedResource Include="Resources\zrdraydatabase\Lightfromsourcefile" />
+    <EmbeddedResource Include="Resources\zrdraydatabase\Lightfromsourcefile.txt" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.1" />
+    <PackageReference Include="nunit" Version="3.13.3" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.2.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Vts.MonteCarlo.ZemaxDatabaseConverter\Vts.MonteCarlo.ZemaxDatabaseConverter.csproj" />
+    <ProjectReference Include="..\Vts\Vts.csproj" />
+	<ProjectReference Include="..\Vts.Zemax\Vts.Zemax.csproj" />
+  </ItemGroup>
+
+</Project>

src/Vts.MonteCarlo.ZemaxDatabaseConverter/DatabaseConverter.cs

@@ -0,0 +1,130 @@
+using System;
+using System.IO;
+using Vts.Common;
+using Vts.MonteCarlo.RayData;
+using Vts.Zemax;
+
+namespace Vts.MonteCarlo.ZemaxDatabaseConverter
+{
+    public static class DatabaseConverter
+    {
+        /// <summary>
+        /// method to verify input arguments
+        /// </summary>
+        /// <param name="inputFile">Database to be converted</param>
+        /// <param name="outputFile">Converted database</param>
+        /// <returns>Boolean indicating inputs are valid</returns>
+        public static bool VerifyInputs(string inputFile, string outputFile)
+        {
+            try
+            {
+                if (string.IsNullOrEmpty(inputFile))
+                {
+                    Console.WriteLine("\nNo input database file specified");
+                    return false;
+                }
+
+                if (!string.IsNullOrEmpty(outputFile)) return true;
+                Console.WriteLine("\nNo output database file specified");
+                return false;
+            }
+            catch (Exception e)
+            {
+                Console.WriteLine(e.Message);
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// method to convert Zemax ray database to MCCL source database
+        /// </summary>
+        /// <param name="inputFile">Database to be converted</param>
+        /// <param name="outputFile">Converted database</param>
+        public static void ConvertZemaxDatabaseToMcclSourceDatabase(string inputFile, string outputFile)
+        {
+            try
+            {
+                //get the full path for the input file
+                var fullFilePath = Path.GetFullPath(inputFile);
+
+                var fileToConvert = ZrdRayDatabase.FromFile(fullFilePath);
+
+                // enumerate through the elements 
+                var enumerator = fileToConvert.DataPoints.GetEnumerator();
+
+                using (var dbWriter = new RayDatabaseWriter(
+                    VirtualBoundaryType.DiffuseReflectance, outputFile))
+                {
+                    for (var i = 0; i < fileToConvert.NumberOfElements; i++)
+                    {
+                        // advance to the next ray data
+                        enumerator.MoveNext();
+                        var dp = enumerator.Current;
+                        // excise Position,Direction,Weight from Zemax struct
+                        if (dp != null)
+                        {
+                            dbWriter.Write(new RayDataPoint(
+                                new Position(dp.X, dp.Y, dp.Z),
+                                new Direction(dp.Ux, dp.Uy, dp.Uz),
+                                dp.Weight));
+                        }
+                    }
+                    dbWriter.Close();
+                }
+                enumerator.Dispose();
+            }
+            catch (Exception e)
+            {
+                Console.WriteLine(e.Message);
+            }
+        }
+        /// <summary>
+        /// method to convert zemax ray database to MCCL source database
+        /// </summary>
+        /// <param name="inputFile">Database to be converted</param>
+        /// <param name="outputFile">Converted database</param>
+        public static void ConvertMcclDatabaseToZemaxSourceDatabase(string inputFile, string outputFile)
+        {
+            try
+            {
+                //get the full path for the input file
+                var fullFilePath = Path.GetFullPath(inputFile);
+
+                var fileToConvert = RayDatabase.FromFile(fullFilePath);
+
+                // enumerate through the elements 
+                var enumerator = fileToConvert.DataPoints.GetEnumerator();
+
+                using (var dbWriter = new ZrdRayDatabaseWriter(
+                    VirtualBoundaryType.DiffuseReflectance, outputFile))
+                {
+                    for (var i = 0; i < fileToConvert.NumberOfElements; i++)
+                    {
+                        // advance to the next ray data
+                        enumerator.MoveNext();
+                        var dp = enumerator.Current;
+                        if (dp == null) continue;
+                        var zrdRayDataPoint = new ZrdRayDataPoint
+                        {
+                            // set Position,Direction,Weight in Zemax struct
+                            X = dp.Position.X,
+                            Y = dp.Position.Y,
+                            Z = dp.Position.Z,
+                            Ux = dp.Direction.Ux,
+                            Uy = dp.Direction.Uy,
+                            Uz = dp.Direction.Uz,
+                            Weight = dp.Weight
+                        };
+                        dbWriter.Write(zrdRayDataPoint);
+                    }
+                    dbWriter.Close();
+                }
+                enumerator.Dispose();
+            }
+            catch (Exception e)
+            {
+                Console.WriteLine(e.Message);
+            }
+        }
+    }
+}