Skip to content

Electromagnetics constraints¤

Boundary conditions¤

phydrax.constraints.ContinuousPECBoundaryConstraint(field_var: str, component: DomainComponent, /, *, var: str = 'x', num_points: int | tuple[Any, ...], structure: Any, sampler: str = 'latin_hypercube', weight: DomainFunction | ArrayLike = 1.0, label: str | None = None, over: str | tuple[str, ...] | None = None, reduction: Literal[mean, integral] = 'mean') -> FunctionalConstraint ¤

Perfect electric conductor (PEC) boundary condition.

For an electric field \(E\), PEC implies the tangential component vanishes:

\[ E_t = (I-n\otimes n)\,E = 0, \]

equivalently \(n\times E = 0\).

phydrax.constraints.ContinuousPMCBoundaryConstraint(field_var: str, component: DomainComponent, /, *, var: str = 'x', num_points: int | tuple[Any, ...], structure: Any, sampler: str = 'latin_hypercube', weight: DomainFunction | ArrayLike = 1.0, label: str | None = None, over: str | tuple[str, ...] | None = None, reduction: Literal[mean, integral] = 'mean') -> FunctionalConstraint ¤

Perfect magnetic conductor (PMC) boundary condition.

For a magnetic field \(H\), PMC implies the tangential component vanishes:

\[ H_t = (I-n\otimes n)\,H = 0, \]

equivalently \(n\times H = 0\).

phydrax.constraints.ContinuousImpedanceBoundaryConstraint(h_var: str, e_var: str, component: DomainComponent, /, *, admittance: DomainFunction | ArrayLike, var: str = 'x', num_points: int | tuple[Any, ...], structure: Any, sampler: str = 'latin_hypercube', weight: DomainFunction | ArrayLike = 1.0, label: str | None = None, over: str | tuple[str, ...] | None = None, reduction: Literal[mean, integral] = 'mean') -> FunctionalConstraint ¤

Impedance (Leontovich) boundary condition.

Enforces a linear relation between tangential \(E\) and \(H\):

\[ n\times H = Y\,E_t, \]

where admittance is \(Y\) and \(E_t\) is the tangential projection of \(E\).

phydrax.constraints.ContinuousElectricSurfaceChargeBoundaryConstraint(field_var: str, component: DomainComponent, /, *, epsilon: DomainFunction | ArrayLike, surface_charge: DomainFunction | ArrayLike, var: str = 'x', num_points: int | tuple[Any, ...], structure: Any, sampler: str = 'latin_hypercube', weight: DomainFunction | ArrayLike = 1.0, label: str | None = None, over: str | tuple[str, ...] | None = None, reduction: Literal[mean, integral] = 'mean') -> FunctionalConstraint ¤

Surface charge boundary condition for the electric field.

Enforces a normal-flux condition

\[ \epsilon\,E\cdot n = \rho_s, \]

where \(\rho_s\) is a prescribed surface charge density.

phydrax.constraints.ContinuousMagneticSurfaceCurrentBoundaryConstraint(field_var: str, component: DomainComponent, /, *, surface_current: DomainFunction | ArrayLike, var: str = 'x', num_points: int | tuple[Any, ...], structure: Any, sampler: str = 'latin_hypercube', weight: DomainFunction | ArrayLike = 1.0, label: str | None = None, over: str | tuple[str, ...] | None = None, reduction: Literal[mean, integral] = 'mean') -> FunctionalConstraint ¤

Surface current boundary condition for the magnetic field.

Enforces the tangential jump condition

\[ n\times H = K_s, \]

where \(K_s\) is a prescribed surface current density.

phydrax.constraints.ContinuousInterfaceNormalBContinuityConstraint(h1_var: str, h2_var: str, component: DomainComponent, /, *, mu1: DomainFunction | ArrayLike, mu2: DomainFunction | ArrayLike, var: str = 'x', num_points: int | tuple[Any, ...], structure: Any, sampler: str = 'latin_hypercube', weight: DomainFunction | ArrayLike = 1.0, label: str | None = None, over: str | tuple[str, ...] | None = None, reduction: Literal[mean, integral] = 'mean') -> FunctionalConstraint ¤

Normal continuity of magnetic flux density across an interface.

