Method of Characteristics

class scarabee.MOCDriver

__init__(self: scarabee._scarabee.MOCDriver, geometry: scarabee._scarabee.Cartesian2D, xminbc: scarabee._scarabee.BoundaryCondition = <BoundaryCondition.Reflective: 0>, xmaxbc: scarabee._scarabee.BoundaryCondition = <BoundaryCondition.Reflective: 0>, yminbc: scarabee._scarabee.BoundaryCondition = <BoundaryCondition.Reflective: 0>, ymaxbc: scarabee._scarabee.BoundaryCondition = <BoundaryCondition.Reflective: 0>, anisotropic: bool = False) → None

Initializes a Method of Characteristics problem.

Parameters:

• geometry (Cartesian2D) – Geometry for the problem.

• xminbc (BoundaryCondition) – Boundary condition at the lower x boundary.

• xmaxbc (BoundaryCondition) – Boundary condition at the upper x boundary.

• yminbc (BoundaryCondition) – Boundary condition at the lower y boundary.

• ymaxbc (BoundaryCondition) – Boundary condition at the upper y boundary.

• anisotropic (bool) – Enable the anisotropic scattering solver.

property anisotropic

If True, anisotropic scattering will be simulated.

apply_criticality_spectrum(self: scarabee._scarabee.MOCDriver, flux: numpy.ndarray[numpy.float64]) → None

Modifies the flux spectrum of the solved problem by multiplying the value of the flux by the ratio of the provided criticality spectrum to homogenized flux spectrum.

Parameters:

flux (ndarray of floats) – Criticality spectrum from a P1 or B1 calculation.

property check_fsr_areas

Checks if the approximate flat source region area (from numerical integration) is within fsr_area_tolerance of the true flat source region area. It the check does not pass, a warning is issued, but the calculation continues. Default value is False.

property cmfd

CMFD object for convergence acceleration.

property drawn

True if geometry has been traced, False otherwise.

extern_src(*args, **kwargs)

Overloaded function.

1. extern_src(self: scarabee._scarabee.MOCDriver, r: scarabee._scarabee.Vector, u: scarabee._scarabee.Direction, g: typing.SupportsInt | typing.SupportsIndex) -> float

Returns the external source in the Flat Source Region at r.

Parameters:

• r (Vector) – Position at which to set the source.

• u (Direction) – Direction vector used to disambiguate the FSR.

• g (int) – Energy group index.

Returns:

Value of the external source at position r.

Return type:

float

2. extern_src(self: scarabee._scarabee.MOCDriver, i: typing.SupportsInt | typing.SupportsIndex, g: typing.SupportsInt | typing.SupportsIndex) -> float

Returns the external source in Flat Source Region i.

Parameters:

• i (int) – Flat Source Region index.

• g (int) – Energy group index.

Returns:

Value of the external source at position r.

Return type:

float

flux(*args, **kwargs)

Overloaded function.

1. flux(self: scarabee._scarabee.MOCDriver, r: scarabee._scarabee.Vector, u: scarabee._scarabee.Direction, g: typing.SupportsInt | typing.SupportsIndex, lj: typing.SupportsInt | typing.SupportsIndex = 0) -> float

Returns:

Flux at position r and in group g.

Return type:

float

2. flux(self: scarabee._scarabee.MOCDriver, i: typing.SupportsInt | typing.SupportsIndex, g: typing.SupportsInt | typing.SupportsIndex, lj: typing.SupportsInt | typing.SupportsIndex = 0) -> float

Returns:

Flux FSR i and in group g.

Return type:

float

property flux_tolerance

Maximum relative absolute difference in flux for convergence.

property fsr_area_tolerance

Maximum relative absolute difference between approximate flat source region area and the true flat source region area. Only used if check_fsr_areas is True. Default value is 0.05.

generate_tracks(*args, **kwargs)

Overloaded function.

1. generate_tracks(self: scarabee._scarabee.MOCDriver, nangles: typing.SupportsInt | typing.SupportsIndex, d: typing.SupportsFloat | typing.SupportsIndex, polar_quad: scarabee._scarabee.PolarQuadrature) -> None

Traces tracks across the geometry for the calculation.

Parameters:

• nangles (int) – Number of azimuthal angles (must be even).

• d (float) – Max spacing between tracks of a given angle (in cm).

• polar_quad (PolarQuadrature) – Polar quadrature for generating segment lengths.

