Enum ProcessIntegrand 

pub enum ProcessIntegrand {
    Amplitude(AmplitudeIntegrand),
    CrossSection(CrossSectionIntegrand),
}

Variants

Amplitude(AmplitudeIntegrand)

CrossSection(CrossSectionIntegrand)

Implementations

impl ProcessIntegrand

pub fn clone_with_selected_graph_groups( &self, graph_names: &[String], ) -> Result<Self>

pub fn resume_fingerprint(&self) -> Result<String>

pub fn kind_name(&self) -> &'static str

pub fn export_standalone( &self, path: impl AsRef<Path>, settings: &StandaloneExportSettings, ) -> Result<()>

pub fn warm_up(&mut self, model: &Model) -> Result<()>

pub fn frozen_compilation(&self) -> &FrozenCompilationMode

pub fn active_f64_backend(&self) -> ActiveF64Backend

pub fn get_settings(&self) -> &RuntimeSettings

pub fn get_mut_settings(&mut self) -> &mut RuntimeSettings

Invalidate runtime caches before exposing mutable settings. Call warm_up again before evaluating samples through sampling channels.

pub fn graph_count(&self) -> usize

pub fn graph_group_count(&self) -> usize

pub fn graph_group_master_names(&self) -> Vec<&str>

pub fn find_graph_id_by_name(&self, graph_name: &str) -> Option<usize>

pub fn graph_name_by_id(&self, graph_id: usize) -> Option<&str>

pub fn graph_group_id_by_graph_id(&self, graph_id: usize) -> Option<usize>

pub fn cut_edge_ids(&self, graph_id: usize, cut_id: usize) -> Option<Vec<usize>>

pub fn lmb_sample_id_for_channel( &self, graph_id: usize, sampling_channel_id: usize, parameterization_settings: &ParameterizationSettings, ) -> Result<Option<usize>>

pub fn resolve_group_id_by_master_name( &self, graph_name: &str, ) -> Result<GroupId>

pub fn resolve_discrete_selection( &self, discrete_dimensions: &[usize], ) -> Result<(Option<GroupId>, Option<usize>, Option<SamplingChannelId>)>

pub fn expected_x_space_dimension( &self, discrete_dimensions: &[usize], ) -> Result<usize>

pub fn discrete_sampling_depth(&self) -> usize

pub fn group_orientation_count(&self, group_id: GroupId) -> Option<usize>

pub fn group_sampling_channel_ids( &self, group_id: GroupId, parameterization_settings: &ParameterizationSettings, ) -> Result<Vec<SamplingChannelId>>

Return the canonical sampling-channel IDs for a graph group.

The IDs come directly from the master graph’s single catalogue. This helper is intended for saved-state acceptance callers constructing explicit (group, orientation, channel) selections; callers must pass the same parameterization settings used by the loaded state.

pub fn group_channel_count(&self, group_id: GroupId) -> Option<usize>

pub fn graph_orientation_count(&self, graph_id: usize) -> Option<usize>

pub fn evaluate_momentum_configuration( &mut self, model: &Model, input: &MomentumSpaceEvaluationInput, use_arb_prec: bool, ) -> Result<EvaluationResult>

pub fn evaluate_sample_precise( &mut self, sample: &Sample<F<f64>>, model: &Model, wgt: F<f64>, use_arb_prec: bool, max_eval: Complex<F<f64>>, ) -> Result<PreciseEvaluationResult>

pub fn evaluate_reference_sample( &mut self, sample: &Sample<F<f64>>, reference: &GaussianReferenceFunction, ) -> Result<EvaluationResult>

Evaluate a normalized reference function through the real process parameterization, retaining its Jacobian and integrator weight.

This is intentionally a test-only style overlay: graph routing, orientation/channel selection and all sampling maps are still exercised, while the physical graph evaluation is replaced by reference.

pub fn evaluate_reference_coordinates( &mut self, coordinates: &[Vec<f64>], reference: &GaussianReferenceFunction, ) -> Result<ReferenceSamplingReport>

Evaluate a normalized reference function from unit-cube coordinates.

This convenience entry point is intended for saved-state acceptance harnesses: callers can load a process normally, generate deterministic coordinates (for example Halton points), and exercise the complete process parameterization without constructing Symbolica Sample values themselves. The coordinate batch is interpreted as an equally weighted quadrature rule, so each sample has unit inverse-density weight and the report averages once over the N draws; the canonical sampling channel selected by the loaded settings remains responsible for its map and Jacobian.

pub fn evaluate_reference_discrete_coordinates( &mut self, discrete_indices: &[usize], coordinates: &[Vec<f64>], reference: &GaussianReferenceFunction, ) -> Result<ReferenceSamplingReport>

Evaluate deterministic coordinates under one explicit discrete selection path. discrete_indices is ordered from the outermost Sample::Discrete selector to the innermost one, matching the canonical graph/orientation/channel order used by the process sampler. The selection itself is never re-enumerated or filtered here; callers must supply IDs obtained from the loaded process’ canonical catalogue. Unit discrete weights make this a partition contribution, which need not integrate to one. A complete acceptance estimator must sum the per-draw contributions or use MC samples with reciprocal selection probabilities. Do not add report errors for channels sharing the same coordinates: their contributions must be combined before squaring.

pub fn evaluate_reference_samples( &mut self, samples: &[Sample<F<f64>>], reference: &GaussianReferenceFunction, ) -> Result<ReferenceSamplingReport>

Evaluate a batch of samples with a normalized reference function while retaining the process maps, Jacobians and sampling-grid weights.

