skfdiff.core package

Subpackages

• skfdiff.core.backends package
  • Submodules
  • skfdiff.core.backends.base_backend module
  • skfdiff.core.backends.numba_backend module
  • skfdiff.core.backends.numpy_backend module
  • Module contents

Submodules

skfdiff.core.grid_builder module

class skfdiff.core.grid_builder.GridBuilder(system: skfdiff.core.system.PDESys)

Bases: object

U_from_fields(fields, t=0)

U_routine(unks, sizes: Tuple[int])

build_flat_from_idxs_mapper(sizes: Tuple[int])

build_idxs_from_flat_mapper(sizes: Tuple[int])

compute_domains(sizes: Tuple[int])

compute grid indices of all the model fields.

compute_flat_from_idxs(idxs, sizes: Tuple[int])

compute_flat_maps(sizes: Tuple[int])

compute_flat_to_unks(sizes: Tuple[int])

compute_gridinfo(sizes: Tuple[int])

compute_idxs(sizes: Tuple[int])

compute_idxs_from_flat(flatindex, sizes: Tuple[int])

compute_indices(sizes: Tuple[int])

compute grid indices of all the model fields.

compute_pivot_idx(shapes: Tuple[int])

compute_shapes(sizes: Tuple[int])

compute the shapes of all the model fields.

compute_sizes(sizes: Tuple[int])

compute the sizes of all the model fields.

compute_steps(sizes, lenghts)

compute the stepsize of all the independent variables.

compute_subgrids(sizes: Tuple[int])

compute_unks_to_flat(sizes: Tuple[int])

fields_from_U(U, fields, t=None)

fields_routine(U, sizes: Tuple[int])

get_relevant_ptrs(i: int, sizes: Tuple[int])

skfdiff.core.grid_builder.list_to_tuple_key(*args, **kwargs)

skfdiff.core.grid_builder.retrieve_cache(key, self)

skfdiff.core.spatial_schemes module

class skfdiff.core.spatial_schemes.FiniteDifferenceScheme(scheme: str = 'centered', accuracy: int = 2, offset: int = 0, pattern=<function all_derivatives>)

Bases: object

apply(expr)

pop_derivative(expr)

relevant_derivatives(expr)

skfdiff.core.spatial_schemes.all_derivatives(derivative, wrt)

skfdiff.core.spatial_schemes.as_finite_diff(derivative, coord, offset=0, accuracy=2, scheme='centered')

skfdiff.core.spatial_schemes.chain_schemes(schemes, expr, default_scheme='centered', default_accuracy=2)

skfdiff.core.spatial_schemes.upwind(velocity, unk, coord=None, accuracy=2)

skfdiff.core.system module

class skfdiff.core.system.BoundaryCondition(unknown, axis, pde=<class 'skfdiff.core.system.PDEquation'>, bcs: Union[str, Tuple[str, str], None] = NOTHING)

Bases: object

bcs_validator(attribute, value)

evaluate_side_patterns(node, coord, domain)

get(side, domains, evaluation_node, offset=None)

noflux_default()

class skfdiff.core.system.PDESys(evolution_equations, unknowns, parameters=NOTHING, coordinates=[], boundary_conditions: dict = NOTHING, subs: dict = NOTHING)

Bases: object

coordinates_dict

equation_dict

jacobian_columns

jacobian_values

mapper

parameters_dict

piecewise_system

unknowns_dict

class skfdiff.core.system.PDEquation(equation: str, unknowns, parameters=[], subs: dict = {}, boundary_conditions: dict = NOTHING, schemes: Sequence[skfdiff.core.spatial_schemes.FiniteDifferenceScheme] = (FiniteDifferenceScheme(scheme='centered', accuracy=2, offset=0), ), raw: bool = False, dirichlet_nodes: Sequence[Tuple[int, ...]] = NOTHING)

Bases: object

computation_domains

computation_nodes

coordinates_dict

domains(*node_coords)

get_distances(indexed)

get_domains(indexed)

