Support material-dependent model applicability

src/celeritas/em/interactor/MollerBhabhaInteractor.hh

@@ -103,6 +103,8 @@ CELER_FUNCTION MollerBhabhaInteractor::MollerBhabhaInteractor(
 {
     CELER_EXPECT(particle.particle_id() == shared_.ids.electron
                  || particle.particle_id() == shared_.ids.positron);
+    CELER_EXPECT(inc_energy_
+                 > (inc_particle_is_electron_ ? 2 : 1) * electron_cutoff_);
 }
 
 //---------------------------------------------------------------------------//
@@ -115,15 +117,6 @@ CELER_FUNCTION MollerBhabhaInteractor::MollerBhabhaInteractor(
 template<class Engine>
 CELER_FUNCTION Interaction MollerBhabhaInteractor::operator()(Engine& rng)
 {
-    if (inc_energy_ <= (inc_particle_is_electron_ ? 2 : 1) * electron_cutoff_)
-    {
-        /*!
-         * \todo Remove and replace with an assertion once material-dependent
-         * model bounds are supported
-         */
-        return Interaction::from_unchanged();
-    }
-
     // Allocate memory for the produced electron
     Secondary* electron_secondary = allocate_(1);
 

src/celeritas/em/interactor/SeltzerBergerInteractor.hh

@@ -128,6 +128,7 @@ CELER_FUNCTION SeltzerBergerInteractor::SeltzerBergerInteractor(
                  || particle.particle_id() == shared_.ids.positron);
     CELER_EXPECT(gamma_cutoff_ > zero_quantity());
     CELER_EXPECT(inc_energy_ < shared_.high_energy_limit);
+    CELER_EXPECT(inc_energy_ > gamma_cutoff_);
 }
 
 //---------------------------------------------------------------------------//
@@ -139,15 +140,6 @@ CELER_FUNCTION SeltzerBergerInteractor::SeltzerBergerInteractor(
 template<class Engine>
 CELER_FUNCTION Interaction SeltzerBergerInteractor::operator()(Engine& rng)
 {
-    if (inc_energy_ <= gamma_cutoff_)
-    {
-        /*!
-         * \todo Remove and replace with an assertion once material-dependent
-         * model bounds are supported
-         */
-        return Interaction::from_unchanged();
-    }
-
     // Allocate space for the brems photon
     Secondary* secondaries = allocate_(1);
     if (secondaries == nullptr)

src/celeritas/em/model/CoulombScatteringModel.cc

@@ -34,7 +34,6 @@ namespace celeritas
  */
 CoulombScatteringModel::CoulombScatteringModel(ActionId id,
                                                ParticleParams const& particles,
-                                               MaterialParams const& materials,
                                                SPConstImported data)
     : StaticConcreteAction(
           id, "coulomb-wentzel", "interact by Coulomb scattering (Wentzel)")
@@ -54,26 +53,6 @@ CoulombScatteringModel::CoulombScatteringModel(ActionId id,
         << R"(missing electron and/or positron particles (required for )"
         << this->description() << ")");
 
-    // Get high/low energy limits
-    energy_limit_
-        = imported_.energy_grid_bounds(data_.ids.electron, PhysMatId{0});
-
-    // Check that the bounds are the same for all particles/materials
-    // TODO: This is only expected when using Coulomb scattering with the
-    // Wentzel VI model above the MSC energy limit. When the MSC energy limit
-    // is not set, the model energy grid bounds are material dependent and
-    // require material-dependent applicability
-    for (auto pid : {data_.ids.electron, data_.ids.positron})
-    {
-        for (auto mid : range(PhysMatId{materials.num_materials()}))
-        {
-            CELER_VALIDATE(
-                energy_limit_ == imported_.energy_grid_bounds(pid, mid),
-                << "Coulomb scattering cross section energy limits are "
-                   "inconsistent across particles and/or materials");
-        }
-    }
-
     CELER_ENSURE(data_);
 }
 
@@ -83,15 +62,7 @@ CoulombScatteringModel::CoulombScatteringModel(ActionId id,
  */
 auto CoulombScatteringModel::applicability() const -> SetApplicability
 {
-    Applicability electron_applic;
-    electron_applic.particle = this->host_ref().ids.electron;
-    electron_applic.lower = energy_limit_[0];
-    electron_applic.upper = energy_limit_[1];
-
-    Applicability positron_applic = electron_applic;
-    positron_applic.particle = this->host_ref().ids.positron;
-
-    return {electron_applic, positron_applic};
+    return imported_.applicability();
 }
 
 //---------------------------------------------------------------------------//

src/celeritas/em/model/CoulombScatteringModel.hh

@@ -15,7 +15,6 @@
 
 namespace celeritas
 {
-class MaterialParams;
 class ParticleParams;
 class IsotopeView;
 
@@ -35,7 +34,6 @@ class CoulombScatteringModel final : public Model, public StaticConcreteAction
     // Construct from model ID and other necessary data
     CoulombScatteringModel(ActionId id,
                            ParticleParams const& particles,
-                           MaterialParams const& materials,
                            SPConstImported data);
 
     // Particle types and energy ranges that this model applies to
@@ -59,7 +57,6 @@ class CoulombScatteringModel final : public Model, public StaticConcreteAction
   private:
     CoulombScatteringData data_;
     ImportedModelAdapter imported_;
-    ImportedModelAdapter::EnergyBounds energy_limit_;
 };
 
 //---------------------------------------------------------------------------//

src/celeritas/em/model/KleinNishinaModel.cc

@@ -8,6 +8,7 @@
 
 #include "corecel/math/Quantity.hh"
 #include "celeritas/em/executor/KleinNishinaExecutor.hh"
+#include "celeritas/em/interactor/detail/PhysicsConstants.hh"
 #include "celeritas/global/ActionLauncher.hh"
 #include "celeritas/global/CoreParams.hh"
 #include "celeritas/global/CoreState.hh"
@@ -48,12 +49,12 @@ KleinNishinaModel::KleinNishinaModel(ActionId id,
  */
 auto KleinNishinaModel::applicability() const -> SetApplicability
 {
-    Applicability photon_applic;
-    photon_applic.particle = data_.ids.gamma;
-    photon_applic.lower = zero_quantity();
-    photon_applic.upper = max_quantity();
+    Applicability applic;
+    applic.particle = data_.ids.gamma;
+    applic.lower = zero_quantity();
+    applic.upper = detail::high_energy_limit();
 
-    return {photon_applic};
+    return {applic};
 }
 
 //---------------------------------------------------------------------------//

src/celeritas/em/model/LivermorePEModel.cc

@@ -15,6 +15,7 @@
 #include "corecel/cont/Range.hh"
 #include "celeritas/em/data/LivermorePEData.hh"
 #include "celeritas/em/executor/LivermorePEExecutor.hh"
+#include "celeritas/em/interactor/detail/PhysicsConstants.hh"
 #include "celeritas/global/ActionLauncher.hh"
 #include "celeritas/global/CoreParams.hh"
 #include "celeritas/global/CoreState.hh"
@@ -80,12 +81,12 @@ LivermorePEModel::LivermorePEModel(ActionId id,
  */
 auto LivermorePEModel::applicability() const -> SetApplicability
 {
-    Applicability photon_applic;
-    photon_applic.particle = this->host_ref().ids.gamma;
-    photon_applic.lower = zero_quantity();
-    photon_applic.upper = max_quantity();
+    Applicability applic;
+    applic.particle = this->host_ref().ids.gamma;
+    applic.lower = zero_quantity();
+    applic.upper = detail::high_energy_limit();
 
-    return {photon_applic};
+    return {applic};
 }
 
 //---------------------------------------------------------------------------//

src/celeritas/em/model/MollerBhabhaModel.cc

@@ -25,9 +25,15 @@ namespace celeritas
  * Construct from model ID and other necessary data.
  */
 MollerBhabhaModel::MollerBhabhaModel(ActionId id,
-                                     ParticleParams const& particles)
+                                     ParticleParams const& particles,
+                                     SPConstImported data)
     : StaticConcreteAction(
           id, "ioni-moller-bhabha", "interact by Moller+Bhabha ionization")
+    , imported_(data,
+                particles,
+                ImportProcessClass::e_ioni,
+                ImportModelClass::moller_bhabha,
+                {pdg::electron(), pdg::positron()})
 {
     CELER_EXPECT(id);
     data_.ids.electron = particles.find(pdg::electron());
@@ -49,23 +55,7 @@ MollerBhabhaModel::MollerBhabhaModel(ActionId id,
  */
 auto MollerBhabhaModel::applicability() const -> SetApplicability
 {
-    /*!
-     * \todo Set lower energy bound based on (material-dependent)
-     * IonizationProcess lambda table energy grid to avoid invoking the
-     * interactor for tracks with energy below the interaction threshold.
-     */
-
-    Applicability electron_applic, positron_applic;
-
-    electron_applic.particle = data_.ids.electron;
-    electron_applic.lower = zero_quantity();
-    electron_applic.upper = units::MevEnergy{data_.max_valid_energy()};
-
-    positron_applic.particle = data_.ids.positron;
-    positron_applic.lower = zero_quantity();
-    positron_applic.upper = electron_applic.upper;
-
-    return {electron_applic, positron_applic};
+    return imported_.applicability();
 }
 
 //---------------------------------------------------------------------------//

src/celeritas/em/model/MollerBhabhaModel.hh

@@ -7,6 +7,8 @@
 #pragma once
 
 #include "celeritas/em/data/MollerBhabhaData.hh"
+#include "celeritas/phys/ImportedModelAdapter.hh"
+#include "celeritas/phys/ImportedProcessAdapter.hh"
 #include "celeritas/phys/Model.hh"
 
 namespace celeritas
@@ -19,9 +21,15 @@ class ParticleParams;
  */
 class MollerBhabhaModel final : public Model, public StaticConcreteAction
 {
+  public:
+    //!@{
+    //! \name Type aliases
+    using SPConstImported = std::shared_ptr<ImportedProcesses const>;
+    //!@}
+
   public:
     // Construct from model ID and other necessary data
-    MollerBhabhaModel(ActionId id, ParticleParams const& particles);
+    MollerBhabhaModel(ActionId, ParticleParams const&, SPConstImported);
 
     // Particle types and energy ranges that this model applies to
     SetApplicability applicability() const final;
@@ -43,6 +51,7 @@ class MollerBhabhaModel final : public Model, public StaticConcreteAction
 
   private:
     MollerBhabhaData data_;
+    ImportedModelAdapter imported_;
 };
 
 //---------------------------------------------------------------------------//

src/celeritas/em/model/MuBremsstrahlungModel.cc

@@ -55,17 +55,7 @@ MuBremsstrahlungModel::MuBremsstrahlungModel(ActionId id,
  */
 auto MuBremsstrahlungModel::applicability() const -> SetApplicability
 {
-    Applicability mu_minus_applic, mu_plus_applic;
-
-    mu_minus_applic.particle = data_.mu_minus;
-    mu_minus_applic.lower = zero_quantity();
-    mu_minus_applic.upper = detail::high_energy_limit();
-
-    mu_plus_applic.particle = data_.mu_plus;
-    mu_plus_applic.lower = mu_minus_applic.lower;
-    mu_plus_applic.upper = mu_minus_applic.upper;
-
-    return {mu_minus_applic, mu_plus_applic};
+    return imported_.applicability();
 }
 
 //---------------------------------------------------------------------------//

src/celeritas/em/model/RayleighModel.cc

@@ -13,6 +13,7 @@
 #include "celeritas/Quantities.hh"
 #include "celeritas/em/data/RayleighData.hh"
 #include "celeritas/em/executor/RayleighExecutor.hh"  // IWYU pragma: associated
+#include "celeritas/em/interactor/detail/PhysicsConstants.hh"
 #include "celeritas/global/ActionLauncher.hh"
 #include "celeritas/global/CoreParams.hh"
 #include "celeritas/global/TrackExecutor.hh"
@@ -64,12 +65,12 @@ RayleighModel::RayleighModel(ActionId id,
  */
 auto RayleighModel::applicability() const -> SetApplicability
 {
-    Applicability rayleigh_scattering;
-    rayleigh_scattering.particle = this->host_ref().gamma;
-    rayleigh_scattering.lower = zero_quantity();
-    rayleigh_scattering.upper = units::MevEnergy{1e+8};
+    Applicability applic;
+    applic.particle = this->host_ref().gamma;
+    applic.lower = zero_quantity();
+    applic.upper = detail::high_energy_limit();
 
-    return {rayleigh_scattering};
+    return {applic};
 }
 
 //---------------------------------------------------------------------------//

src/celeritas/em/model/RelativisticBremModel.cc

@@ -86,15 +86,7 @@ RelativisticBremModel::RelativisticBremModel(ActionId id,
  */
 auto RelativisticBremModel::applicability() const -> SetApplicability
 {
-    Applicability electron;
-    electron.particle = this->host_ref().ids.electron;
-    electron.lower = this->host_ref().low_energy_limit;
-    electron.upper = detail::high_energy_limit();
-
-    Applicability positron = electron;
-    positron.particle = this->host_ref().ids.positron;
-
-    return {electron, positron};
+    return imported_.applicability();
 }
 
 //---------------------------------------------------------------------------//

src/celeritas/em/model/SeltzerBergerModel.cc

@@ -112,21 +112,7 @@ SeltzerBergerModel::SeltzerBergerModel(ActionId id,
  */
 auto SeltzerBergerModel::applicability() const -> SetApplicability
 {
-    /*!
-     * \todo Set lower energy bound based on (material-dependent)
-     * BremsstrahlungProcess lambda table energy grid to avoid invoking the
-     * interactor for tracks with energy below the interaction threshold.
-     */
-
-    Applicability electron;
-    electron.particle = this->host_ref().ids.electron;
-    electron.lower = zero_quantity();
-    electron.upper = this->host_ref().high_energy_limit;
-
-    Applicability positron = electron;
-    positron.particle = this->host_ref().ids.positron;
-
-    return {electron, positron};
+    return imported_.applicability();
 }
 
 //---------------------------------------------------------------------------//

src/celeritas/em/process/CoulombScatteringProcess.cc

@@ -19,17 +19,14 @@ namespace celeritas
  * Construct from host data.
  */
 CoulombScatteringProcess::CoulombScatteringProcess(SPConstParticles particles,
-                                                   SPConstMaterials materials,
                                                    SPConstImported process_data)
     : particles_(std::move(particles))
-    , materials_(std::move(materials))
     , imported_(process_data,
                 particles_,
                 ImportProcessClass::coulomb_scat,
                 {pdg::electron(), pdg::positron()})
 {
     CELER_EXPECT(particles_);
-    CELER_EXPECT(materials_);
 }
 
 //---------------------------------------------------------------------------//
@@ -40,7 +37,7 @@ auto CoulombScatteringProcess::build_models(ActionIdIter start_id) const
     -> VecModel
 {
     return {std::make_shared<CoulombScatteringModel>(
-        *start_id++, *particles_, *materials_, imported_.processes())};
+        *start_id++, *particles_, imported_.processes())};
 }
 
 //---------------------------------------------------------------------------//

src/celeritas/em/process/CoulombScatteringProcess.hh

@@ -28,14 +28,12 @@ class CoulombScatteringProcess : public Process
     //!@{
     //! \name Type aliases
     using SPConstParticles = std::shared_ptr<ParticleParams const>;
-    using SPConstMaterials = std::shared_ptr<MaterialParams const>;
     using SPConstImported = std::shared_ptr<ImportedProcesses const>;
     //!@}
 
   public:
     // Construct from Coulomb scattering data
     CoulombScatteringProcess(SPConstParticles particles,
-                             SPConstMaterials materials,
                              SPConstImported process_data);
 
     // Construct the models associated with this process
@@ -58,7 +56,6 @@ class CoulombScatteringProcess : public Process
 
   private:
     SPConstParticles particles_;
-    SPConstMaterials materials_;
     ImportedProcessAdapter imported_;
 };
 

src/celeritas/em/process/EIonizationProcess.cc

@@ -37,7 +37,8 @@ EIonizationProcess::EIonizationProcess(SPConstParticles particles,
  */
 auto EIonizationProcess::build_models(ActionIdIter start_id) const -> VecModel
 {
-    return {std::make_shared<MollerBhabhaModel>(*start_id++, *particles_)};
+    return {std::make_shared<MollerBhabhaModel>(
+        *start_id++, *particles_, imported_.processes())};
 }
 
 //---------------------------------------------------------------------------//