For \(B=\mu H\), enforces

\[ (B_2 - B_1)\cdot n = 0, \]

i.e. \(\mu_2 H_2\cdot n - \mu_1 H_1\cdot n = 0\).

phydrax.constraints.ContinuousInterfaceNormalDJumpConstraint(e1_var: str, e2_var: str, component: DomainComponent, /, *, epsilon1: DomainFunction | ArrayLike, epsilon2: DomainFunction | ArrayLike, surface_charge: DomainFunction | ArrayLike | None = None, var: str = 'x', num_points: int | tuple[Any, ...], structure: Any, sampler: str = 'latin_hypercube', weight: DomainFunction | ArrayLike = 1.0, label: str | None = None, over: str | tuple[str, ...] | None = None, reduction: Literal[mean, integral] = 'mean') -> FunctionalConstraint ¤

Normal jump condition for electric displacement across an interface.

For \(D=\epsilon E\), enforces

\[ (D_2 - D_1)\cdot n = \rho_s, \]

i.e. \(\epsilon_2 E_2\cdot n - \epsilon_1 E_1\cdot n = \rho_s\).

phydrax.constraints.ContinuousInterfaceTangentialEContinuityConstraint(e1_var: str, e2_var: str, component: DomainComponent, /, *, var: str = 'x', num_points: int | tuple[Any, ...], structure: Any, sampler: str = 'latin_hypercube', weight: DomainFunction | ArrayLike = 1.0, label: str | None = None, over: str | tuple[str, ...] | None = None, reduction: Literal[mean, integral] = 'mean') -> FunctionalConstraint ¤

Tangential continuity of electric field across an interface.

Enforces \((E_2 - E_1)_t = 0\), i.e. tangential \(E\) is continuous across the interface.

phydrax.constraints.ContinuousInterfaceTangentialHJumpConstraint(h1_var: str, h2_var: str, component: DomainComponent, /, *, surface_current: DomainFunction | ArrayLike | None = None, var: str = 'x', num_points: int | tuple[Any, ...], structure: Any, sampler: str = 'latin_hypercube', weight: DomainFunction | ArrayLike = 1.0, label: str | None = None, over: str | tuple[str, ...] | None = None, reduction: Literal[mean, integral] = 'mean') -> FunctionalConstraint ¤

Tangential jump condition for magnetic field across an interface.

Enforces

\[ n\times(H_2 - H_1) = K_s, \]

where \(K_s\) is an optional surface current density (defaults to \(0\)).

phydrax.constraints.DiscretePECBoundaryConstraint(field_var: str, component: DomainComponent, /, *, points: Mapping[str, ArrayLike] | ArrayLike, var: str = 'x', weight: DomainFunction | ArrayLike = 1.0, label: str | None = None, reduction: Literal[mean, sum] = 'mean') -> PointSetConstraint ¤

Discrete PEC constraint at explicit boundary anchor points.

phydrax.constraints.DiscretePMCBoundaryConstraint(field_var: str, component: DomainComponent, /, *, points: Mapping[str, ArrayLike] | ArrayLike, var: str = 'x', weight: DomainFunction | ArrayLike = 1.0, label: str | None = None, reduction: Literal[mean, sum] = 'mean') -> PointSetConstraint ¤

Discrete PMC constraint at explicit boundary anchor points.

phydrax.constraints.DiscreteElectricSurfaceChargeBoundaryConstraint(field_var: str, component: DomainComponent, /, *, points: Mapping[str, ArrayLike] | ArrayLike, surface_charge_values: ArrayLike, epsilon: DomainFunction | ArrayLike, var: str = 'x', weight: DomainFunction | ArrayLike = 1.0, label: str | None = None, reduction: Literal[mean, sum] = 'mean') -> PointSetConstraint ¤

Discrete surface charge constraint at explicit boundary anchor points.

phydrax.constraints.DiscreteMagneticSurfaceCurrentBoundaryConstraint(field_var: str, component: DomainComponent, /, *, points: Mapping[str, ArrayLike] | ArrayLike, surface_current_values: ArrayLike, var: str = 'x', weight: DomainFunction | ArrayLike = 1.0, label: str | None = None, reduction: Literal[mean, sum] = 'mean') -> PointSetConstraint ¤