• generate_tracks(self (2.) –

• calculation. (Traces tracks across the geometry for the) –

• nangles – Number of azimuthal angles (must be even).

• d – Max spacing between tracks of a given angle (in cm).

• polar_quad – Polar quadrature for generating segment lengths.

property geometry

The Cartesian2D geometry for the problem.

get_all_fsr_in_cell(self: scarabee._scarabee.MOCDriver, r: scarabee._scarabee.Vector, u: scarabee._scarabee.Direction) → list[int]

Obtains the index of all Flat Source Regions contained in the Cell located at position r.

Parameters:

• r (Vector) – Position at which to set the source.

• u (Direction) – Direction vector used to disambiguate the FSR.

Returns:

Indices of all flat source regions in the cell.

Return type:

list of int

get_fsr_indx(self: scarabee._scarabee.MOCDriver, fsr_id: SupportsInt | SupportsIndex, instance: SupportsInt | SupportsIndex) → int

Obtains the index for a given flat source region ID and instance.

Parameters:

• fsr_id (int) – Flat source region ID.

• instance (int) – Desired instance of the provided FSR ID.

Returns:

Index in the MOCDriver of the specified FSR instance.

Return type:

int

homogenize(*args, **kwargs)

Overloaded function.

1. homogenize(self: scarabee._scarabee.MOCDriver) -> scarabee._scarabee.CrossSection

Computes a homogenized set of cross sections for the problem based on the previously computed flux and reaction rates. This method raises an exception if the problem has not yet been solved.

Returns:

Homogenized cross section.

Return type:

CrossSection

2. homogenize(self: scarabee._scarabee.MOCDriver, regions: collections.abc.Sequence[typing.SupportsInt | typing.SupportsIndex]) -> scarabee._scarabee.CrossSection

Computes a homogenized set of cross sections for the set of provided region indices.

Parameters:

regions (list of int) – List of regions for homogenization.

Returns:

Homogenized cross section.

Return type:

CrossSection

homogenize_flux_spectrum(*args, **kwargs)

Overloaded function.

1. homogenize_flux_spectrum(self: scarabee._scarabee.MOCDriver) -> numpy.ndarray[numpy.float64]

Computes a homogenized flux spectrum based on the previously computed flux, which can be used for energy condensation. This method will raise an exception if the problem has not yet been solved.

Returns:

Homogenized flux spectrum.

Return type:

ndarray of floats

2. homogenize_flux_spectrum(self: scarabee._scarabee.MOCDriver, regions: collections.abc.Sequence[typing.SupportsInt | typing.SupportsIndex]) -> numpy.ndarray[numpy.float64]

Computes a homogenized flux spectrum based on the list of provided region indices. This method will raise an exception if the problem has not yet been solved.

Parameters:

regions (list of int) – List of regions for homogenization.

Returns:

Homogenized flux spectrum.

Return type:

ndarray of floats

property keff

Value of keff estimated by solver (1 by default if no solution has been obtained).

property keff_tolerance

Maximum relative absolute difference in keff for convergence.

static load(fname: str) → scarabee._scarabee.MOCDriver

Loads MOCDriver from a binary file.

Parameters:

fname (str) – Name of file.

property max_legendre_order

Maximum legendre order for scattering.

property nfsr

Number of flat source regions.

property ngroups

Number of energy groups.

property nregions

Number of flat source regions.

property num_spherical_harmonics

Number of spherical harmonics for storing the flux moments.

plot(self: scarabee._scarabee.MOCDriver) → None

Open the graphical MOC geometry plotting window.

property polar_quadrature

Quadrature used for polar angle integration.

rasterize_flux(self: scarabee._scarabee.MOCDriver, nx: SupportsInt | SupportsIndex, ny: SupportsInt | SupportsIndex) → tuple[numpy.ndarray[numpy.float64], numpy.ndarray[numpy.float64], numpy.ndarray[numpy.float64]]

Rasterizes the flux in all energy groups for easy plotting.

Parameters:

• nx (int) – Number of mesh bins along x.

• ny (int) – Number of mesh bins along y.

Returns:

• flux (ndarray) – Values of the flux. First index is group, second is y, third is x.

• x (ndarray) – Array of bounding x values.

• y (ndarray) – Array of bounding y values.

save(self: scarabee._scarabee.MOCDriver, fname: str) → None

Saves MOCDriver to a binary file.

Parameters:

fname (str) – Name of file.

set_extern_src(*args, **kwargs)

Overloaded function.

1. set_extern_src(self: scarabee._scarabee.MOCDriver, r: scarabee._scarabee.Vector, u: scarabee._scarabee.Direction, g: typing.SupportsInt | typing.SupportsIndex, src: typing.SupportsFloat | typing.SupportsIndex) -> None

Sets the external source in the Flat Source Region at r.

Parameters:

• r (Vector) – Position at which to set the source.

• u (Direction) – Direction vector used to disambiguate the FSR.

• g (int) – Energy group index.

• src (float) – Value of source in the FSR.

2. set_extern_src(self: scarabee._scarabee.MOCDriver, i: typing.SupportsInt | typing.SupportsIndex, g: typing.SupportsInt | typing.SupportsIndex, src: typing.SupportsFloat | typing.SupportsIndex) -> None

Sets the external source in Flat Source Region with index i.

Parameters:

• i (int) – Flat Source Region index.

• g (int) – Energy group index.

• src (float) – Value of source in the FSR.

property sim_mode

SimulationMode describing type of simulation (fixed-source or keff).

property size

Number of flat source regions.

solve(self: scarabee._scarabee.MOCDriver) → None

Begins iterations to solve problem.

property solved

True if solve has been run sucessfully (reset to false on generate_tracks).

trace_fsr_segments(self: scarabee._scarabee.MOCDriver, r_start: scarabee._scarabee.Vector, u: scarabee._scarabee.Direction) → list[tuple[int, float]]

Starting from a given position and direction, this function traces across the geometry until leaving the problem domain, returning a list of FSR index - distance pairs.

Parameters:

• r_start (Vector) – Starting position.

• u (Direction) – Direction to trace segments.

Returns:

All the FSR index - distance pairs.

Return type:

list of pairs of int and float

volume(*args, **kwargs)

Overloaded function.

1. volume(self: scarabee._scarabee.MOCDriver, r: scarabee._scarabee.Vector, u: scarabee._scarabee.Direction) -> float

Returns the volume of the Flat Source Region at position r.

Parameters:

• r (Vector) – Position at which to obtain flux.

• u (Direction) – Direction vector for disambiguating the cell region.

• Returns –

• float – Volume of the FSR at r.

2. volume(self: scarabee._scarabee.MOCDriver, i: typing.SupportsInt | typing.SupportsIndex) -> float

Returns the volume of Flat Source Region i.

Parameters:

i (int) – Flat Source Region index.

Returns:

Volume of FSR i.

Return type:

float

property x_max

Maximum value of x in problem domain.

property x_max_bc

BoundadaryCondition at x_max.

property x_min

Minimum value of x in problem domain.

property x_min_bc

BoundadaryCondition at x_min.

xs(*args, **kwargs)

Overloaded function.

1. xs(self: scarabee._scarabee.MOCDriver, r: scarabee._scarabee.Vector, u: scarabee._scarabee.Direction) -> scarabee._scarabee.CrossSection

Returns the CrossSection at position r.

Parameters:

• r (Vector) – Position at which to obtain flux.

• u (Direction) – Direction vector for disambiguating the cell region.

Returns:

Material cross sections at r.

Return type:

CrossSection

2. xs(self: scarabee._scarabee.MOCDriver, i: typing.SupportsInt | typing.SupportsIndex) -> scarabee._scarabee.CrossSection

Returns the CrossSection in Flat Source Region i.

Parameters:

i (int) – Flat Source Region index.

Returns:

Material cross sections at r.

Return type:

CrossSection

property y_max

Maximum value of y in problem domain.

property y_max_bc

BoundadaryCondition at y_max.

property y_min

Minimum value of y in problem domain.

property y_min_bc

BoundadaryCondition at y_min.

class scarabee.BoundaryCondition

Members:

Reflective

Vacuum

Periodic

__init__(self: scarabee._scarabee.BoundaryCondition, value: SupportsInt | SupportsIndex) → None

property name

class scarabee.SimulationMode

Members:

FixedSource

Keff

__init__(self: scarabee._scarabee.SimulationMode, value: SupportsInt | SupportsIndex) → None

property name

class scarabee.CMFD

__init__(self: scarabee._scarabee.CMFD, dx: collections.abc.Sequence[SupportsFloat | SupportsIndex], dy: collections.abc.Sequence[SupportsFloat | SupportsIndex], groups: collections.abc.Sequence[tuple[SupportsInt | SupportsIndex, SupportsInt | SupportsIndex]]) → None

A Cartesian mesh for accelerating MOC convergence.

Parameters:

• dx (list of float) – Widths along x axis.

• dy (list of float) – Widths along y axis.

• groups (list of 2D tuples of ints) – The scheme for condensing energy groups.

property check_neutron_balance

Flag indicating that the neutron balance should be checked in each CMFD tile on each CMFD solve. Should only be used for debugging purposes.

property condensation_scheme

Condensation scheme to go from the MOC group structure to the CMFD group structure.

current(self: scarabee._scarabee.CMFD, g: SupportsInt | SupportsIndex, surf: SupportsInt | SupportsIndex) → float

Returns the current on a CMFD cell boundary.

Parameters:

• g (int) – CMFD energy group.

• surf (int) – CMFD surface index.

Returns:

Tallied current in CMFD group g on surface surf.

Return type:

float

property damping

The damping factor used for under-relaxing the nonlinear diffusion coefficient between iterations.

property dx

List of tile widths along the x axis.

property dy

List of tile widths along the y axis.

flux(self: scarabee._scarabee.CMFD, i: SupportsInt | SupportsIndex, j: SupportsInt | SupportsIndex, g: SupportsInt | SupportsIndex) → float

Gets the CMFD flux in a desired tile and group.

Parameters:

• i (int.) – x index of tile.

• j (int.) – y index of tile.

• g (int.) – Energy group index.

Returns:

The CMFD scalar flux at cell (i,j) in group g.

Return type:

float

property flux_limiting

Whether or not to use the flux-limiting condition when calculatingthe surface and non-linear diffusion coefficients.

property flux_tolerance

Maximum relative absolute difference in flux for convergence.

get_surface(self: scarabee._scarabee.CMFD, r: scarabee._scarabee.Vector, u: scarabee._scarabee.Direction) → scarabee._scarabee.CMFDSurfaceCrossing

Obtains the CMFD surface crossing info for a provided position and direction.

Parameters:

• r (Vector) – Position of the desired point.

• u (Direction) – Direction vector for disambiguating the cell region.

Returns:

Contains the surface crossing information.

Return type:

CMFDSurfaceCrossing

get_tile(self: scarabee._scarabee.CMFD, r: scarabee._scarabee.Vector, u: scarabee._scarabee.Direction) → Annotated[list[int], 'FixedSize(2)'] | None

Finds the CMFD tile of a provided position and direction.

Parameters:

• r (Vector) – Position of the desired point.

• u (Direction) – Direction vector for disambiguating the cell region.

Returns:

The x and y tile indices.

Return type:

List of two ints

get_x_neg_surf(self: scarabee._scarabee.CMFD, i: SupportsInt | SupportsIndex, j: SupportsInt | SupportsIndex) → int

Obtains the index of negative x surface for tile (i,j).

Parameters:

• i (int.) – x index of tile.

• j (int.) – y index of tile.

Returns:

Index of the surface.

Return type:

int

get_x_pos_surf(self: scarabee._scarabee.CMFD, i: SupportsInt | SupportsIndex, j: SupportsInt | SupportsIndex) → int

Obtains the index of positive x surface for tile (i,j).

Parameters:

• i (int.) – x index of tile.

• j (int.) – y index of tile.

Returns:

Index of the surface.

Return type:

int

get_y_neg_surf(self: scarabee._scarabee.CMFD, i: SupportsInt | SupportsIndex, j: SupportsInt | SupportsIndex) → int

Obtains the index of negative y surface for tile (i,j).

Parameters:

• i (int.) – x index of tile.

• j (int.) – y index of tile.

Returns:

Index of the surface.

Return type:

int

get_y_pos_surf(self: scarabee._scarabee.CMFD, i: SupportsInt | SupportsIndex, j: SupportsInt | SupportsIndex) → int

Obtains the index of positive y surface for tile (i,j).

Parameters:

• i (int.) – x index of tile.

• j (int.) – y index of tile.

Returns:

Index of the surface.

Return type:

int

property keff_tolerance

Maximum relative absolute difference in keff for convergence.

property larsen_correction

Flag indicating use of Larsen’s corrected diffusion coefficient for optically thick meshes. Mutally exclusive with the od_cmfd flag.

property nx

Number of CMFD tiles along x.

property ny

Number of CMFD tiles along y.

property od_cmfd

Flag indicating use of optimally diffusive CMFD (odCMFD) to modify the diffusion coeffients. Mutally exclusive with the larsen_correction flag.

property skip_moc_iterations

Number of MOC iterations to skip before applying CMFD.

tally_current(self: scarabee._scarabee.CMFD, aflx: SupportsFloat | SupportsIndex, u: scarabee._scarabee.Direction, g: SupportsInt | SupportsIndex, surf: scarabee._scarabee.CMFDSurfaceCrossing) → None

Tallies the current onto the appropriate CMFD surface(s).

Parameters:

• aflx (float) – Value of the angular flux to be tallied.

• u (Direction) – Direction of the angular flux.

• g (int) – CMFD energy group index.

• surf (CMFDSurfaceCrossing) – Information for surfaces on which the current is tallied.

tile_fsr_list(self: scarabee._scarabee.CMFD, i: SupportsInt | SupportsIndex, j: SupportsInt | SupportsIndex) → list[int]

Obtains the list of flat source regions in tile (i,j).

Parameters:

• i (int.) – x index of tile.

• j (int.) – y index of tile.

Returns:

FSRs int the tile.

Return type:

List of int

property unbounded_cmfd_solves

Number of CMFD solves before flux update ratios are clamped to the range (0.05, 20).

class scarabee.P1CriticalitySpectrum

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: scarabee._scarabee.P1CriticalitySpectrum, xs: scarabee._scarabee.CrossSection) -> None

