Add optical model importer and refactor imported optical materials

src/celeritas/CMakeLists.txt

@@ -81,8 +81,10 @@ list(APPEND SOURCES
   optical/CoreState.cc
   optical/CoreTrackData.cc
   optical/ImportedModelAdapter.cc
+  optical/ImportedMaterials.cc
   optical/OpticalCollector.cc
   optical/MaterialParams.cc
+  optical/ModelImporter.cc
   optical/TrackInitParams.cc
   optical/ScintillationParams.cc
   optical/WavelengthShiftParams.cc

src/celeritas/optical/ImportedMaterials.cc

@@ -0,0 +1,100 @@
+//------------------------------- -*- C++ -*- -------------------------------//
+// Copyright Celeritas contributors: see top-level COPYRIGHT file for details
+// SPDX-License-Identifier: (Apache-2.0 OR MIT)
+//---------------------------------------------------------------------------//
+//! \file celeritas/optical/ImportedMaterials.cc
+//---------------------------------------------------------------------------//
+#include "ImportedMaterials.hh"
+
+#include <algorithm>
+
+#include "celeritas/io/ImportData.hh"
+#include "celeritas/io/ImportOpticalMaterial.hh"
+
+namespace celeritas
+{
+namespace optical
+{
+//---------------------------------------------------------------------------//
+/*!
+ * Construct from imported and shared data.
+ */
+std::shared_ptr<ImportedMaterials>
+ImportedMaterials::from_import(ImportData const& data)
+{
+    // If there's no material specific parameters, return a nullptr
+    if (!std::any_of(data.optical_materials.begin(),
+                     data.optical_materials.end(),
+                     [](auto const& mat) { return mat.rayleigh || mat.wls; }))
+    {
+        return nullptr;
+    }
+
+    OpticalMaterialId::size_type num_materials = data.optical_materials.size();
+
+    // Copy over Rayleigh and WLS data
+
+    std::vector<ImportOpticalRayleigh> rayleigh;
+    rayleigh.reserve(num_materials);
+
+    std::vector<ImportWavelengthShift> wls;
+    wls.reserve(num_materials);
+
+    for (auto const& mat : data.optical_materials)
+    {
+        rayleigh.push_back(mat.rayleigh);
+        wls.push_back(mat.wls);
+    }
+
+    CELER_ENSURE(rayleigh.size() == num_materials);
+    CELER_ENSURE(wls.size() == num_materials);
+
+    return std::make_shared<ImportedMaterials>(std::move(rayleigh),
+                                               std::move(wls));
+}
+
+//---------------------------------------------------------------------------//
+/*!
+ * Construct directly from imported material properties.
+ */
+ImportedMaterials::ImportedMaterials(std::vector<ImportOpticalRayleigh> rayleigh,
+                                     std::vector<ImportWavelengthShift> wls)
+    : rayleigh_(std::move(rayleigh)), wls_(std::move(wls))
+{
+    CELER_EXPECT(!rayleigh_.empty());
+    CELER_EXPECT(rayleigh_.size() == wls_.size());
+}
+
+//---------------------------------------------------------------------------//
+/*!
+ * Number of imported optical materials.
+ */
+OpticalMaterialId::size_type ImportedMaterials::num_materials() const
+{
+    return rayleigh_.size();
+}
+
+//---------------------------------------------------------------------------//
+/*!
+ * Get imported Rayleigh properties for the given material.
+ */
+ImportOpticalRayleigh const&
+ImportedMaterials::rayleigh(OpticalMaterialId mat) const
+{
+    CELER_EXPECT(mat < this->num_materials());
+    return rayleigh_[mat.get()];
+}
+
+//---------------------------------------------------------------------------//
+/*!
+ * Get imported wavelength shifting properties for the given material.
+ */
+ImportWavelengthShift const& ImportedMaterials::wls(OpticalMaterialId mat) const
+{
+    CELER_EXPECT(mat < this->num_materials());
+    return wls_[mat.get()];
+}
+
+//---------------------------------------------------------------------------//
+}  // namespace optical
+}  // namespace celeritas

src/celeritas/optical/ImportedMaterials.hh

@@ -0,0 +1,55 @@
+//------------------------------- -*- C++ -*- -------------------------------//
+// Copyright Celeritas contributors: see top-level COPYRIGHT file for details
+// SPDX-License-Identifier: (Apache-2.0 OR MIT)
+//---------------------------------------------------------------------------//
+//! \file celeritas/optical/ImportedMaterials.hh
+//---------------------------------------------------------------------------//
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "celeritas/Types.hh"
+
+namespace celeritas
+{
+struct ImportData;
+struct ImportOpticalRayleigh;
+struct ImportWavelengthShift;
+
+namespace optical
+{
+//---------------------------------------------------------------------------//
+/*!
+ * Imported material data for optical models.
+ *
+ * Stores material properties relevant for Rayleigh scattering and
+ * wavelength shifting.
+ */
+class ImportedMaterials
+{
+  public:
+    // Construct from imported and shared data
+    static std::shared_ptr<ImportedMaterials> from_import(ImportData const&);
+
+    // Construct directly from imported materials
+    ImportedMaterials(std::vector<ImportOpticalRayleigh> rayleigh,
+                      std::vector<ImportWavelengthShift> wls);
+
+    // Get number of imported optical materials
+    OpticalMaterialId::size_type num_materials() const;
+
+    // Get imported Rayleigh material parameters
+    ImportOpticalRayleigh const& rayleigh(OpticalMaterialId mat) const;
+
+    // Get imported wavelength shifting material parameters
+    ImportWavelengthShift const& wls(OpticalMaterialId mat) const;
+
+  private:
+    std::vector<ImportOpticalRayleigh> rayleigh_;
+    std::vector<ImportWavelengthShift> wls_;
+};
+
+//---------------------------------------------------------------------------//
+}  // namespace optical
+}  // namespace celeritas

src/celeritas/optical/MaterialData.hh

@@ -36,6 +36,7 @@ struct MaterialParamsData
 
     OpticalMaterialItems<GenericGridRecord> refractive_index;
     VolumeItems<OpticalMaterialId> optical_id;
+    OpticalMaterialItems<CoreMaterialId> core_material_id;
 
     // Backend data
     Items<real_type> reals;
@@ -46,7 +47,7 @@ struct MaterialParamsData
     explicit CELER_FUNCTION operator bool() const
     {
         return !refractive_index.empty() && !optical_id.empty()
-               && !reals.empty();
+               && !core_material_id.empty() && !reals.empty();
     }
 
     //! Assign from another set of data
@@ -56,6 +57,7 @@ struct MaterialParamsData
         CELER_EXPECT(other);
         refractive_index = other.refractive_index;
         optical_id = other.optical_id;
+        core_material_id = other.core_material_id;
         reals = other.reals;
         return *this;
     }

