Physics Processes

Users select physical behavior through package data and transport policy. A process is usable only over the material, energy and event representation covered by that package.

Coupled Electromagnetic

Start from the supported profile and override only choices required by the calculation:

const CoupledEmPhysicsProfile profile =
    CoupledEmPhysicsProfile::neomc_reference_epdl_eedl;

CoupledEmTransportConfig transport =
    make_coupled_em_transport_config(profile);
transport.production.electron_energy = 1.0e3;
transport.production.positron_energy = 1.0e3;
transport.production.photon_energy = 1.0e3;
transport.physics.positron_policy =
    CoupledPositronPolicy::spatial_transport;

CoupledEmSimulationPackage em =
    resolve_coupled_em_simulation_package(
        CoupledEmDataLibraryDefinition{.root = physics_data_root},
        materials,
        transport,
        make_coupled_em_material_process_config(profile));

The resolved package can transport photon Rayleigh, Compton, photoelectric and pair interactions plus charged elastic, excitation, ionization, bremsstrahlung and positron annihilation within its data and model domain. Photonuclear reactions require additional explicit reaction data.

Proton Stopping Without Nuclear Reactions

ProtonTransportConfig transport{
    .master_seed = 61,
    .max_energy_loss_fraction = 0.05,
    .active_transport_floor_energy = 1.0e3,
    .nuclear_reaction_policy = ProtonNuclearReactionPolicy::csda_only,
    .stopping_model =
        ProtonStoppingModel::material_total_stopping_table,
    .energy_straggling_model = ProtonEnergyStragglingModel::bohr,
    .multiple_scattering_model =
        ProtonMultipleScatteringModel::highland,
};

ProtonSimulationPackage proton{
    .data = std::move(proton_data),
    .transport = transport,
};

Use a total stopping table when nuclear loss is already included and no explicit nuclear event is transported.

Proton Reactions And Secondary Handoff

ProtonTransportConfig transport{
    .master_seed = 62,
    .active_transport_floor_energy = 1.0e3,
    .nuclear_reaction_policy =
        ProtonNuclearReactionPolicy::evaluated_event_transport,
    .stopping_model =
        ProtonStoppingModel::material_electronic_stopping_table,
    .multiple_scattering_model =
        ProtonMultipleScatteringModel::evaluated_screened_coulomb,
};

SimulationPackageSet packages{
    .proton = ProtonSimulationPackage{
        .data = std::move(proton_data),
        .transport = transport,
    },
    .neutron = std::move(neutron_package),
    .required_capabilities = {
        SimulationRequiredTransportCapability{
            .package = TransportPackageId::proton,
            .capability = "proton_data_driven_nuclear_reactions",
            .minimum_status = TransportCapabilityStatus::experimental,
        },
    },
};

The reaction tables must cover every reachable target and energy. Products are routed to their owning enabled package rather than disappearing from the event.

Alpha Transport

AlphaTransportConfig transport{
    .master_seed = 63,
    .max_energy_loss_fraction = 0.05,
    .active_transport_floor_energy = 1.0e3,
    .nuclear_reaction_policy =
        AlphaNuclearReactionPolicy::evaluated_reaction_transport,
    .stopping_model =
        AlphaStoppingModel::material_electronic_stopping_table,
    .continuous_nuclear_stopping_model =
        AlphaContinuousNuclearStoppingModel::
            evaluated_screened_coulomb_soft_recoil,
    .energy_straggling_model = AlphaEnergyStragglingModel::bohr,
    .multiple_scattering_model =
        AlphaMultipleScatteringModel::evaluated_screened_coulomb,
};

The continuous nuclear-stopping choice states how soft recoil is represented without double-counting explicit hard elastic events.

Deuteron, Triton And Helium-3

LightIonTransportConfig transport{
    .master_seed = 64,
    .active_transport_floor_energy = 1.0e3,
    .nuclear_reaction_policy =
        LightIonNuclearReactionPolicy::evaluated_reaction_transport,
    .inclusive_product_policy =
        LightIonInclusiveProductPolicy::require_transport_package,
    .evaluated_reaction_particles = {ParticleType::deuteron},
    .energy_straggling_model = LightIonEnergyStragglingModel::bohr,
    .multiple_scattering_model =
        LightIonMultipleScatteringModel::highland,
    .charge_state_model =
        LightIonChargeStateModel::equilibrium_effective_charge,
};

LightIonSimulationPackage light_ions{
    .data = std::move(light_ion_data),
    .transport = transport,
    .incident_particles = {ParticleType::deuteron},
};

evaluated_reaction_particles limits reaction transport to the named projectiles. Other enabled light ions can still use the configured stopping model when covered by their tables.

Neutron Transport

NeutronTransportConfig transport{
    .master_seed = 65,
    .cross_package_secondary_policy =
        NeutronCrossPackageSecondaryPolicy::require_transport_package,
    .delayed_fission_neutron_policy =
        NeutronDelayedFissionSecondaryPolicy::require_evaluated_transport,
    .delayed_fission_gamma_policy =
        NeutronDelayedFissionSecondaryPolicy::require_evaluated_transport,
    .fission_fragment_policy =
        NeutronFissionFragmentPolicy::deposit_evaluated_release_locally,
    .collision_sampling_method = NeutronCollisionSamplingMethod::analog,
    .elastic_policy =
        NeutronElasticFinalStatePolicy::require_evaluated_angular,
    .thermal_scattering_policy =
        NeutronThermalScatteringPolicy::tabulated_energy_angle,
    .thermal_scattering_cutoff_ev = 0.5,
    .material_temperature_kelvin = 293.6,
};

NeutronSimulationPackage neutron{
    .prepared_data = std::move(prepared_neutron_data),
    .transport = transport,
};

Compilation classifies every reachable nonzero reaction under these policies. Evaluated elastic and thermal laws, reaction products, de-excitation photons, fission emissions and secondary handoff are used only where the prepared package supports them.

Variance Reduction

Variance reduction changes numerical weights, not physical interaction rates:

auto window = std::make_shared<NeutronWeightWindowMesh>();
window->x_edges_cm = {0.0, 10.0, 20.0};
window->y_edges_cm = {-5.0, 5.0};
window->z_edges_cm = {-5.0, 5.0};
window->energy_min_ev = 1.0e3;
window->energy_upper_bounds_ev = {1.0e6, 20.0e6};
window->lower_weight_bounds = {0.5, 0.25, 0.2, 0.1};

transport.weight_window_mesh = std::move(window);

Decay And Activation

Chain an irradiation result into decay transport through the public helper:

SimulationTransportSessionResult shutdown =
    run_activation_decay_transport_from_simulation_result(
        irradiation_result,
        SimulationActivationDecayTransportDefinition{
            .decay_data = std::move(decay_data),
            .initial_inventory = initial_inventory,
            .physical_source_events = source_events,
            .irradiation_time_s = irradiation_time_s,
            .cooling_time_s = cooling_time_s,
            .decay_transport_model = std::move(decay_model),
        });

The irradiation, inventory evolution and decay-particle transport remain separate physical stages. This helper does not turn the workflow into a general burnup solver.