pyopensn.solver.DiscreteOrdinatesCurvilinearProblem

class pyopensn.solver.DiscreteOrdinatesCurvilinearProblem

Base class for discrete ordinates problems in curvilinear geometry.

Wrapper of opensn::DiscreteOrdinatesCurvilinearProblem.

ComputeFissionProduction(self: pyopensn.solver.LBSProblem, scalar_flux_iterate: str) → float

Computes the total fission production (nu*fission).

Parameters:

scalar_flux_iterate ({'old', 'new'}) –

Specifies which scalar flux vector to use in the calculation.

• ’old’: Use the previous scalar flux iterate.

• ’new’: Use the current scalar flux iterate.

Returns:

The total fission production.

Return type:

float

Raises:

ValueError – If scalar_flux_iterate is not ‘old’ or ‘new’.

ComputeFissionRate(self: pyopensn.solver.LBSProblem, scalar_flux_iterate: str) → float

Computes the total fission rate.

Parameters:

scalar_flux_iterate ({'old', 'new'}) –

Specifies which scalar flux vector to use in the calculation.

• ’old’: Use the previous scalar flux iterate.

• ’new’: Use the current scalar flux iterate.

Returns:

The total fission rate.

Return type:

float

Raises:

ValueError – If scalar_flux_iterate is not ‘old’ or ‘new’.

ComputeLeakage(self: pyopensn.solver.DiscreteOrdinatesProblem, bnd_names: list) → dict

Compute leakage for the problem.

Parameters:

bnd_names (List[str]) – A list of boundary names for which leakage should be computed.

Returns:

A dictionary mapping boundary names to group-wise leakage vectors. Each array contains the outgoing angular flux (per group) integrated over the corresponding boundary surface.

Return type:

Dict[str, numpy.ndarray]

Raises:

• RuntimeError – If save_angular_flux option was not enabled during problem setup.

• ValueError – If one or more boundary ids are not present on the current mesh.

CreateAndWriteSourceMoments(self: pyopensn.solver.LBSProblem, file_base: str) → None

Write source moments from latest flux iterate to file.

Parameters:

file_base (str) – File basename.

GetAngularFieldFunctionList(self: pyopensn.solver.DiscreteOrdinatesProblem, groups: list, angles: list) → list

Return field functions for selected angular flux components.

Note: You must enable angular flux storage (save_angular_flux=True) in the problem options, or use a transient/time-dependent solver that retains angular fluxes, otherwise the field functions will remain zero.

Example

`python solver.Initialize() solver.Execute() ang_ff = phys.GetAngularFieldFunctionList(groups=[0], angles=[0]) `

For transient/time-dependent runs, call this after each timestep. Two common patterns are:

1) Use TransientSolver.Execute() with a post-advance callback: ```python solver = TransientSolver(problem=phys) solver.Initialize()

def post_advance():

ang_ff = phys.GetAngularFieldFunctionList(groups=[0], angles=[0]) FieldFunctionGridBased.ExportMultipleToPVTU(ang_ff, “angular_flux_t”)

solver.SetPostAdvanceCallback(post_advance) solver.Execute() ```

2) Use a custom Python loop with TransientSolver.Advance(): ```python solver = TransientSolver(problem=phys) solver.Initialize() for _ in range(num_steps):

solver.Advance() ang_ff = phys.GetAngularFieldFunctionList(groups=[0], angles=[0]) FieldFunctionGridBased.ExportMultipleToPVTU(ang_ff, “angular_flux_t”)

```

Parameters:

• groups (List[int]) – Global group indices to export.

• angles (List[int]) – Angle indices within the groupset quadrature for each group.

Returns:

Field functions for the requested (group, angle) pairs.

Return type:

List[pyopensn.fieldfunc.FieldFunctionGridBased]

GetPhiNewLocal(self: pyopensn.solver.LBSProblem) → memoryview

Get the current scalar flux iterate (local vector).

Returns:

Memory view of the local new scalar flux vector.

Return type:

memoryview

GetPhiOldLocal(self: pyopensn.solver.LBSProblem) → memoryview

Get the previous scalar flux iterate (local vector).

Returns:

Memory view of the local old scalar flux vector.

Return type:

memoryview

GetPowerFieldFunction(self: pyopensn.solver.LBSProblem) → pyopensn.fieldfunc.FieldFunctionGridBased

