Dipole¶

Fields¶

cfsem.flux_density_dipole ¶

flux_density_dipole(
    loc: Array3xN,
    moment: Array3xN,
    xyzp: Array3xN,
    par: bool = True,
    outer_radius: NDArray[float64] | None = None,
) -> Array3xN

Magnetic flux density of a dipole in cartesian coordiantes.

Parameters:

Name	Type	Description	Default
`loc`	`Array3xN`	[m] x,y,z coordinates of dipole	required
`moment`	`Array3xN`	[A-m^2] dipole magnetic moment vector	required
`xyzp`	`Array3xN`	[m] x,y,z coords of observation points	required
`par`	`bool`	Whether to use CPU parallelism	`True`
`outer_radius`	`NDArray[float64] \| None`	[m] radius inside which to defer to magnetized sphere calc. Defaults to zeroes.	`None`

Returns:

Type	Description
`Array3xN`	[T] flux density

Source code in cfsem/bindings.py

def flux_density_dipole(
    loc: Array3xN,
    moment: Array3xN,
    xyzp: Array3xN,
    par: bool = True,  # Ordered for backwards compatibility
    outer_radius: NDArray[float64] | None = None,
) -> Array3xN:
    """
    Magnetic flux density of a dipole in cartesian coordiantes.

    Args:
        loc: [m] x,y,z coordinates of dipole
        moment: [A-m^2] dipole magnetic moment vector
        xyzp: [m] x,y,z coords of observation points
        par: Whether to use CPU parallelism
        outer_radius: [m] radius inside which to defer to magnetized sphere calc. Defaults to zeroes.


    Returns:
        [T] flux density
    """
    loc = _3tup_contig(loc)
    moment = _3tup_contig(moment)
    xyzp = _3tup_contig(xyzp)
    outer_radius = outer_radius if outer_radius is not None else zeros_like(loc[0])
    outer_radius = ascontiguousarray(outer_radius).ravel()

    bx, by, bz = em_flux_density_dipole(loc, moment, xyzp, outer_radius, par)  # [T]

    return bx, by, bz

cfsem.flux_density_dipole_hierarchical `builtin` ¶

flux_density_dipole_hierarchical(
    loc: ArrayTriple,
    moment: ArrayTriple,
    obs: ArrayTriple,
    outer_radius: FloatArray,
    theta: float = 0.01,
    construction_method: str = "longest_axis",
    par: bool = True,
    out: ArrayTriple | None = None,
    extra_diagnostics: bool = False,
) -> SolveResult

Evaluate dipole flux density with the hierarchical solver from Python inputs.

cfsem.vector_potential_dipole ¶

vector_potential_dipole(
    loc: Array3xN,
    moment: Array3xN,
    xyzp: Array3xN,
    par: bool = True,
    outer_radius: NDArray[float64] | None = None,
) -> Array3xN

Magnetic vector potential of a dipole in cartesian coordiantes.

Parameters:

Name	Type	Description	Default
`loc`	`Array3xN`	[m] x,y,z coordinates of dipole	required
`moment`	`Array3xN`	[A-m^2] dipole magnetic moment vector	required
`xyzp`	`Array3xN`	[m] x,y,z coords of observation points	required
`par`	`bool`	Whether to use CPU parallelism	`True`
`outer_radius`	`NDArray[float64] \| None`	[m] radius inside which to defer to magnetized sphere calc. Defaults to zeroes.	`None`

Returns:

Type	Description
`Array3xN`	[V⋅s⋅m-1] vector potential

Source code in cfsem/bindings.py

def vector_potential_dipole(
    loc: Array3xN,
    moment: Array3xN,
    xyzp: Array3xN,
    par: bool = True,  # Ordered for backwards compatibility
    outer_radius: NDArray[float64] | None = None,
) -> Array3xN:
    """
    Magnetic vector potential of a dipole in cartesian coordiantes.

    Args:
        loc: [m] x,y,z coordinates of dipole
        moment: [A-m^2] dipole magnetic moment vector
        xyzp: [m] x,y,z coords of observation points
        par: Whether to use CPU parallelism
        outer_radius: [m] radius inside which to defer to magnetized sphere calc. Defaults to zeroes.

    Returns:
        [V⋅s⋅m-1] vector potential
    """
    loc = _3tup_contig(loc)
    moment = _3tup_contig(moment)
    xyzp = _3tup_contig(xyzp)
    outer_radius = outer_radius if outer_radius is not None else zeros_like(loc[0])
    outer_radius = ascontiguousarray(outer_radius).ravel()

    ax, ay, az = em_vector_potential_dipole(loc, moment, xyzp, outer_radius, par)  # [T]

    return ax, ay, az

cfsem.vector_potential_dipole_hierarchical `builtin` ¶

vector_potential_dipole_hierarchical(
    loc: ArrayTriple,
    moment: ArrayTriple,
    obs: ArrayTriple,
    outer_radius: FloatArray,
    theta: float = 0.01,
    construction_method: str = "longest_axis",
    par: bool = True,
    out: ArrayTriple | None = None,
    extra_diagnostics: bool = False,
) -> SolveResult

Evaluate dipole vector potential with the hierarchical solver from Python inputs.