get_ghost_equation(ghost, node)

is_in_bulk(indexed)

is_outside(indexed)

mapper

node_coords

node_coords_subs

parameters_dict

parsed_boundary_conditions

physical_domains

piecewise_system

stencils

unknowns_dict

skfdiff.core.system.dict_product(d)

skfdiff.core.system.list_conditions(domain)

skfdiff.core.system.list_node_coords(domain)

skfdiff.core.system.sign_distance(distance, domain)

skfdiff.core.system.target_axis(derivative, wrt, axis)

skfdiff.core.temporal_schemes module

This module regroups all the implemented temporal schemes. They are written as callable class which take the model and some control arguments at the init, and perform a computation step every time they are called.

The following solvers are implemented:

• Backward and Forward Euler, Crank-Nicolson method (with the Theta class)

• Some Rosenbrock Wanner schemes (up to the 6th order) with time controler

• All the scipy.integrate.ode integrators with the scipy_ode class.

class skfdiff.core.temporal_schemes.RODASPR(model, tol=0.1, time_stepping=True, max_iter=None, dt_min=None, safety_factor=0.9, solver='auto', recompute_target=True, iteratif_atol=0.001)

Bases: skfdiff.core.temporal_schemes.ROW_general

6th order Rosenbrock scheme, with time stepping

Parameters

• model (skfdiff.Model) – skfdiff Model

• tol (float, optional, default 1E-2) – tolerance factor for the time stepping. The time step will adapt to ensure that the maximum relative error on all fields stay under that value.

• time_stepping (bool, optional, default True) – allow a variable internal time-step to ensure good agreement between computing performance and accuracy.

• max_iter (float or None, optional, default None) – maximum internal iteration allowed

• dt_min (float or None, optional, default None) – minimum internal time step allowed

• recompute_target (bool, optional, default False) – if True a new computation is done when the target time is exceeded, interpolation used otherwise.

embeded_timestepping = True

name = 'RODASPR'

class skfdiff.core.temporal_schemes.ROS2(model)

Bases: skfdiff.core.temporal_schemes.ROW_general

Second order Rosenbrock scheme, without time stepping

Parameters

model (skfdiff.Model) – skfdiff Model

embeded_timestepping = False

name = 'ROS2'

class skfdiff.core.temporal_schemes.ROS3PRL(model, tol=0.1, time_stepping=True, max_iter=None, dt_min=None, safety_factor=0.9, solver='auto', recompute_target=True, iteratif_atol=0.001)

Bases: skfdiff.core.temporal_schemes.ROW_general

4th order Rosenbrock scheme, with time stepping

Parameters

• model (skfdiff.Model) – skfdiff Model

• tol (float, optional, default 1E-2) – tolerance factor for the time stepping. The time step will adapt to ensure that the maximum relative error on all fields stay under that value.

• time_stepping (bool, optional, default True) – allow a variable internal time-step to ensure good agreement between computing performance and accuracy.

• max_iter (float or None, optional, default None) – maximum internal iteration allowed

• dt_min (float or None, optional, default None) – minimum internal time step allowed

• recompute_target (bool, optional, default False) – if True a new computation is done when the target time is exceeded, interpolation used otherwise.

embeded_timestepping = True

name = 'ROS3PRL'

class skfdiff.core.temporal_schemes.ROS3PRw(model, tol=0.1, time_stepping=True, max_iter=None, dt_min=None, safety_factor=0.9, solver='auto', recompute_target=True, iteratif_atol=0.001)

Bases: skfdiff.core.temporal_schemes.ROW_general

Third order Rosenbrock scheme, with time stepping

Parameters

• model (skfdiff.Model) – skfdiff Model

• tol (float, optional, default 1E-2) – tolerance factor for the time stepping. The time step will adapt to ensure that the maximum relative error on all fields stay under that value.

• time_stepping (bool, optional, default True) – allow a variable internal time-step to ensure good agreement between computing performance and accuracy.

• max_iter (float or None, optional, default None) – maximum internal iteration allowed

