Working with Values of Potentials

Visualization of Potentials

sumpy.visualization.make_field_plotter_from_bbox(bbox: tuple[onp.Array1D[floating[Any]], onp.Array1D[floating[Any]]], h: float | Sequence[float], extend_factor: float = 0) → FieldPlotter

Parameters:

• bbox – a tuple (low, high) of points represented as 1D numpy arrays indicating the low and high ends of the extent of a bounding box.

• h – Either a number or a sequence of numbers indicating the desired (approximate) grid spacing in all or each of the dimensions. If a sequence, the length must match the number of dimensions.

• extend_factor – A floating point number indicating by what percentage the plot area should be grown compared to bbox.

class sumpy.visualization.FieldPlotter(center: onp.ToArray1D[floating[Any]], extent: float | onp.Array1D[floating[Any]] = 1, npoints: int | tuple[int, ...] = 1000, points: onp.ArrayND[floating[Any]] | None = None)

dimensions: int

npoints: int

points: onp.Array2D[floating[Any]]

set_matplotlib_limits() → None

show_scalar_in_matplotlib(fld: onp.ArrayND[Any], max_val: float | None = None, func_name: str = 'imshow', **kwargs: Any) → Any

show_scalar_in_mayavi(fld: onp.ArrayND[Any], max_val: float | None = None, **kwargs: Any) → None

write_vtk_file(file_name: str | pathlib.Path, data: Iterable[tuple[str, onp.ArrayND[Any]]], *, real_only: bool = False, overwrite: bool = False) → None

Differentiation of Potentials

sumpy.point_calculus.NodesKind

alias of Literal[‘chebyshev’, ‘equispaced’, ‘legendre’]

class sumpy.point_calculus.InexactT

alias of TypeVar(‘InexactT’, bound=inexact[Any])

class sumpy.point_calculus.NodesKind

class sumpy.point_calculus.CalculusPatch(center: ndarray[floating[Any]], h: float = 0.1, order: int = 4, nodes: NodesKind = 'chebyshev')

Sets up a grid of points on which derivatives can be calculated. Useful to verify that an evaluated potential actually solves a PDE.

dim: int

npoints: int

points: ndarray[floating[Any]]

Shape: (dim, npoints).

center: ndarray[floating[Any]]

weights() → ndarray[floating[Any]]

Returns:

a vector of high-order quadrature weights on the points

basis() → Sequence[Callable[[ndarray[floating[Any]]], ndarray[floating[Any]]]]

Returns:

a list containing functions that realize a high-order interpolation basis on the points.

diff(axis: int, f_values: number[Any] | complex, nderivs: int = 1) → Literal[0]

diff(axis: int, f_values: ndarray[InexactT], nderivs: int = 1) → ndarray[InexactT]

Return the derivative along axis of f_values.

Parameters:

f_values – an array of shape (npoints,)

Returns:

an array of shape (npoints,)

dx(f_values: ndarray[InexactT]) → ndarray[InexactT]

dy(f_values: ndarray[InexactT]) → ndarray[InexactT]

dz(f_values: ndarray[InexactT]) → ndarray[InexactT]

laplace(f_values: ndarray[InexactT]) → ndarray[InexactT]

Return the Laplacian of f_values.

Parameters:

f_values – an array of shape (npoints,)

Returns:

an array of shape (npoints,) representing the application of the Laplacian to f_values.

div(arg: ObjectArray1D[ndarray[InexactT]]) → ndarray[InexactT]

Parameters:

arg – an object array containing numpy.ndarrays with shape (npoints,).

curl(arg: ObjectArray1D[ndarray[InexactT]]) → ObjectArray1D[ndarray[InexactT]]

Take the curl of the vector quantity arg.

Parameters:

arg – an object array of shape (3,) containing numpy.ndarrays with shape (npoints,).

eval_at_center(f_values: ndarray[InexactT]) → InexactT

Interpolate f_values to the center point.

Parameters:

f_values – an array of shape (npoints,)

Returns:

a scalar.

property x: ndarray[floating[Any]]

property y: ndarray[floating[Any]]

property z: ndarray[floating[Any]]

norm(arg: ObjectArray1D[ndarray[InexactT]] | ndarray[InexactT], p: float) → floating[Any]

plot_nodes() → None

plot(f: ndarray[floating[Any]]) → None

sumpy.point_calculus.frequency_domain_maxwell(cpatch: CalculusPatch, e: ObjectArray1D[ndarray[complexfloating[Any]]], h: ObjectArray1D[ndarray[complexfloating[Any]]], k: complex) → tuple[ObjectArray1D[ndarray[complexfloating[Any]]], ObjectArray1D[ndarray[complexfloating[Any]]], ndarray[complexfloating[Any]], ndarray[complexfloating[Any]]]

Support for Numerical Experiments with Expansions (“Expansion toys”)

This module provides a convenient interface for numerical experiments with local and multipole expansions.

class sumpy.toys.ToyContext(kernel: Kernel, mpole_expn_class: MultipoleExpansionFactory | None = None, local_expn_class: LocalExpansionFactory | None = None, expansion_factory: ExpansionFactoryBase | None = None, extra_source_kwargs: Mapping[str, object] | None = None, extra_kernel_kwargs: Mapping[str, object] | None = None, m2l_use_fft: bool | None = None)

This class functions as a container for generated code and ‘behind-the-scenes’ information.