Computes the criticality energy spectrum using the P1 leakage approximation.

Parameters:

xs (CrossSection) – Homogenized set of cross sections for the system.

2. __init__(self: scarabee._scarabee.P1CriticalitySpectrum, xs: scarabee._scarabee.CrossSection, B2: typing.SupportsFloat | typing.SupportsIndex) -> None

Computes the flux and current energy spectrum using the P1 leakage approximation for a given buckling.

Parameters:

• xs (CrossSection) – Homogenized set of cross sections for the system.

• B2 (float) – Desired value of the buckling.

class scarabee.B1CriticalitySpectrum

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: scarabee._scarabee.B1CriticalitySpectrum, xs: scarabee._scarabee.CrossSection) -> None

Computes the criticality energy spectrum using the B1 leakage approximation.

Parameters:

xs (CrossSection) – Homogenized set of cross sections for the system.

2. __init__(self: scarabee._scarabee.B1CriticalitySpectrum, xs: scarabee._scarabee.CrossSection, B2: typing.SupportsFloat | typing.SupportsIndex) -> None

Computes the flux and current energy spectrum using the B1 leakage approximation for a given buckling.

Parameters:

• xs (CrossSection) – Homogenized set of cross sections for the system.

• B2 (float) – Desired value of the buckling.

class scarabee.FundamentalModeCriticalitySpectrum

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: scarabee._scarabee.FundamentalModeCriticalitySpectrum, xs: scarabee._scarabee.CrossSection) -> None