Discrete surface current constraint at explicit boundary anchor points.

phydrax.constraints.DiscreteInterfaceNormalBContinuityConstraint(field_var: str, component: DomainComponent, /, *, points: Mapping[str, ArrayLike] | ArrayLike, values: ArrayLike, mu: DomainFunction | ArrayLike, var: str = 'x', weight: DomainFunction | ArrayLike = 1.0, label: str | None = None, reduction: Literal[mean, sum] = 'mean') -> PointSetConstraint ¤

Discrete normal magnetic flux continuity constraint at explicit interface points.

phydrax.constraints.DiscreteInterfaceNormalDJumpConstraint(field_var: str, component: DomainComponent, /, *, points: Mapping[str, ArrayLike] | ArrayLike, values: ArrayLike, epsilon: DomainFunction | ArrayLike, var: str = 'x', weight: DomainFunction | ArrayLike = 1.0, label: str | None = None, reduction: Literal[mean, sum] = 'mean') -> PointSetConstraint ¤

Discrete normal electric displacement jump constraint at explicit interface points.

phydrax.constraints.DiscreteInterfaceTangentialEContinuityConstraint(field_var: str, component: DomainComponent, /, *, points: Mapping[str, ArrayLike] | ArrayLike, tangential_values: ArrayLike, var: str = 'x', weight: DomainFunction | ArrayLike = 1.0, label: str | None = None, reduction: Literal[mean, sum] = 'mean') -> PointSetConstraint ¤

Discrete tangential electric continuity constraint at explicit interface points.

phydrax.constraints.DiscreteInterfaceTangentialHJumpConstraint(field_var: str, component: DomainComponent, /, *, points: Mapping[str, ArrayLike] | ArrayLike, Ks_values: ArrayLike, var: str = 'x', weight: DomainFunction | ArrayLike = 1.0, label: str | None = None, reduction: Literal[mean, sum] = 'mean') -> PointSetConstraint ¤

Discrete tangential magnetic jump constraint at explicit interface points.

Integral / global constraints¤

phydrax.constraints.EMBoundaryChargeConstraint(field_var: str, domain, /, *, total_free_charge: ArrayLike, var: str = 'x', num_points: NumPoints | tuple[Any, ...], structure: ProductStructure | None = None, sampler: str = 'latin_hypercube', weight: ArrayLike = 1.0, label: str | None = None, over: str | tuple[str, ...] | None = None, where: Mapping[str, Callable] | None = None, where_all: DomainFunction | None = None) -> IntegralEqualityConstraint ¤

Boundary integral constraint for total free charge (Gauss law).

For an electric displacement-like field \(D\), Gauss' law implies

\[ \int_{\partial\Omega} D\cdot n\,dS = Q_{\text{free}}. \]

This enforces that equality with total_free_charge.

phydrax.constraints.EMPoyntingFluxBoundaryConstraint(e_var: str, h_var: str, domain, /, *, target_total_power: ArrayLike, num_points: NumPoints | tuple[Any, ...], structure: ProductStructure | None = None, sampler: str = 'latin_hypercube', weight: ArrayLike = 1.0, label: str | None = None, over: str | tuple[str, ...] | None = None, where: Mapping[str, Callable] | None = None, where_all: DomainFunction | None = None) -> IntegralEqualityConstraint ¤

Boundary integral constraint for Poynting flux (electromagnetic power).

The Poynting vector is \(S = E\times H\). This enforces

\[ \int_{\partial\Omega} (E\times H)\cdot n\,dS = P. \]

phydrax.constraints.MagneticFluxZeroConstraint(field_var: str, domain, /, *, var: str = 'x', num_points: NumPoints | tuple[Any, ...], structure: ProductStructure | None = None, sampler: str = 'latin_hypercube', weight: ArrayLike = 1.0, label: str | None = None, over: str | tuple[str, ...] | None = None, where: Mapping[str, Callable] | None = None, where_all: DomainFunction | None = None) -> IntegralEqualityConstraint ¤

Boundary integral constraint enforcing zero net magnetic flux.

For a magnetic flux density field \(B\), one form of \(\nabla\cdot B = 0\) is

\[ \int_{\partial\Omega} B\cdot n\,dS = 0. \]