__init__(kernel: Kernel, mpole_expn_class: MultipoleExpansionFactory | None = None, local_expn_class: LocalExpansionFactory | None = None, expansion_factory: ExpansionFactoryBase | None = None, extra_source_kwargs: Mapping[str, object] | None = None, extra_kernel_kwargs: Mapping[str, object] | None = None, m2l_use_fft: bool | None = None)

class sumpy.toys.PotentialSource(toy_ctx: ToyContext)

A base class for all classes representing potentials that can be evaluated anywhere in space.

eval(actx: ArrayContext, targets: np.ndarray) → np.ndarray

Parameters:

targets – An array of shape (dim, ntargets).

Returns:

an array of shape (ntargets,).

Supports (lazy) arithmetic:

__neg__() → PotentialSource

__add__(other: int | float | complex | number | PotentialSource) → PotentialSource

__radd__(other: int | float | complex | number | PotentialSource) → PotentialSource

__sub__(other: int | float | complex | number | PotentialSource) → PotentialSource

__rsub__(other: int | float | complex | number | PotentialSource) → PotentialSource

__mul__(other: int | float | complex | number | PotentialSource) → PotentialSource

__rmul__(other: int | float | complex | number | PotentialSource) → PotentialSource

class sumpy.toys.ConstantPotential(toy_ctx: ToyContext, value)

Inherits from PotentialSource.

__init__(toy_ctx: ToyContext, value)

class sumpy.toys.PointSources(toy_ctx: ToyContext, points: ndarray, weights: ndarray, center: ndarray | None = None)

Inherits from PotentialSource.

points

[ndim, npoints]

__init__(toy_ctx: ToyContext, points: ndarray, weights: ndarray, center: ndarray | None = None)

These functions manipulate these potentials:

sumpy.toys.multipole_expand(actx: ArrayContext, psource: PotentialSource, center: np.ndarray, *, order: int | None = None, rscale: float = 1, **expn_kwargs: Any) → MultipoleExpansion

sumpy.toys.local_expand(actx: ArrayContext, psource: PotentialSource, center: np.ndarray, *, order: int | None = None, rscale: float = 1, **expn_kwargs: Any) → LocalExpansion

sumpy.toys.logplot(actx: ArrayContext, fp: FieldPlotter, psource: PotentialSource, **kwargs) → None

sumpy.toys.combine_inner_outer(psource_inner: PotentialSource, psource_outer: PotentialSource, radius: float | None, center: ndarray | None = None) → PotentialSource

sumpy.toys.combine_halfspace(psource_pos: PotentialSource, psource_neg: PotentialSource, axis: int, center: ndarray | None = None) → PotentialSource

sumpy.toys.combine_halfspace_and_outer(psource_pos: PotentialSource, psource_neg: PotentialSource, psource_outer: PotentialSource, axis: int, radius: float | None = None, center: ndarray | None = None) → PotentialSource

sumpy.toys.l_inf(actx: ArrayContext, psource: PotentialSource, radius: float, center: np.ndarray | None = None, npoints: int = 100, debug: bool = False) → number

These functions help with plotting:

sumpy.toys.draw_box(el, eh, **kwargs)

sumpy.toys.draw_circle(center, radius, **kwargs)

sumpy.toys.draw_annotation(to_pt, from_pt, label, arrowprops=None, **kwargs)

Parameters:

• to_pt – Head of arrow

• from_pt – Tail of arrow

• label – Annotation label

• arrowprops – Passed to arrowprops

• kwargs – Passed to annotate

sumpy.toys.draw_schematic(psource, **kwargs)

These are created behind the scenes and are not typically directly instantiated by users:

class sumpy.toys.OneOnBallPotential(toy_ctx: ToyContext, center: ndarray, radius: float)

A potential that is the characteristic function on a ball.

Inherits from PotentialSource.

__init__(toy_ctx: ToyContext, center: ndarray, radius: float) → None

class sumpy.toys.HalfspaceOnePotential(toy_ctx: ToyContext, center: ndarray, axis: int, side: int = 1)

A potential that is the characteristic function of a halfspace.

__init__(toy_ctx: ToyContext, center: ndarray, axis: int, side: int = 1) → None

class sumpy.toys.ExpansionPotentialSource(toy_ctx, center, rscale, order: int, coeffs, derived_from, radius=None, expn_style=None, text_kwargs=None)

Inherits from PotentialSource.

radius

Not used mathematically. Just for visualization, purely advisory.

text_kwargs

Passed to matplotlib.pyplot.annotate(). Used for customizing the expansion label. Changing the label text is supported by passing the kwarg s. Just for visualization, purely advisory.

__init__(toy_ctx, center, rscale, order: int, coeffs, derived_from, radius=None, expn_style=None, text_kwargs=None)

class sumpy.toys.MultipoleExpansion(toy_ctx, center, rscale, order: int, coeffs, derived_from, radius=None, expn_style=None, text_kwargs=None)

Inherits from ExpansionPotentialSource.

class sumpy.toys.LocalExpansion(toy_ctx, center, rscale, order: int, coeffs, derived_from, radius=None, expn_style=None, text_kwargs=None)

Inherits from ExpansionPotentialSource.

class sumpy.toys.PotentialExpressionNode(psources: Sequence[PotentialSource])

Inherits from PotentialSource.

__init__(psources: Sequence[PotentialSource]) → None

class sumpy.toys.Sum(psources: Sequence[PotentialSource])

Inherits from PotentialExpressionNode.

class sumpy.toys.Product(psources: Sequence[PotentialSource])

Inherits from PotentialExpressionNode.

class sumpy.toys.SchematicVisitor(default_expn_style='circle')