src/celeritas/optical/MaterialParams.cc

@@ -72,8 +72,24 @@ MaterialParams::from_import(ImportData const& data,
 
     CELER_VALIDATE(has_opt_mat,
                    << "no volumes have associated optical materials");
-
     CELER_ENSURE(inp.volume_to_mat.size() == geo_mat.num_volumes());
+
+    // Construct optical to core material mapping
+    inp.optical_to_core
+        = std::vector<CoreMaterialId>(inp.properties.size(), CoreMaterialId{});
+    for (auto core_id : range(CoreMaterialId{mat.num_materials()}))
+    {
+        if (auto opt_mat_id = mat.get(core_id).optical_material_id())
+        {
+            CELER_EXPECT(opt_mat_id < inp.optical_to_core.size());
+            CELER_EXPECT(!inp.optical_to_core[opt_mat_id.get()]);
+            inp.optical_to_core[opt_mat_id.get()] = core_id;
+        }
+    }
+
+    CELER_ENSURE(std::all_of(
+        inp.optical_to_core.begin(), inp.optical_to_core.end(), LogicalTrue{}));
+
     return std::make_shared<MaterialParams>(std::move(inp));
 }
 
@@ -85,6 +101,7 @@ MaterialParams::MaterialParams(Input const& inp)
 {
     CELER_EXPECT(!inp.properties.empty());
     CELER_EXPECT(!inp.volume_to_mat.empty());
+    CELER_EXPECT(inp.optical_to_core.size() == inp.properties.size());
 
     HostVal<MaterialParamsData> data;
     CollectionBuilder refractive_index{&data.refractive_index};
@@ -127,10 +144,22 @@ MaterialParams::MaterialParams(Input const& inp)
     CollectionBuilder{&data.optical_id}.insert_back(inp.volume_to_mat.begin(),
                                                     inp.volume_to_mat.end());
 
+    CollectionBuilder{&data.core_material_id}.insert_back(
+        inp.optical_to_core.begin(), inp.optical_to_core.end());
+
     data_ = CollectionMirror<MaterialParamsData>{std::move(data)};
     CELER_ENSURE(data_);
 }
 
+//---------------------------------------------------------------------------//
+/*!
+ * Construct a material view for the given identifier.
+ */
+MaterialView MaterialParams::get(OpticalMaterialId mat) const
+{
+    return MaterialView(this->host_ref(), mat);
+}
+
 //---------------------------------------------------------------------------//
 }  // namespace optical
 }  // namespace celeritas

src/celeritas/optical/MaterialParams.hh

@@ -14,6 +14,7 @@
 #include "celeritas/io/ImportOpticalMaterial.hh"
 
 #include "MaterialData.hh"
+#include "MaterialView.hh"
 
 namespace celeritas
 {
@@ -51,6 +52,8 @@ class MaterialParams final : public ParamsDataInterface<MaterialParamsData>
         std::vector<ImportOpticalProperty> properties;
         //! Map logical volume ID to optical material ID
         std::vector<OpticalMaterialId> volume_to_mat;
+        //! Map optical material ID to core material ID
+        std::vector<CoreMaterialId> optical_to_core;
     };
 
   public:
@@ -66,6 +69,9 @@ class MaterialParams final : public ParamsDataInterface<MaterialParamsData>
     // Number of optical materials
     inline OpticalMaterialId::size_type num_materials() const;
 
+    // Construct a material view for the given identifier
+    MaterialView get(OpticalMaterialId mat) const;
+
     //! Access optical material on the host
     HostRef const& host_ref() const final { return data_.host_ref(); }
 

src/celeritas/optical/MaterialView.hh

@@ -45,6 +45,9 @@ class MaterialView
     // ID of this optical material
     CELER_FORCEINLINE_FUNCTION MaterialId material_id() const;
 
+    // ID of the associated core material
+    CELER_FORCEINLINE_FUNCTION CoreMaterialId core_material_id() const;
+
     //// PARAMETER DATA ////
 
     // Access energy-dependent refractive index
@@ -104,6 +107,15 @@ CELER_FUNCTION auto MaterialView::material_id() const -> MaterialId
     return mat_id_;
 }
 
+//---------------------------------------------------------------------------//
+/*!
+ * Get the id of the core material associated with this optical material.
+ */
+CELER_FUNCTION CoreMaterialId MaterialView::core_material_id() const
+{
+    return params_.core_material_id[mat_id_];
+}
+
 //---------------------------------------------------------------------------//
 /*!
  * Access energy-dependent refractive index.