Thin wires

This page covers the thin-wire model in witwin.maxwell: ThinWire, WireConductor, WireEnd, and WireData. Use it for wires much thinner than a grid cell, such as dipole arms, feed lines, and loops. A thin wire is not voxelized. Maxwell keeps its physical radius and couples a current/charge network on the wire to the Yee grid, so you do not need to resolve the radius with the mesh.

The workflow has three steps:

1. Build each wire as a ThinWire with a centerline, a radius, and a WireConductor.
2. Add the wires to the scene with Scene(thin_wires=...) or Scene.add_thin_wire(wire). Wires are kept apart from volume structures and are read back through the read-only Scene.thin_wires tuple. Wire names must be unique in a scene.
3. To read wire current, charge, or loss, add a WireMonitor that names the wire. After the run, result.monitor(name) returns a WireData.

To drive a wire, bind a LumpedPort or TerminalPort to wire points with WirePortBinding and WireNodeRef (see Ports).

import torch
import witwin.maxwell as mw
 
dx = 1.25e-3
arm = torch.linspace(0.5 * dx, 0.024, 21)
negative_arm = mw.ThinWire("negative_arm", tuple((0.0, 0.0, -float(z)) for z in arm.flip(0)),
                           0.05 * dx, mw.WireConductor.pec(), snap="continuous")
positive_arm = mw.ThinWire("positive_arm", tuple((0.0, 0.0, float(z)) for z in arm),
                           0.05 * dx, mw.WireConductor.pec(), snap="continuous")
feed = mw.LumpedPort("feed", wire_binding=mw.WirePortBinding.nodes(
    negative=mw.WireNodeRef("negative_arm", 20), positive=mw.WireNodeRef("positive_arm", 0)))
scene = mw.Scene(
    domain=mw.Domain(bounds=((-0.05, 0.05),) * 3), grid=mw.GridSpec.uniform(dx),
    boundary=mw.BoundarySpec.pml(num_layers=8),
    thin_wires=(negative_arm, positive_arm), ports=(feed,),
    monitors=(mw.WireMonitor("arm_state", "positive_arm", frequencies=(3.0e9,)),),
)

ThinWire#

class ThinWire(name, points, radius, conductor, endpoints=None, snap='strict')

Immutable centerline definition of one thin wire. Each pair of consecutive points is one wire segment. Tensor radius keeps its autograd graph, so the radius can be trained. Tensor points keep coordinate gradients only with snap="continuous"; the compiled cell stencil itself stays a fixed, discrete choice. ThinWire compares by identity, not by value.

Raises TypeError or ValueError for any violated rule above. Further checks run when the scene is compiled: the wire must stay inside the physical domain (not in the PML), and a segment must not collapse to zero length after snapping.

ThinWire properties#

loop = mw.ThinWire(
    "loop",
    ((0.0, 0.0, 0.0), (0.01, 0.0, 0.0), (0.01, 0.01, 0.0), (0.0, 0.01, 0.0), (0.0, 0.0, 0.0)),
    5.0e-4,
    mw.WireConductor.pec(),
)
assert loop.is_closed and loop.endpoints == ()

WireConductor#

class WireConductor(kind='pec', *, conductivity=None, permeability=None)

Frozen conductor law for a thin wire. Use the two class methods below rather than the constructor.

The compiler turns a finite conductor into a per-unit-length series impedance (DC resistance plus a passive skin-effect model).

WireConductor.pec#

WireConductor.pec() -> WireConductor   # classmethod

Returns a lossless perfect-conductor law.

WireConductor.finite#

WireConductor.finite(conductivity, *, permeability=None) -> WireConductor   # classmethod

Returns a solid round conductor with bulk conductivity (S/m) and permeability (H/m, vacuum by default).

copper = mw.WireConductor.finite(5.8e7)
print(copper.kind, copper.conductivity)   # finite 58000000.0

WireEnd#

class WireEnd(kind='open', *, structure=None, node_name=None)

Frozen boundary condition for one end of an open wire. Use the class methods.

WireEnd.open#

WireEnd.open() -> WireEnd   # classmethod

A free end.

WireEnd.grounded#

WireEnd.grounded(*, structure) -> WireEnd   # classmethod

An end connected to a PEC structure. At compile time the structure must exist in the scene, have a unique name, be enabled, use a PEC material, and contain the wire end point.

WireEnd.node#

WireEnd.node(name) -> WireEnd   # classmethod

A named junction. Ends with the same node name merge into one electrical node, which lets you build branched wires. At compile time every end that uses a node name must resolve to the same grid coordinate, and a name needs at least two ends. Two wires that touch at a point without one shared node name raise ValueError.

stub = mw.ThinWire(
    "stub",
    ((0.0, 0.0, 0.0), (0.0, 0.0, 0.01)),
    5.0e-4,
    mw.WireConductor.pec(),
    endpoints=(mw.WireEnd.grounded(structure="ground"), mw.WireEnd.node("junction")),
)

WireData#

class WireData(monitor_name, wire_name, frequencies, current, charge, ohmic_loss, metadata={})

Frozen frequency-domain state of one wire, returned by result.monitor(name) for a WireMonitor. Tensors stay on the run device and keep any live autograd graph. Quantities that the monitor did not request are None.

For an FDTD run, metadata holds quantities, segment_ids, node_ids, segment_positions and node_positions (midpoints and node coordinates in metres), phasor_convention (peak phasor, exp(-i*omega*t)), the time-step limits wire_cfl_limit, uncoupled_wire_cfl_limit, maxwell_cfl_limit, the flag time_step_adjusted, and validity.

At least one of current, charge, ohmic_loss must be present. current and charge must share one complex dtype that matches the precision of frequencies. ohmic_loss must match the shape of current when both are present.

Property device returns the device of frequencies. WireData has an explicit frequency axis, so result.monitor(name, freq_index=...) and result.at(freq_index=...).monitor(name) raise ValueError; index the tensors yourself. Result.save stores a detached CPU copy, and Result.load restores it as WireData.

pulse = mw.GaussianPulse(frequency=3.0e9, fwidth=1.5e9)
result = mw.Simulation.fdtd(
    scene, frequencies=[3.0e9], excitations=mw.PortExcitation("feed", source_time=pulse)
).run()
state = result.monitor("arm_state")
feed_current = state.current[0, 0]          # first segment, first frequency
total_charge = state.charge.sum(dim=-1)

Related pages#