Returns the power generation field function, if enabled.

GetPsi(self: pyopensn.solver.DiscreteOrdinatesProblem) → list

Return psi as a list of NumPy arrays (float64), using zero-copy views into the underlying data.

GetScalarFluxFieldFunction(self: pyopensn.solver.LBSProblem, only_scalar_flux: bool = True) → list

Return scalar-flux or flux-moment field functions grouped by energy group.

Parameters:

only_scalar_flux (bool, default=True) – If True, returns only the zeroth moment (scalar flux) field function for each group. If False, returns all moment field functions for each group.

Returns:

If only_scalar_flux=True: result[g] is the scalar-flux field function for group g.

If only_scalar_flux=False: result[g][m] is the field function for group g and moment m.

Return type:

Union[List[pyopensn.fieldfunc.FieldFunctionGridBased], List[List[pyopensn.fieldfunc.FieldFunctionGridBased]]]

Notes

In the nested form (only_scalar_flux=False), the moment index varies fastest within each group (inner index = moment, outer index = group).

GetTime(self: pyopensn.solver.LBSProblem) → float

Get the current simulation time in seconds.

GetTimeStep(self: pyopensn.solver.LBSProblem) → float

Get the current timestep size.

IsAdjoint(self: pyopensn.solver.LBSProblem) → bool

Return True if the problem is in adjoint mode, otherwise False.

IsTimeDependent(self: pyopensn.solver.DiscreteOrdinatesProblem) → bool

Return True if the problem is currently in time-dependent mode.

ReadAngularFluxes(self: opensn::DiscreteOrdinatesProblem, file_base: str) → None

Read angular fluxes from file.

Parameters:

file_base (str) – File basename.

ReadFluxMoments(self: pyopensn.solver.LBSProblem, file_base: str, single_file_flag: bool) → None

Read flux moment data.

Parameters:

• file_base (str) – File basename.

• single_file_flag (bool) – True if all flux moments are in a single file.

ReadFluxMomentsAndMakeSourceMoments(self: pyopensn.solver.LBSProblem, file_base: str, single_file_flag: bool) → None

Read flux moments and compute corresponding source moments.

Parameters:

• file_base (str) – File basename.

• single_file_flag (bool) – True if all flux moments are in a single file.

ReadSourceMoments(self: pyopensn.solver.LBSProblem, file_base: str, single_file_flag: bool) → None

Read source moments from file.

Parameters:

• file_base (str) – File basename.

• single_file_flag (bool) – True if all source moments are in a single file.

SetAdjoint(self: pyopensn.solver.LBSProblem, arg0: bool) → None

Set forward/adjoint transport mode.

Parameters:

adjoint (bool) – True enables adjoint mode and False enables forward mode.

Notes

This is one of three supported mode-setting paths in Python:

1. options={'adjoint': ...} in the problem constructor.

2. SetOptions(adjoint=...).

3. SetAdjoint(...) (this method).

In typical Python workflows, use constructor options or SetOptions.

If this changes mode, OpenSn performs a full mode-transition reset:

• Materials are reinitialized in the selected mode.

• Point and volumetric sources are cleared.

• Boundary conditions are cleared.

• Scalar and angular flux vectors are zeroed.

If this is called with the same mode as the current setting, no reset is performed.

The block-id to cross-section map is preserved across the transition. However, the mode change is applied to the mapped MultiGroupXS objects themselves. If those objects are shared with other problems, they observe the same mode toggle.

After a mode change, reapply the desired driving terms before solving, typically:

• LBSProblem.SetPointSources()

• LBSProblem.SetVolumetricSources()

• DiscreteOrdinatesProblem.SetBoundaryOptions()

This routine is intentionally destructive with respect to source/boundary/flux state to avoid hidden coupling between forward and adjoint setups.

SetBoundaryOptions(self: pyopensn.solver.DiscreteOrdinatesProblem, **kwargs) → None

Set or clear boundary conditions.

Parameters:

• clear_boundary_conditions (bool, default=False) – If true, all current boundary conditions are deleted.

• boundary_conditions (List[Dict]) –

  A list of boundary condition dictionaries. Each dictionary supports:

  • name: str (required)

    Boundary name that identifies the specific boundary.

  • type: {‘vacuum’, ‘isotropic’, ‘reflecting’, ‘arbitrary’} (required)

    Boundary type specification.

  • group_strength: List[float], optional

    Required when type='isotropic'. Isotropic strength per group.

  • function: AngularFluxFunction, optional

    Required when type='arbitrary'. Callable that returns incoming angular flux.