Computes the criticality energy spectrum using the fundamental mode leakage approximation.

Parameters:

xs (CrossSection) – Homogenized set of cross sections for the system.

2. __init__(self: scarabee._scarabee.FundamentalModeCriticalitySpectrum, xs: scarabee._scarabee.CrossSection, B2: typing.SupportsFloat | typing.SupportsIndex) -> None

Computes the flux and current energy spectrum using the fundamental mode leakage approximation for a given buckling.

Parameters:

• xs (CrossSection) – Homogenized set of cross sections for the system.

• B2 (float) – Desired value of the buckling.

Polar Quadratures

scarabee.PolarQuadrature

alias of Union[Legendre2, Legendre4, Legendre6, Legendre8, Legendre10, Legendre12, Legendre16, Legendre32, Legendre64, YamamotoTabuchi2, YamamotoTabuchi4, YamamotoTabuchi6]

class scarabee.YamamotoTabuchi2

__init__(self: scarabee._scarabee.YamamotoTabuchi2) → None

Two point Yamamoto-Tabuchi polar quadrature.

invs_sin(self: scarabee._scarabee.YamamotoTabuchi2) → list[float]

Array of inverse sine values.

sin(self: scarabee._scarabee.YamamotoTabuchi2) → list[float]

Array of sine values.

