solprop.backends.low_storage#

The low-storage interaction-picture RK4 march: replay-only, accepted in place.

SEP 24 (docs/dev/seps/archive/, sep-0024-low-storage-interaction-picture-runge-kutta.md). Classical fourth-order Runge-Kutta in the interaction picture anchored at the step’s midpoint, Lawson’s transformation [1] in Hult’s arrangement [2]. For a step [z_n, z_n + h] with z_m = z_n + h/2, P = U(z_m, z_n), Q = U(z_n + h, z_m) and U(z_2, z_1) = exp(Phi(z_2) - Phi(z_1)), the step is

g1 = P F(z_n, A_n), F2 = F(z_m, P A_n + h/2 g1), F3 = F(z_m, P A_n + h/2 F2), F4 = F(z_n + h, Q (P A_n + h F3)), A_{n+1} = Q (P A_n + h/6 g1 + h/3 F2 + h/3 F3) + h/6 F4,

with F the complete source (the response, the in-stage absorbers and the modified noise draw at the evaluation’s position). Only forward flows are applied, four per element, and on a constant operator P = Q = exp(h D / 2).

The register form (SEP 24 section 4.3) holds three field-sized registers beside the source pipeline’s scratch S: the state A, overwritten in place by P A and then by the accepted step, the accumulator B and the stage register C. A step is four passes, each forming an input, evaluating F into S and folding it into the registers:

pass

evaluation

finish

1

F1 at z_n

A <- P A; g <- P S; B <- A + h/6 g; C <- A + h/2 g

2

F2 at z_m

B <- B + h/3 S; C <- A + h/2 S

3

F3 at z_m

B <- B + h/3 S; C <- Q (A + h S)

4

F4 at end

A <- Q B + h/6 S

The march (the reference’s solprop.backends.numpy_ref.marches.low_storage.HostLowStorageMarch; the native session’s replay) replays a prescribed schedule and never rejects, so it accepts each step in place: from the start of the step’s trial to its accept the engine is in flight and every entry that reads or advances the state refuses it, until a load replaces the state (SEP 24 section 6.2, ADR-050). It records no error estimate: the step history’s norm is 0.0, “not estimated” (section 6.3). Divergence is detected on the accepted state’s norm instead.

The engine holds the registers and makes the passes: it is a RungeKuttaEngine with the documented destructive trial (SEP 52 section 5.2). The reference’s is NumpyLowStorage, over the workspace’s lab_source and propagator; native’s is resident. The table keys (table_steps(), schedule_key()) are stateless numerical code the two backends share (SEP 47 Part III decision 5).

References#

[1]

J. D. Lawson, “Generalized Runge-Kutta processes for stable systems with large Lipschitz constants”, SIAM Journal on Numerical Analysis 4, 372 (1967). doi:10.1137/0704033

[2]

J. Hult, “A fourth-order Runge-Kutta in the interaction picture method for simulating supercontinuum generation in optical fibers”, J. Lightwave Technol. 25, 3770 (2007). doi:10.1109/JLT.2007.909373

Functions

schedule_key(keys, edges, z, dz)

Return the table key of the schedule step from z, from table_steps().

table_steps(schedule)

Return the step each of a schedule's steps builds and keys the flow table on.

solprop.backends.low_storage.schedule_key(keys, edges, z, dz)[source]#

Return the table key of the schedule step from z, from table_steps().

Found by position rather than by a step counter, so that it needs no count of the steps taken before.

Parameters:
keysnumpy.ndarray

table_steps() of the schedule.

edgesnumpy.ndarray

The schedule’s edges, m.

zfloat

Where the step starts, m.

dzfloat

The step, m.

Returns:
float

The key, m.

solprop.backends.low_storage.table_steps(schedule)[source]#

Return the step each of a schedule’s steps builds and keys the flow table on.

SEP 24 Q10, decided in phase 2: the mean step of the step’s run, the longest stretch of consecutive steps within LANDING_ULPS ulps of the run’s first, the ulps being of the run’s farthest position (or of the step, near the origin). uniform() takes a segment’s steps from differences of rounded positions, which differ in their last bits by up to an ulp of the position: far from the origin that is many ulps of the step, and a table keyed on one step’s own value within ulps of the step was rebuilt nearly every step. Keyed on the run’s mean h_bar instead, a uniform segment builds one table and reuses it; each flow’s exponent is then off by |D| |h - h_bar| / 2, a few ulps of the position times |D|, and the error does not drift: the steps of a run sum to n h_bar to rounding, so the phase the flows apply over a run is the run’s own. A schedule whose steps all differ (a discovered one) has runs of one step and keys each step on itself.

Parameters:
schedulesolprop.stepper.schedule.FixedSchedule

The schedule replayed.

Returns:
numpy.ndarray

One key per step, m, shape (n_steps,): constant over a run.

Examples

>>> from solprop.backends.low_storage import table_steps
>>> from solprop.stepper import FixedSchedule
>>> schedule = FixedSchedule.uniform(0.0, 1.0, 0.1, save_planes=[0.25, 1.0])
>>> keys = table_steps(schedule)
>>> len(set(keys.tolist())), round(float(keys[0]), 12), round(float(keys[-1]), 12)
(2, 0.083333333333, 0.09375)