Notes

Mode transitions via SetOptions(adjoint=...) (or the low-level LBSProblem.SetAdjoint()) clear all boundary conditions. Reapply boundaries with this method before solving in the new mode.

SetOptions(self: pyopensn.solver.DiscreteOrdinatesProblem, **kwargs) → None

Set problem options from a large list of parameters.

Parameters:

**kwargs – Same option keys and semantics as LBSProblem.SetOptions().

Notes

This call is additive: only options explicitly supplied are updated.

As with LBSProblem.SetOptions(), if adjoint is explicitly supplied and differs from the current mode, the same mode-transition behavior as LBSProblem.SetAdjoint() is used.

SetPointSources(self: pyopensn.solver.LBSProblem, **kwargs) → None

Set or clear point sources.

Parameters:

• clear_point_sources (bool, default=False) – If true, all current the point sources of the problem are deleted.

• point_sources (List[pyopensn.source.PointSource]) – List of new point sources to be added to the problem.

SetSaveAngularFlux(self: pyopensn.solver.LBSProblem, save: bool) → None

SetSteadyStateMode(self: pyopensn.solver.DiscreteOrdinatesProblem) → None

Set the problem to steady-state mode.

Notes

Switch problem from time-dependent to steady-state mode. This updates problem internals (sweep chunk mode and source-function) while preserving user boundary conditions and fixed sources. If save_angular_flux was auto-enabled when entering time-dependent mode, this call restores the previous value.

SetTimeDependentMode(self: pyopensn.solver.DiscreteOrdinatesProblem) → None

Set the problem to time-dependent mode.

Notes

Switch problem from steady-state to time-dependent mode. This updates problem internals (sweep chunk mode and source-function) while preserving user boundary conditions and fixed sources. If save_angular_flux is false, this transition enables it.

SetVolumetricSources(self: pyopensn.solver.LBSProblem, **kwargs) → None

Set or clear volumetric sources.

Parameters:

• clear_volumetric_sources (bool, default=False) – If true, all current the volumetric sources of the problem are deleted.

• volumetric_sources (List[pyopensn.source.VolumetricSource]) – List of new volumetric sources to be added to the problem.

SetXSMap(self: pyopensn.solver.LBSProblem, **kwargs) → None

Replace the block-id to cross-section map.

Parameters:

xs_map (List[Dict]) –

A list of block-id to cross-section mapping dictionaries. Each dictionary supports:

• block_ids: List[int] (required)

  Mesh block ids to associate with the cross section.

• xs: pyopensn.xs.MultiGroupXS (required)

  Cross section object.

Notes

Forward/adjoint mode toggles via SetOptions(adjoint=...) (or the low-level LBSProblem.SetAdjoint()) do not change this map. The MultiGroupXS objects themselves are mutable and shared by pointer. If the same MultiGroupXS handle is shared across multiple problems, toggling adjoint mode in one problem also changes the transport mode seen by the others.

WriteAngularFluxes(self: opensn::DiscreteOrdinatesProblem, file_base: str) → None

Write angular flux data to file.

Parameters:

file_base (str) – File basename.

WriteFluxMoments(self: pyopensn.solver.LBSProblem, file_base: str) → None

Write flux moments to file.

Parameters:

file_base (str) – File basename.

ZeroPhi(self: pyopensn.solver.LBSProblem) → None

Zero the scalar-flux vectors (phi_old and phi_new) in-place.

ZeroPsi(self: pyopensn.solver.LBSProblem) → None

Zero the angular-flux storage (if present for this problem type).

__init__(self: pyopensn.solver.DiscreteOrdinatesCurvilinearProblem, **kwargs) → None

Construct a discrete ordinates problem for curvilinear geometry.

Warning

DiscreteOrdinatesCurvilinearProblem is experimental and should be used with caution!

Parameters:

• mesh (MeshContinuum) – The spatial mesh.

• coord_system (int) – Coordinate system to use. Must be set to 2 (cylindrical coordinates).

• num_groups (int) – The total number of energy groups.

