Collision Probability Solvers

Collision probability (CP) method for neutron transport.

Solves the multi-group neutron transport equation using the collision probability method with white boundary condition for an infinite lattice.

The geometry-specific kernel is encapsulated in CPMesh, an augmented geometry that wraps a Mesh1D and provides compute_pinf_group(). Three coordinate systems are supported:

  • Cartesian (slab) — E₃ exponential-integral kernel.

  • Cylindrical (Wigner-Seitz pin) — Ki₃/Ki₄ Bickley-Naylor kernel.

  • Spherical (shell) — exponential kernel with y-weighted quadrature.

All share the same power iteration via CPSolver.

Two solver modes are available:

  • Jacobi (default) — computes the scattering source from the previous iteration’s flux for all groups simultaneously. Simple, no inner iterations.

  • Gauss-Seidel — sweeps group-by-group from fast to thermal, using the updated flux from already-processed groups. Within each group, inner iterations converge the within-group scattering. Converges faster for problems with strong thermal self-scatter.

See also

Collision Probability Method — Key Facts, equations, gotchas.

class orpheus.cp.solver.CPParams(max_outer=500, keff_tol=1e-06, flux_tol=1e-05, n_ki_table=20000, ki_max=50.0, n_quad_y=64, solver_mode='jacobi', inner_tol=1e-08, max_inner=100)[source]

Bases: object

Solver parameters for the collision probability method.

Parameters:
max_outer: int = 500
keff_tol: float = 1e-06
flux_tol: float = 1e-05
n_ki_table: int = 20000
ki_max: float = 50.0
n_quad_y: int = 64
solver_mode: str = 'jacobi'
inner_tol: float = 1e-08
max_inner: int = 100
class orpheus.cp.solver.CPResult(keff, keff_history, flux, flux_fuel, flux_clad, flux_cool, geometry, eg, elapsed_seconds, residual_history=<factory>, n_inner=None)[source]

Bases: object

Results of a collision probability calculation.

Parameters:
keff: float
keff_history: list[float]
flux: ndarray
flux_fuel: ndarray
flux_clad: ndarray
flux_cool: ndarray
geometry: Mesh1D
eg: ndarray
elapsed_seconds: float
residual_history: list[float]
n_inner: ndarray | None = None
class orpheus.cp.solver.CPMesh(mesh, params=None)[source]

Bases: object

Augmented geometry for the collision probability method.

Wraps a Mesh1D and adds the CP-specific kernel, quadrature, and compute_pinf_group() method. The kernel is selected automatically based on the mesh coordinate system:

  • Cartesian — E₃ kernel (slab), scalar computation.

  • Cylindrical — Ki₄ kernel, y-quadrature with chord half-lengths.

  • Spherical — exp(-τ) kernel, y-quadrature with y-weighted chords.

Parameters:

  • mesh (Mesh1D) – Base geometry.

  • params (CPParams, optional) – Solver parameters (Ki table size, quadrature order, etc.).

compute_pinf_group(sig_t_g)[source]

Compute the infinite-lattice P_inf matrix for one energy group.

Parameters:

sig_t_g (ndarray, shape (N,)) – Total macroscopic cross section per cell for this group.

Returns:

Infinite-lattice collision probability matrix.

Return type:

ndarray, shape (N, N)

class orpheus.cp.solver.CPSolver(P_inf, xs, volumes, mat_ids, materials, keff_tol=1e-06, flux_tol=1e-05, solver_mode='jacobi', inner_tol=1e-08, max_inner=100)[source]

Bases: object

Geometry-independent CP eigenvalue solver.

Once the infinite-lattice CP matrices P_inf are built (by CPMesh), the eigenvalue iteration is identical for all geometries:

φ_g = P_inf_g^T · (V · Q_g) / (Σ_t · V)

where V is the cell volume array and Q is the total source (fission + scattering + n,2n).

Two solver modes are supported:

  • Jacobi (default) — all groups updated from previous iteration’s flux. Simple, no inner iterations.

  • Gauss-Seidel — groups swept from fast to thermal; each group uses the latest flux from already-processed groups. Inner iterations within each group converge the within-group scattering source. Converges faster for thermal problems with strong self-scatter.

Parameters:
residual_history: list[float]
n_inner_history: list[ndarray]
initial_flux_distribution()[source]
Return type:

ndarray

compute_fission_source(flux_distribution, keff)[source]
Parameters:
Return type:

ndarray

solve_fixed_source(fission_source, flux_distribution)[source]
Parameters:
Return type:

ndarray

compute_keff(flux_distribution)[source]
Parameters:

flux_distribution (ndarray)

Return type:

float

converged(keff, keff_old, flux_distribution, flux_old, iteration)[source]
Parameters:
Return type:

bool

orpheus.cp.solver.solve_cp(materials, mesh=None, params=None)[source]

Solve the CP eigenvalue problem for any supported geometry.

The kernel is selected automatically based on mesh.coord: Cartesian (slab E₃), Cylindrical (Ki₄), or Spherical (exp).

Parameters:

  • materials (dict[int, Mixture]) – Macroscopic cross sections keyed by material ID.

  • mesh (Mesh1D, optional) – 1-D mesh. Defaults to a cylindrical PWR pin cell via geometry.factories.pwr_pin_equivalent().

  • params (CPParams, optional) – Solver parameters (tolerances, Ki table size, quadrature order).

Return type:

CPResult