solprop.backends.numba_cpu.dispersive_general

SEP 6’s frequency-dependent electronic response on the general modal route.

The general modal guide synthesises each node’s three Cartesian components in frequency, through maps that depend on frequency, and transforms them to the analytic signal at the node (solprop.backends.numba_cpu.general_modal). So the input multipliers act in synthesis: on the synthesised spectrum of a node chunk, before the inverse transform, one batched inverse transform giving every filtered field of the chunk (Phase 1b’s decision, measured in Phase 2b). The products are formed at the nodes of each channel’s own region – a gas region’s fill is one channel per species – and zero elsewhere; one batched forward transform takes them to frequency, and their output multipliers and the channels’ eps0 gamma0 rho land them in the chunk’s polarisation spectrum after the route’s own forward transform, ahead of the projection. The route has no temporal collar. The symmetric evaluator forms one product per region, a mixture’s under its fill’s mixture filter.

The sector is the leaf’s: the full cubic beside kerr_form="real", formed on the real field, and the number-conserving one beside "analytic", formed on the analytic signals with Pi_+; both contract the three components through the isotropic Kleinman tensor (SEP 6, decision Q3). The polynomial groups the species of one region with equal leg bounds, and forms one cube per region (DispersiveTerms).

Functions

make_general_dispersive(form, *, parallel[, ...])

Compile the general route's three-component product kernels.

Classes

GeneralDispersive(leaf, node_region, chunks, ...)	The general route's dispersive buffers, plans and kernels, allocated once.
GeneralDispersiveKernels(cube, pairs)	The general route's product kernels for one form.

class solprop.backends.numba_cpu.dispersive_general.GeneralDispersive(leaf, node_region, chunks, plans, *, parallel, flag, threads)

Bases: object

The general route’s dispersive buffers, plans and kernels, allocated once.

Parameters:

leafsolprop.translate.responses.DispersiveKerrTerms

The compiled leaf, carrying each channel’s node region.

node_regionnumpy.ndarray

Every node’s region, int32.

chunkstuple of tuple of int

The route’s node chunks, (first, count).

planssolprop.backends.numba_cpu.fft.GeneralPlans

The route’s plans, whose synthesised spectrum, analytic signal and polarisation spectrum the response reads and adds into.

parallelbool

Whether the node loops are prange.

flagstr

The FFTW planning flag, a key of solprop.backends.numba_cpu.fft.PLAN_FLAGS.

threadsint

The FFTW pool of the route’s own plans.

begin(densities)

Weigh the channels at a stage, once for all its chunks.

Parameters:

densitiestuple of float

Each channel’s number density, m^-3.

combine(*, overwrite=False)

Land the products’ weighted spectra in the chunk’s polarisation spectrum.

Parameters:

overwritebool, optional

Whether to write the spectrum rather than add to it: when no regional tensor or delayed response made one.

memory_ledger()

Return the bytes of every buffer the response owns, by name.

Returns:

dict

Every row of DISPERSIVE_LEDGER_ROWS of solprop.backends.numba_cpu.dispersive.

respond(index, first, count)

Filter a chunk’s synthesised spectrum, form and transform its products.

Called after the route’s inverse transform of the synthesised spectrum, which leaves the spectrum intact (a complex-to-complex plan out of place).

Parameters:

indexint

The chunk’s position in the route’s chunk list.

first, countint

The chunk’s first node and node count.

Returns:

bool

Whether the chunk has a node in any channel’s region, so that combine() has something to add.

class solprop.backends.numba_cpu.dispersive_general.GeneralDispersiveKernels(cube, pairs)

Bases: NamedTuple

The general route’s product kernels for one form.

Attributes:

cubenumba.core.dispatcher.Dispatcher

(source, target, node_region, region, first, count, offset): T(E, E, E) at the chunk’s nodes of one region, zero at the others.

pairsnumba.core.dispatcher.Dispatcher

(field, first_field, second_field, out_first, out_second, c0, c1, node_region, region, first, count, offset): T(E, E, F) and c0 T(E, E, H) + c1 T(E, F, F) likewise.

cube: Any

Alias for field number 0

pairs: Any

Alias for field number 1

solprop.backends.numba_cpu.dispersive_general.make_general_dispersive(form, *, parallel, shifted=False)

Compile the general route’s three-component product kernels.

Parameters:

form{‘real’, ‘conserving’}

The full cubic of the real field, or the number-conserving group of the analytic signals.

parallelbool

Whether the node loop is a prange.

shiftedbool, optional

Whether the bare field’s zero-frequency constant is subtracted per row as it is read: the synthesised analytic signal keeps that bin once, which Pi_+ excludes.

Returns:

GeneralDispersiveKernels

The compiled kernels.