• groupsets (list of dict) –

  A list of input parameter blocks, each block provides the iterative properties for a groupset. Each dictionary supports:

  • groups_from_to: List[int] (required)

    Two-entry list with the first and last group id for the groupset, e.g. [0, 3].

  • angular_quadrature: pyopensn.aquad.AngularQuadrature, optional

    Handle to an angular quadrature.

  • angle_aggregation_type: {‘polar’, ‘single’, ‘azimuthal’}, default=’polar’

    Angle aggregation method to use during sweeping.

  • angle_aggregation_num_subsets: int, default=1

    Number of angle subsets used for aggregation.

  • inner_linear_method: {‘classic_richardson’, ‘petsc_richardson’, ‘petsc_gmres’, ‘petsc_bicgstab’}, default=’petsc_richardson’

    Iterative method used for inner linear solves.

  • l_abs_tol: float, default=1.0e-6

    Inner linear solver absolute residual tolerance.

  • l_max_its: int, default=200

    Inner linear solver maximum iterations.

  • gmres_restart_interval: int, default=30

    GMRES restart interval, if GMRES is used.

  • allow_cycles: bool, default=True

    Whether cyclic dependencies are allowed in sweeps.

  • apply_wgdsa: bool, default=False

    Enable within-group DSA for this groupset.

  • wgdsa_l_abs_tol: float, default=1.0e-4

    WGDSA linear absolute tolerance.

  • wgdsa_l_max_its: int, default=30

    WGDSA maximum iterations.

  • wgdsa_verbose: bool, default=False

    Verbose WGDSA output.

  • wgdsa_petsc_options: str, default=’’

    PETSc options string for the WGDSA solver.

  • apply_tgdsa: bool, default=False

    Enable two-grid DSA for this groupset.

  • tgdsa_l_abs_tol: float, default=1.0e-4

    TGDSA linear absolute tolerance.

  • tgdsa_l_max_its: int, default=30

    TGDSA maximum iterations.

  • tgdsa_verbose: bool, default=False

    Verbose TGDSA output.

  • tgdsa_petsc_options: str, default=’’

• xs_map (list of dict) –

  A list of mappings from block ids to cross-section definitions. Each dictionary supports:

  • block_ids: List[int] (required)

    Mesh block IDs to associate with the cross section.

  • xs: pyopensn.xs.MultiGroupXS (required)

    Cross-section object to assign to the specified blocks.

• boundary_conditions (List[Dict], default=[]) –

  A list containing tables for each boundary specification. Each dictionary supports:

  • name: str (required)

    Boundary name that identifies the specific boundary.

  • type: {‘vacuum’, ‘isotropic’, ‘reflecting’, ‘arbitrary’} (required)

    Boundary type specification.

  • group_strength: List[float], optional

    Required when type='isotropic'. Isotropic strength per group.

  • function: AngularFluxFunction, optional

    Required when type='arbitrary'. Callable that returns incoming angular flux.

• point_sources (List[pyopensn.source.PointSource], default=[]) – A list of point sources.

• volumetric_sources (List[pyopensn.source.VolumetricSource], default=[]) – A list of volumetric sources.

• options (dict, optional) –

  A block of optional configuration parameters. Each dictionary supports the same keys as LBSProblem.SetOptions(), including:

  • max_mpi_message_size: int, default=32768

  • restart_writes_enabled: bool, default=False

  • write_delayed_psi_to_restart: bool, default=True

  • read_restart_path: str, default=’’

  • write_restart_path: str, default=’’

  • write_restart_time_interval: int, default=0

  • use_precursors: bool, default=False

  • use_source_moments: bool, default=False

  • save_angular_flux: bool, default=False

  • verbose_inner_iterations: bool, default=True

  • verbose_outer_iterations: bool, default=True

  • max_ags_iterations: int, default=100

  • ags_tolerance: float, default=1.0e-6

  • ags_convergence_check: {‘l2’, ‘pointwise’}, default=’l2’

  • verbose_ags_iterations: bool, default=True

  • power_field_function_on: bool, default=False

  • power_default_kappa: float, default=3.20435e-11

  • power_normalization: float, default=-1.0

  • field_function_prefix_option: {‘prefix’, ‘solver_name’}, default=’prefix’

  • field_function_prefix: str, default=’’

• sweep_type (str, optional) – The sweep type to use. Must be one of AAH or CBC. Defaults to AAH.