wgt(self: scarabee._scarabee.YamamotoTabuchi2) → list[float]

Array of weight values.

class scarabee.YamamotoTabuchi4

__init__(self: scarabee._scarabee.YamamotoTabuchi4) → None

Four point Yamamoto-Tabuchi polar quadrature.

invs_sin(self: scarabee._scarabee.YamamotoTabuchi4) → list[float]

Array of inverse sine values.

sin(self: scarabee._scarabee.YamamotoTabuchi4) → list[float]

Array of sine values.

wgt(self: scarabee._scarabee.YamamotoTabuchi4) → list[float]

Array of weight values.

class scarabee.YamamotoTabuchi6

__init__(self: scarabee._scarabee.YamamotoTabuchi6) → None

Six point Yamamoto-Tabuchi polar quadrature.

invs_sin(self: scarabee._scarabee.YamamotoTabuchi6) → list[float]

Array of inverse sine values.

sin(self: scarabee._scarabee.YamamotoTabuchi6) → list[float]

Array of sine values.

wgt(self: scarabee._scarabee.YamamotoTabuchi6) → list[float]

Array of weight values.

class scarabee.Legendre2

__init__(self: scarabee._scarabee.Legendre2) → None

Two point Legendre polar quadrature.

invs_sin(self: scarabee._scarabee.Legendre2) → list[float]