• dt_min (float or None, optional, default None) – minimum internal time step allowed

• recompute_target (bool, optional, default False) – if True a new computation is done when the target time is exceeded, interpolation used otherwise.

embeded_timestepping = True

name = 'ROS3PRw'

class skfdiff.core.temporal_schemes.ROW_general(model, alpha, gamma, b, b_pred=None, time_stepping=False, tol=None, max_iter=None, dt_min=None, safety_factor=0.9, solver='auto', recompute_target=True, iteratif_atol=0.001, initial_dt=None)

Bases: skfdiff.core.temporal_schemes.TemporalScheme

Rosenbrock Wanner class of temporal solvers

The implementation and the different parameters can be found in http://www.digibib.tu-bs.de/?docid=00055262

class skfdiff.core.temporal_schemes.Stationnary(model, solver=<function spsolve>)

Bases: object

Solve the stationnary problem F(U) = 0

Parameters

• model (skfdiff.Model) – skfdiff Model

• solver (callable, optional, default scipy.sparse.linalg.spsolve) – method able to solve a Ax = b linear equation with A a sparse matrix. Take A and b as argument and return x.

class skfdiff.core.temporal_schemes.TemporalScheme

Bases: object

class skfdiff.core.temporal_schemes.Theta(model, theta=1, solver=<function spsolve>)

Bases: skfdiff.core.temporal_schemes.TemporalScheme

Simple theta-based scheme where theta is a weight

if theta = 0, the scheme is a forward-euler scheme if theta = 1, the scheme is a backward-euler scheme if theta = 0.5, the scheme is called a Crank-Nicolson scheme

Parameters

• model (skfdiff.Model) – skfdiff Model

• theta (int, optional, default 1) – weight of the theta-scheme

• solver (callable, optional, default scipy.sparse.linalg.spsolve) – method able to solve a Ax = b linear equation with A a sparse matrix. Take A and b as argument and return x.

embeded_timestepping = False

name = 'theta'

skfdiff.core.temporal_schemes.add_time_stepping(scheme, tol=0.01, ord=2, m=20, reject_factor=2)

skfdiff.core.temporal_schemes.get_temporal_scheme(name)

get a temporal_scheme by its name

Parameters

{str} -- temporal_scheme name (name) –

Raises

NotImplementedError -- raised if the temporal_scheme is not available. –

Returns

TemporalScheme – the requested temporal_scheme

skfdiff.core.temporal_schemes.null_hook(t, fields)

skfdiff.core.temporal_schemes.register_temporal_scheme(CustomTemporalScheme)

class skfdiff.core.temporal_schemes.scipy_ivp(model, use_jac=True, method='RK45', **integrator_kwargs)

Bases: skfdiff.core.temporal_schemes.TemporalScheme

Proxy written around the scipy.integrate.solve_ivp function. Give access to all the scipy integrators.

Parameters

• model (skfdiff.Model) – skfdiff Model

• method (str, optional, default 'RK45') – name of the chosen scipy integration scheme.

• **integrator_kwargs – extra arguments provided to the scipy integration scheme.

embeded_timestepping = True

name = 'scipy_ivp'

skfdiff.core.variables module

class skfdiff.core.variables.Coordinate(name)

Bases: object

N

bound

c_Ns

c_bounds

c_discs

c_idxs

c_names

c_step_values

c_steps

c_symbols

check(attrs, value)

coords

discrete

distance_from_domain(node_coord)

distances(node_coord)

domain(node_coord)

domains(*node_coords)

get_node_coord(domain)

idx

is_in_bulk(node_coord)

step

step_value

symbol

class skfdiff.core.variables.Unknown(name: str)

Bases: object

c_Ns

c_bounds

c_discs

c_idxs

c_names

c_step_values

c_steps

c_symbols

coords

discrete

discrete_i

distances(*node_coords)

domains(*node_coords)

is_in_bulk(*node_coords)

node_coords

node_coords_subs

physical_domains

symbol

Module contents