Physics Data And Cross Sections

NeoMC transport consumes compact runtime tables:

upstream library
  -> versioned resolver or lower-level importer
  -> package data in SimulationModel
  -> compiled transport and observable response

External file formats stop at the importer boundary.

Coupled Electromagnetic Data

CoupledEmPhysicsData contains photon, electron/positron, atomic-relaxation, photonuclear and material-specific stopping data.

For the supported reference installation, use:

• resolve_coupled_em_physics_data;
• resolve_coupled_em_simulation_package.

CoupledEmSimulationPackage em =
    resolve_coupled_em_simulation_package(
        CoupledEmDataLibraryDefinition{
            .root = physics_data_root,
            .version =
                CoupledEmDataLibraryVersion::
                    nndc_epdl97_endfb_vii1_eedl_g4emlow_8_8,
        },
        materials,
        transport,
        material_processes);

The resolver imports the elements used by the material list and records every consumed file and SHA-256 identity. The current named installation combines:

nndc-epdl97+endf-b-vii.1-eedl+g4emlow-8.8

It covers the mutually coherent photon, relaxation, electron, bremsstrahlung, density-effect and multiple-scattering inputs used by the reference profile. Selecting another physical combination requires another implemented version mapping or explicit lower-level assembly.

The resolver does not silently add photonuclear data or material-specific tables outside that installation. Lower-level importers remain available for applications that deliberately own those choices.

Photonuclear Data

PhotonuclearRuntimeTable carries reaction cross sections and optional final-state products. When enabled, photonuclear reactions enter collision competition. Emitted neutrons, protons, alphas or light ions require their owning packages and compatible data.

Start from resolved coupled-EM data, then add the explicitly selected photonuclear library:

ResolvedCoupledEmPhysicsData resolved =
    resolve_coupled_em_physics_data(
        CoupledEmDataLibraryDefinition{
            .root = physics_data_root,
            .version =
                CoupledEmDataLibraryVersion::
                    nndc_epdl97_endfb_vii1_eedl_g4emlow_8_8,
        },
        materials);

resolved.data.photonuclear =
    import_particlexs_photonuclear_runtime_table(
        photonuclear_data_root);

CoupledEmSimulationPackage em{
    .data = std::move(resolved.data),
    .transport = transport,
    .material_processes = material_processes,
};

Use this path only when the model can state the covered materials, reactions, energy ranges and product representations. Missing final states are not treated as zero-probability reactions.

Charged-Particle Data

ProtonTransportPhysicsData, AlphaTransportPhysicsData and LightIonTransportPhysicsData contain material stopping tables and optional target-nuclide reaction tables.

The stopping table must cover every material and energy reached by transport. The selected stopping model also defines whether nuclear loss is included in the continuous table or handled by explicit recoil/reaction transport.

For singly charged deuterons and tritons, resolve_anchored_same_velocity_light_ion_stopping constructs an explicitly named reduced model from a proton stopping table and a light-ion anchor table. The result records:

• projectile and material;
• model name and material scale;
• base and anchor source identities and versions;
• source hashes.

This model is opt-in. It is not a fallback and does not claim helium-3 or general light-ion stopping coverage.

LightIonMaterialStoppingTable deuteron_stopping =
    resolve_anchored_same_velocity_light_ion_stopping(
        AnchoredSameVelocityLightIonStoppingRequest{
            .proton_stopping_path = pstar_water_path,
            .proton_source_id = "nist-pstar-water",
            .proton_source_version = "2024-07",
            .particle_type = ParticleType::deuteron,
            .material = water,
            .mass_stopping_scale = 1.0,
            .anchors = LightIonStoppingAnchorSourceDefinition{
                .path = deuteron_anchor_path,
                .source_id = "project-deuteron-water",
                .source_version = "v1",
            },
        });

LightIonSimulationPackage light_ions{
    .data = LightIonTransportPhysicsData{
        .material_stopping_tables = {
            std::move(deuteron_stopping),
        },
    },
    .transport = LightIonTransportConfig{},
    .incident_particles = {ParticleType::deuteron},
};

Reaction transport additionally needs complete competing cross sections and a declared event representation. An exclusive two-body law can represent one closed event. Separate inclusive product marginals do not define a correlated multi-product event.

Neutron Data

NeutronSimulationPackage accepts either:

• EvaluatedNeutronData plus NeutronTransportDataPreparationPolicy; or
• prepared PreparedNeutronTransportData.

The high-level preparation path uses NeutronDataResolutionRequest, resolve_neutron_data_request and resolve_prepared_neutron_data_artifact. Its identity includes the selected data version, source hashes, nuclides, temperatures, processing settings, schema and processor version.

A matching prepared artifact can be reused across runs. A provenance, temperature or processing mismatch requires a new artifact.

ResolvedNeutronDataRequest request =
    resolve_neutron_data_request(
        NeutronDataResolutionRequest{
            .data_root = neutron_data_root,
            .data_version = "endf-b-viii.1",
            .materials = materials,
            .default_temperature_kelvin = 293.6,
            .database_scope = "shielding-model",
        });

ResolvedPreparedNeutronDataArtifact artifact =
    resolve_prepared_neutron_data_artifact(
        PreparedNeutronDataArtifactRequest{
            .data = std::move(request),
            .data_version = "endf-b-viii.1",
            .artifact_directory = processed_data_cache,
        });

NeutronSimulationPackage neutron{
    .prepared_data = std::move(artifact.data),
    .transport = NeutronTransportConfig{},
};

The returned NeutronTransportSupportManifest records which reachable reactions are transportable, explicitly modeled or unsupported for that exact model. It is more useful than an aggregate reaction count.

Decay Data

Use resolve_decay_data with the physical inventory nuclides and a named installation:

ResolvedDecayData resolved = resolve_decay_data(
    DecayDataLibraryDefinition{
        .data_root = decay_data_root,
        .data_version = "endf-b-viii.1",
    },
    inventory_nuclides);

The resolver follows evaluated daughters to stable closure. Stable evaluations are verified as endpoints but are not inserted as decaying parents in DecayRuntimeTable.

The result retains relative paths, per-file hashes and an aggregate closure hash. Importing an emission does not enable its transport; the owning particle package must also be present.

Runtime-Bound Responses

Microscopic reaction-rate observables name a target nuclide and MT. Compilation normally binds their response to the same evaluated package data used by transport.

An application can select a separately versioned response, such as a dosimetry table, through microscopic_reaction_response_id. That choice remains explicit in the observable result.

Provenance To Retain

For a result intended for reuse, retain:

• library name, version and source hashes;
• imported elements, nuclides and reactions;
• material density, temperature and binding state;
• processing and prepared-artifact identity;
• stopping, scattering, reaction and secondary-disposition policies;
• the package capability and support metadata returned by the run.

The repository's local data/ directory is only a workspace convention. It is not an implicit global data library in the NeoMC API.

if (result.coupled_em_data) {
  std::cout << result.coupled_em_data->library_version << '\n'
            << result.coupled_em_data->aggregate_sha256 << '\n';
}

for (const LightIonStoppingTableProvenance &table :
     result.light_ion_stopping_data) {
  std::cout << light_ion_stopping_table_model_name(table.model)
            << ' ' << table.mass_stopping_scale << '\n';
}