Array of inverse sine values.

sin(self: scarabee._scarabee.Legendre2) → list[float]

Array of sine values.

wgt(self: scarabee._scarabee.Legendre2) → list[float]

Array of weight values.

class scarabee.Legendre4

__init__(self: scarabee._scarabee.Legendre4) → None

Four point Legendre polar quadrature.

invs_sin(self: scarabee._scarabee.Legendre4) → list[float]

Array of inverse sine values.

sin(self: scarabee._scarabee.Legendre4) → list[float]

Array of sine values.

wgt(self: scarabee._scarabee.Legendre4) → list[float]

Array of weight values.

class scarabee.Legendre6

__init__(self: scarabee._scarabee.Legendre6) → None

Six point Legendre polar quadrature.

invs_sin(self: scarabee._scarabee.Legendre6) → list[float]

Array of inverse sine values.

sin(self: scarabee._scarabee.Legendre6) → list[float]

Array of sine values.

wgt(self: scarabee._scarabee.Legendre6) → list[float]

Array of weight values.

class scarabee.Legendre8

__init__(self: scarabee._scarabee.Legendre8) → None

Eight point Legendre polar quadrature.

invs_sin(self: scarabee._scarabee.Legendre8) → list[float]

Array of inverse sine values.

sin(self: scarabee._scarabee.Legendre8) → list[float]

Array of sine values.

wgt(self: scarabee._scarabee.Legendre8) → list[float]

Array of weight values.

class scarabee.Legendre10

__init__(self: scarabee._scarabee.Legendre10) → None

Ten point Legendre polar quadrature.

invs_sin(self: scarabee._scarabee.Legendre10) → list[float]

Array of inverse sine values.

sin(self: scarabee._scarabee.Legendre10) → list[float]

Array of sine values.

wgt(self: scarabee._scarabee.Legendre10) → list[float]

Array of weight values.

class scarabee.Legendre12

__init__(self: scarabee._scarabee.Legendre12) → None

Twelve point Legendre polar quadrature.

invs_sin(self: scarabee._scarabee.Legendre12) → list[float]

Array of inverse sine values.

sin(self: scarabee._scarabee.Legendre12) → list[float]

Array of sine values.

wgt(self: scarabee._scarabee.Legendre12) → list[float]

Array of weight values.

class scarabee.Legendre16

__init__(self: scarabee._scarabee.Legendre16) → None

Sixteen point Legendre polar quadrature.

invs_sin(self: scarabee._scarabee.Legendre16) → list[float]

Array of inverse sine values.

sin(self: scarabee._scarabee.Legendre16) → list[float]

Array of sine values.

wgt(self: scarabee._scarabee.Legendre16) → list[float]

Array of weight values.

class scarabee.Legendre32

__init__(self: scarabee._scarabee.Legendre32) → None

Thirty-two point Legendre polar quadrature.

invs_sin(self: scarabee._scarabee.Legendre32) → list[float]

Array of inverse sine values.

sin(self: scarabee._scarabee.Legendre32) → list[float]

Array of sine values.

wgt(self: scarabee._scarabee.Legendre32) → list[float]

Array of weight values.

class scarabee.Legendre64

__init__(self: scarabee._scarabee.Legendre64) → None

Sixty-four point Legendre polar quadrature.

invs_sin(self: scarabee._scarabee.Legendre64) → list[float]

Array of inverse sine values.

sin(self: scarabee._scarabee.Legendre64) → list[float]

Array of sine values.

wgt(self: scarabee._scarabee.Legendre64) → list[float]

Array of weight values.