pub fn evaluate_reference_sample_detailed( &mut self, sample: &Sample<F<f64>>, reference: &GaussianReferenceFunction, ) -> Result<ReferenceSampleEvaluation>

Detailed variant used by acceptance harnesses that also check raw momentum moments. The public scalar method above remains convenient for callers interested only in the mapped value.

pub fn evaluate_momentum_configuration_precise( &mut self, model: &Model, input: &MomentumSpaceEvaluationInput, use_arb_prec: bool, ) -> Result<PreciseEvaluationResult>

pub fn evaluate_samples_raw( &mut self, target: EvaluationTarget<'_>, samples: &[Sample<F<f64>>], _iter: usize, use_arb_prec: bool, stop_on_interrupt: bool, max_eval: Complex<F<f64>>, ) -> Result<RawBatchEvaluationResult>

pub fn evaluate_samples_raw_with_estimate( &mut self, target: EvaluationTarget<'_>, samples: &[Sample<F<f64>>], _iter: usize, use_arb_prec: bool, stop_on_interrupt: bool, max_eval: Complex<F<f64>>, integral_estimate: Option<(f64, f64)>, ) -> Result<RawBatchEvaluationResult>

pub fn evaluate_momentum_configurations_raw( &mut self, model: &Model, inputs: &[MomentumSpaceEvaluationInput], use_arb_prec: bool, ) -> Result<RawBatchEvaluationResult>

pub fn evaluate_samples_precise_raw( &mut self, model: &Model, samples: &[Sample<F<f64>>], use_arb_prec: bool, max_eval: Complex<F<f64>>, ) -> Result<RawPreciseBatchEvaluationResult>

pub fn evaluate_momentum_configurations_precise_raw( &mut self, model: &Model, inputs: &[MomentumSpaceEvaluationInput], use_arb_prec: bool, ) -> Result<RawPreciseBatchEvaluationResult>

pub fn process_evaluation_result(&mut self, result: &EvaluationResult)

pub fn merge_event_processing_runtime(&mut self, other: &mut Self) -> Result<()>

pub fn update_event_processing_runtime(&mut self, iter: usize)

pub fn observable_accumulator_bundle( &self, ) -> Option<ObservableAccumulatorBundle>

pub fn has_observables(&self) -> bool

pub fn observable_snapshot_bundle(&self) -> Option<ObservableSnapshotBundle>

pub fn build_observable_snapshots_for_result( &self, result: &EvaluationResult, ) -> Option<ObservableSnapshotBundle>

pub fn build_observable_snapshots_for_precise_result( &self, result: &PreciseEvaluationResult, ) -> Option<ObservableSnapshotBundle>

pub fn write_observable_snapshots( &self, path: impl AsRef<Path>, format: ObservableFileFormat, ) -> Result<()>

pub fn restore_observable_snapshot_bundle( &mut self, bundle: &ObservableSnapshotBundle, ) -> Result<()>

Trait Implementations

impl Clone for ProcessIntegrand

fn clone(&self) -> ProcessIntegrand

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<__Context> Decode<__Context> for ProcessIntegrand

where __Context: GammaLoopContext,

fn decode<D: Decoder<Context = __Context>>( decoder: &mut D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

impl Encode for ProcessIntegrand

where AmplitudeIntegrand: Encode, CrossSectionIntegrand: Encode,

fn encode<__E: Encoder>(&self, encoder: &mut __E) -> Result<(), EncodeError>

Encode a given type.

impl From<AmplitudeIntegrand> for ProcessIntegrand

fn from(v: AmplitudeIntegrand) -> ProcessIntegrand

Converts to this type from the input type.

impl From<CrossSectionIntegrand> for ProcessIntegrand

fn from(v: CrossSectionIntegrand) -> ProcessIntegrand

Converts to this type from the input type.

impl HasIntegrand for ProcessIntegrand

fn create_grid(&self) -> Grid<F<f64>>

Constructs the continuous or discrete integration grid required by this integrand.

fn name(&self) -> String

Returns the integrand name used in state inspection, logs, and status output.

fn evaluate_sample( &mut self, __enum_dispatch_arg_0: &Sample<F<f64>>, __enum_dispatch_arg_1: &Model, __enum_dispatch_arg_2: F<f64>, __enum_dispatch_arg_3: usize, __enum_dispatch_arg_4: bool, __enum_dispatch_arg_5: Complex<F<f64>>, ) -> Result<EvaluationResult>

Evaluates one weighted grid sample against the supplied model and numerical controls.

fn get_n_dim(&self) -> usize

Returns the number of continuous sampling dimensions used by the integrand.

fn get_integrator_settings(&self) -> IntegratorSettings

Returns integrator settings specialized for this integrand, or the defaults.

fn merge_results<I: HasIntegrand>( &mut self, __enum_dispatch_arg_0: &mut I, __enum_dispatch_arg_1: usize, )

Merges iteration-local result state from another worker integrand.

fn update_results(&mut self, __enum_dispatch_arg_0: usize)

Finalizes or writes iteration-local result state after an integration iteration.

impl TryInto<AmplitudeIntegrand> for ProcessIntegrand

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into( self, ) -> Result<AmplitudeIntegrand, <Self as TryInto<AmplitudeIntegrand>>::Error>

Performs the conversion.

impl TryInto<CrossSectionIntegrand> for ProcessIntegrand

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into( self, ) -> Result<CrossSectionIntegrand, <Self as TryInto<CrossSectionIntegrand>>::Error>

Performs the conversion.