Repository navigation
solprop 0.3.0 runs every native simulation in a compiled session of its own and fits the
native backend to the machine it runs on, lets the desktop front end run simulations and
scans on other machines, and makes the Python interfaces consistent, at the cost of many
breaks. It computes in double precision only, has two backends, native and numpy_ref,
and writes output schema 3. Every break is listed first, under "Changed (breaking)", with
how to migrate (ADR-058).
Highlights:
- Output schema 3: a file or scan written by 0.2.0 is refused wherever it is opened,
read or resumed, and the refusal names the release that wrote it: read, resume or
continue it with solprop 0.2.x. Every run's configuration hash changes too, so no run
started on 0.2.0 continues on 0.3.0. - One rule for saved planes, and consistent interfaces
(SEP 51):
every route records both ends of its run,n_save=NgivesNevenly spaced planes and
save_planes=[...]lists positions (save_planes=80is refused with "pass
n_save=80"). A gas fill needs its pressure wherever a gas is named,loss=becomes
loss_scale=andalpha=,from_freeandprop_freetake aRadialGridin place of
from_radialandprop_radial, the pulses takephases=andm=, and a
Simulation's inputs are read-only, changed throughwith_inputorwith_mixture. - The front end on other machines: the desktop front end runs every simulation and
scan as a process of its own that outlives the window, on this computer or over SSH on
a workstation, a Slurm cluster or a rented machine. A Runs window lists every run on
every machine, and a machine can be set up with solprop from the window
(Running on other machines). - Machine calibration
(SEP 46):
solprop calibratemeasures how the native backend should thread and plan its
transforms on this machine, and every later run applies the profile and records it. The
first native CPU run with no profile for its machine, build and allocation calibrates
itself first, in about 30 s (SOLPROP_CALIBRATION=usenever measures,offignores
profiles), and FFTW plans are kept, so each transform shape is measured once per machine
and build. - Faster native runs
(SEP 45,
SEP 47):
the native backend steps every run it admits in a compiled session, Runge–Kutta,
resumed and dense-output runs and the transverse edge included, with no Python step
loop, on CPU and GPU builds alike. Idle OpenMP threads spin briefly instead of sleeping
(benchmark windows took about 0.8 of their time), and on Apple silicon the thread budget
is the fastest cores, smaller passes thread and SLEEF's vector maths is the default. - TDSE on the native backend
(SEP 49):
the TDSE response runs on the native CPU build, andbackend="auto"selectsnative
for it as for every other run. Its atomic provider runs in a worker process of its own,
so Ctrl-C or a stop flag stops a TDSE run during an atomic call, and solprop no longer
pins a Pyroraptor revision. - More correct results: the zero-dispersion search (
modes.base.zdw, thezdw
statistic and the design tools) no longer reads a gas resonance or the fine structure
of a narrow feature as a zero, and takesnear=to choose among several;
refractive_index_minus_onekeeps its precision in a dilute gas;
FieldGrid.from_limitsrefusesffacbelow 2.2, where
the Nyquist bin kept field; andVincettiModeuses the effective-radius coefficient
Rosa, Melli and Vincetti print, 20 rather than 10, which moves an antiresonant fibre's
dispersion slightly (results with the old coefficient need solprop 0.2). - Retired: single and mixed precision (the
precisionkeyword is gone), the
experimentalmlxbackend, theBatchscan executor (useLocalorPool), the
comparison Adams variants (ComparisonMultistep) and the CF4 coupled-flow sections.
The backend and translation layers, unstable within 0.x, now build a backend for one
problem and its run request
(SEP 52).
Changed (breaking)
Output and resume
- Output files are written in output schema 3. A file's march snapshot (
/march_snapshot) stores itsstateas(n_modes, n_pol, n_omega)and its enginerowsas(n_slots, n_modes, n_pol, n_omega), without the leading axis of one they kept before, and the plane-reference record (RunMetadata.reference) has nobasisentry: a plane's basis is derived when it is read. Saved fields, statistics and the rest of the run record are laid out as before. A file or scan written by 0.2.0 (output schema 2) is refused wherever it is opened, read or resumed, and the refusal names the file and the release that wrote it: read, resume or continue it with solprop 0.2.x, and a 0.1.0 file (schema 1) with solprop 0.1.x. Every run's configuration hash also differs from 0.2.0's, since the run record names its record types by module (solprop.output.records.GridRecord) and holds the keywords renamed in this release, so a run or scan started on 0.2.0 is finished on 0.2.x. solprop.output.schemais split into five modules:solprop.output.serialisation
(serialise,ArrayDigest,StatedInput,recorded_input),
solprop.output.provenance(BackendRecord,GitProvenance,package_versions),
solprop.output.records(GridRecord,ModeRecord,StepperRecord,SavedPlane,
RunOutcomeand the other record types),solprop.output.metadata(RunMetadata,
SCHEMA_VERSION,resolve_metadata_write) andsolprop.output.store(Output,
PlaneStore,FieldRetentionand the other save protocols). Import these names from
solprop.output, which still exports the public ones, or from their new module.- A run no longer computes or records its planes' basis identities before its first step (#874): a guide that varies along z paid a mode evaluation at every saved plane, about 0.3 s for 201 planes of a gas-filled capillary with a pressure gradient. A plane's basis is derived when it is read (
PlaneBasis.of_run; the record change is output schema 3's), an ordinary mode set's from its modes at the plane's own position, which come fromfield_plane(..., source=simulation)or from the recipe the output records. A plane of a run from a script read withoutsource=has no basis identity (PlaneBasis.identitymay now beNone), andsame_basisrefuses to copy it or apply a declaredBasisChangeto it, namingsource=as the remedy.Recipe.from_outputalso takes an opened output. - A modal basis identity (
solprop.coupling.modal_basis_identity) is formed by roundingaeffandneffto 40 significant bits with exact binary arithmetic and hashing their bytes: it costs about a third of what it did and is the same on every platform. Identities therefore differ from those 0.2.0 computed. solprop.output.resumeis renamedsolprop.output.read_resume_state(also insolprop.output.hdf5), andsolprop.solno longer exportsresume: the name read a file's resumable state into aResumeStateand continued nothing, whichresume=Trueon a run orsolprop resumedoes. Replacefrom solprop.output import resumeorfrom solprop.sol import resume, andresume(path), withread_resume_state; the old name is gone.solprop.driver.run.open_run_recordis removed in favour ofsolprop.driver.run.open_run,
which opens an output with the same record and also returns its checkpoint interface.MemoryOutputnow returns read-only views of its buffers (run["field"],run["z"],
run["stats/<name>"], the step history and statistics,noise_phase,plane_field): a
write through one raisesValueErrorinstead of silently changing the stored run. Take
.copy()of an array to change it.- The
Outputprotocol now includesplane_field(index, convention="optics"), which
solprop.processinguses to read one saved plane: a handler of your own implements it
(returning shape(n_modes, n_pol, n_omega)) besidefields.CallbackOutputrefuses it
by name.processing.axes.layoutreads the shape from the store without reading the
field, and counts every saved plane. - A refused argument to
SnapshotController(interval_seconds,max_snapshots) or to
TDSEArchive(path,outputs) raises the new
solprop.exceptions.OutputRequestError, aSolpropErrorand aValueError, as a
refusedprogressorresumeraises aDriverError. They raisedOutputError(a
RuntimeError) and bareTypeErrororValueErrorbefore. CatchOutputRequestError
orValueErrorin place ofOutputErrororTypeErroraround these constructors;
OutputErrorstill reports a file that cannot be written or read.
Routes and Simulation
- Every route now follows one rule for the saved planes and the end of a run
(SEP 51).
A run marches frominitial_zto its length,lengthorgrid.length, and always
records both ends.n_save=NgivesNevenly spaced observations over that interval,
both ends included, andsave_planes=[...]lists positions inside it.
SimulationSettingsgainsn_save, itssave_planesbecomes optional (given neither,
a run records 201), and a recipe's object-route[build.settings]takesn_savetoo.
Migration:save_planes=80is refused with "passn_save=80" in Python and "write
n_save = 80" in a recipe, where 0.2.0 read a recipe'ssave_planes = 80as one plane
at 80 m (#533);save_planes=0.25must be[0.25];n_saveandsave_planes
together,n_savebelow 2, and positions before the entrance or beyond the end are
refused. Positions short of the length no longer end the run: it continues to the length
and records it, so indices counted from the end (field_planes=[-1, …]) may name other
planes, and a short window of a longer setup is now a shorter grid, with
boundary_lengthpinned to keep the absorber. On the keyword routeslengthmay be
Nonebesidegrid=, which then supplies it, as in
prop_capillary(radius, None, "Ar", grid=grid, ...); it is still passed, sogasstays
required. Given besidegrid=, the two must agree, and a call with neither is refused;
a recipe may leavelengthout beside a grid.n_savebeside an interior launch counts
over[initial_z, length]. Simulation.from_radialandprop_radialare removed:Simulation.from_freeand
prop_freetake aRadialGridas well as aFreeGridorLineGrid, and choose the
radial or the Cartesian transform from it, with the same keywords and the same
defaults as before for each grid. Replacefrom_radial(...)withfrom_free(...)and
prop_radial(...)withprop_free(...); recipes keep theradialroute.Simulation'sgrid,modes,responses,initial,initial_z,noise,
noise_resolution,profiles,configuration,spatial_grid,medium,frame,
general,guide,wall,taper_couplingandmaterialsare now read-only
properties, andprofilesandconfigurationreturn copies. Assigning one used
to leave the run built from the old value while the record described the new one
(sim.initial = pulseran the old pulse); it now raisesAttributeError. Derive a run
with a new input, noise or launch position withwith_input(...), one with a new fill
withwith_mixture(...), and build a newSimulationfor anything else.prop_free,prop_planar,Simulation.from_freeandSimulation.from_planartake
the defaults the keyword routes take.SimulationSettings.dz_maxanddz_initare
optional: leftNone, a simulation takes half itsgrid.lengthand a ten-thousandth of
it, the first refined by the start-up rule, asprop_gnlse,prop_capillaryand
prop_waveguidedo. Settings whosestatsisNonenow record the route's default
statistics on the free-space and planar routes (default_spec("radial")on a radial
grid,default_spec("free")otherwise, with a mixture's per-species statistics), as
every modal route already did, rather than none; passStatsSpec(names=())to record
none. The manual no longer says thatrtol,atol,dz_initanddz_maxare
keywords of everyprop_*function: the free-space and planar ones take them in
their settings.- The
polarisationkeyword ofprop_capillary,prop_waveguide,
Simulation.from_capillaryandSimulation.from_waveguide, and of their recipes, is
removed: it was refused whatever its value, because these routes are scalar. Declare the
polarisation in the modes (a rectangular or slab guide's own partners, each a row of its
own). Passing it now raisesTypeError, and a recipe holding it is refused as an unknown
keyword. Simulation.from_waveguideandprop_waveguideno longer takeobservable_rtolandobservable_atol, which accepted onlyNoneand refused every number. Drop them from calls: a general modal run's observables are bounded by the solver's ownrtolandatol.PIControlleris final: defining a subclass raisesStepperError(ADR-077). Both backends implement its decisions and its norm (scale,accepts,propose,rejection_factor,start_factor,equivalent_norm) themselves, so a subclass that overrode one would step differently on each (0.2.0 stepped such a run on native with solprop's Python march and aHostMarchWarning). Set the controller's fields instead.- Removed
solprop.stepper.multistep.ComparisonMultistep, the benchmark-only Adams variants SEP 13 compared and did not select (PECE, explicit Adams–Bashforth, the matched predictor–corrector pairs and their Hermite dense interpolant), with the reference's general Adams path that stepped them,milne_factor,defect_integral, theCorrectorandInterpolanttypes,Multistep.correctorandMultistep.corrector_nodes(ADR-077). UseMultistep();Multistep(order=q, variable_order=False, formulation="interaction")is the one-order-higher PEC variant the comparison family also named. StepperSettingsandPropagatorModemoved fromsolprop.translate.problemto
solprop.stepper.settings, the run-specification layer the run request's stepper
section belongs to: import them from there, orStepperSettingsfromsolprop.stepper.
solprop.translateno longer re-exportsStepperSettings.solprop.driver.scaffold.propagate_fixed_rk4'sn_savenow means what it means on every
Simulationroute: the number of evenly spaced saved planes over[0, z_end], both ends
included, at least 2 (default 2).n_stepsmust be a multiple ofn_save - 1. A call
that passedn_save=4now passesn_save=5for the same planes (#856).solprop.driver.simulationnow holds theSimulationclass alone; the rest moved into
modules by concern. ImportSimulationSettingsanddefault_collarfrom
solprop.driver.settings(orSimulationSettingsfromsolprop.driver),
SimulationRunnerandcheck_derived_problemfromsolprop.driver.runner,
metadata_forfromsolprop.driver.metadata,default_field_rangefrom
solprop.driver.inputsanddefault_radial_orderfromsolprop.driver.routes.hollow.
Modes and media
- A gas fill no longer takes a pressure it was not given: the same omitted argument meant
0 bar on the modes and 1 bar on the routes andSpatialMedium. Wherever a gas is named,
its pressure must now be passed, in bar, or the call is refused with "a gas fill needs
its pressure" namingpressure: on the hollow modes, theModeCollectionfactories,
SpatialMediumand the capillary and waveguide routes (for a built-in gas,"air"or a
mapping of fractions). Where no gas is named nothing changes: a mode without a gas is
evacuated,SpatialMedium()is vacuum, and aMixturecarries its own pressure. To
migrate, add the pressure the call used to take by default:
MarcatiliMode(125e-6, "He", 0.0)for a mode or mode set (or drop the gas, which is
what 0 bar meant), andprop_capillary(r, L, "He", 1.0)orSpatialMedium("Ar", 1.0)
for a route or a medium. A recipe's route no longer resolves an omittedpressureto
one bar. - One loss vocabulary for every mode.
loss=is removed, with theLossSpecalias, from
the hollow modes (MarcatiliMode,RectMode,SlabMode,VincettiMode, the tabulated
hollow modes), theModeCollectionfactories,prop_capillaryand
Simulation.from_capillary,capillary_paramsandcapillary_design, and recipes.
loss_scalemultiplies a hollow mode's own loss (default1.0;0.0is lossless) and
alphareplaces it by an absolute power attenuation in 1/m, a number or a callable
alpha(omega); givingalphabeside aloss_scaleother than one is refused.
StepIndexModeandSpecifiedMode(and itsfrom_taylor,from_taylor_pathand
from_table), whoseloss=was already an absolute attenuation, take it asalpha=.
Migrateloss=Falsetoloss_scale=0.0,loss=0.5toloss_scale=0.5, a callable
loss=ftoalpha=f, droploss=True, and writeloss_scale = 0.0in a recipe for
loss = false.SpecifiedMode.alpha(omega, z)is now
SpecifiedMode.attenuation(omega, z)andloss_pathisalpha_path, becausealpha
is the declared field. - The
ModeCollectionfactories share one layout: the geometry, thengasand
pressure(as on the modes: no gas is an evacuated guide, and a gas needs its
pressure), then keyword-only options, withtemperature=None(room temperature, or the
mixture's own) andmixture=on all of them.he1mand
vincettitakecount=by keyword (default one),slabtakesorders=by keyword
(default(1,)) after the fill, andmarcatilitakeskinds=,n=andm=by keyword:
writeModeCollection.slab(63.5e-6, "Ar", 1.0, orders=(1, 3, 5))for
ModeCollection.slab(63.5e-6, (1, 3, 5), "Ar", 1.0)and
ModeCollection.he1m(125e-6, "He", 0.8, count=4)for
ModeCollection.he1m(125e-6, "He", 0.8, 4). - The gas-property functions take one argument order,
(gas, pressure, temperature), with
the pressure in bar namedpressureand the temperature defaulting to 293.15 K in every
function;ReferenceState, where a source states its own state, and the
EquationOfStateprotocol keep it required.density,ideal_gas_density, the
equations of state'sdensity,ReferenceState,gasflow.mass_flowand
gasflow.knudsen_numberrenamepressure_bartopressure(write
ReferenceState(pressure=1.0, temperature=273.15)).
physdata.transport.sound_speed(gas, temperature, pressure_bar=None)becomes
sound_speed(gas, pressure=None, temperature=293.15): replacesound_speed(gas, T)
withsound_speed(gas, temperature=T)andsound_speed(gas, T, p)with
sound_speed(gas, p, T).viscosity,heat_capacity_ratioandmean_free_pathnow
default the temperature to 293.15 K. - The steady-flow and pressure-profile functions name their pressures without the unit,
asphysdatadoes; the pressures stay in bar.gasflow.throughputand
PressureGradient.two_pointrenamestart_barandend_bartostart_pressureand
end_pressure,gasflow.choked_pressurerenameshigh_bartohigh_pressure,
gasflow.steady_fillrenamespressures_bartopressures(as
PressureGradient.from_stagesalready spells it),StageFlowrenames its fields
start_barandend_bartostart_pressureandend_pressure, andFlowReport
renameschoked_start_barandchoked_end_bartochoked_start_pressureand
choked_end_pressure. A recipe'sPressureGradient.two_pointtable takes the new
keys. Positional calls are unchanged; rename the keywords, recipe keys and attributes. - solprop requires optmat 0.10.0 or later. Its first real-gas density loads CoolProp in about 0.07 s instead of 0.46 s; no density, index or other recommended value changes, but every equation of state's identity does (optmat's
EVALUATION_VERSION2), which a run with a gas fill records. MaterialSelectionno longer has anenergy_lossfield, and
solprop.physdata.selection.ENERGY_LOSS_POLICIESis gone: its one value,
"peak-weighted", was validated and recorded but never read, since each optmat rate
applies its own convention, which itsionisationentry in the material manifest still
records. Dropenergy_loss=fromMaterialSelection(...)and from a recipe's
MaterialSelectiontable; the run is unchanged. A run's material manifest no longer
carries apolicies.energy_lossentry.is_air, which says whether a gas name means air (Gas.Air, or"air"in any case),
moved fromsolprop.driver.mixturestosolprop.physdata.gasesbesideas_gasand
is_molecule, and is exported fromsolprop.physdata. Import it as
from solprop.physdata import is_air.- The tube-lattice geometry helpers take every argument after the first by keyword, so
two lengths can no longer be swapped silently:tube_gap(core_radius, *, tube_radius, n_tubes),core_radius_from_gap(tube_radius, *, n_tubes, gap),
tube_radius_from_gap(core_radius, *, n_tubes, gap),
TubeLattice.from_gap(core_radius, *, gap, n_tubes, wall_thickness)and
TubeLattice.from_inner_diameter_ratio(core_radius, *, wall_thickness, inner_diameter_ratio, n_tubes). Name the arguments, for example
TubeLattice.from_inner_diameter_ratio(20e-6, wall_thickness=300e-9, inner_diameter_ratio=0.6, n_tubes=6). - Removed the CF4 coupled-flow sections (ADR-077):
CoherentWall'smethod,growth_limitandfallbackkeywords,solprop.translate.coupled.cf4_flow,cf4_defect,cf4_growth_bound,CF4_NODES,CF4_WEIGHTSandCF4_GROWTH_LIMIT, the"cf4"section method, and theflow.cf4entry of a coherent wall's run record. They ran onnumpy_refalone; a recipe that gives one is refused as an unknown key. A varying coherent wall is integrated by the frozen-residual split, as by default; to shorten its advisory step, divide the sections (CoherentWall(sections=...)) or cap the step. - A moving guide's z sampling is described once (#875):
ModalPathnow lives insolprop.modes.path(still importable fromsolprop.modes.guide), andModalPathTableholds that record aspathbeside itstablesinstead of its ownz_edges,degree,z_errorandgram_departure(readtable.path.z_edgesand so on).sample_modal_pathtakesrtol=andsections=to search a degree, orpath=aModalPathalready qualified to rebuild its snapshots, in place ofz_edges,degree=andmeasured=. Sampled positions and tables are unchanged. - The provider-table sampling of a general modal guide moved from
solprop.translate.modal_tablesto the newsolprop.modes.tables(sample_modal_table,sample_provider_table,DenseModalTable,align_modal_sample,channel_areaand the rest), and a moving guide's path sampling fromsolprop.translate.modal_pathto the newsolprop.modes.path(path_rule,path_sections,sample_modal_path,ModalPathTable);solprop.translate.modal_tableskeeps the run's execution maps (ModalTransformTables,modal_transform_tables,project_transverse_field). Import the moved names from their new modules. StepIndexProviderand itsMATERIAL_AGREEMENT_RTOLmoved fromsolprop.modes.guideto the new public modulesolprop.modes.stepindex_vector(formerly the privatesolprop.modes._stepindex_vector), andradial_node_rulemoved fromsolprop.modes.guidetosolprop.modes.vector, besideModalNodeRule.from solprop.modes import StepIndexProvideris unchanged; replacefrom solprop.modes.guide import StepIndexProviderwithfrom solprop.modes.stepindex_vector import StepIndexProvider, andfrom solprop.modes.guide import radial_node_rulewithfrom solprop.modes.vector import radial_node_rule.- The coherent wall moved out of
solprop.modes.capillaryinto its own module,solprop.modes.wall:CoherentWall,WallImpedance,WallLimits,WallOperator,WallFamily,VectorWallOperator,wall_operator,vector_wall_operator,wall_connection,taper_connection,taper_coupling_block,worst_wall_limitsandwall_square_root_metric.from solprop.modes import CoherentWall(and the other namessolprop.modesalready exported) is unchanged; replacefrom solprop.modes.capillary import CoherentWallwithfrom solprop.modes.wall import CoherentWall, and likewise for the others.
Pulses, grids and boundaries
- The pulse builders now spell their parameters as the drivers do. The Taylor spectral
phase ofGaussianPulse,SechPulse,CustomPulse,DataPulseandTimeDataPulse
(and ofDataPulse.from_spectral_density) isphases=, the nameprop_gnlse,
prop_capillaryandprop_waveguideuse, rather thanphase=; and the super-Gaussian
order ofSpatialPulseandPlanarPulseism=, as onGaussianPulse, rather than
order=. The meaning is unchanged. A recipe's pulse tables takephasesandm.
Migration: renamephase=tophases=on the pulses andorder=tom=on the beams. FieldGrid.from_limitsrefusesffacbelow 2.2, andTimeGrid.validaterefuses a field grid whose spectral collar is not exactly zero at the zero-frequency or Nyquist bin. With2 <= ffac < 2.2the coarse Nyquist bin lay inside the collar and kept field, which broke the energy identities offourier.oversample,fourier.spectral_densityandspatial.node_spectrum. Passffac >= 2.2(the default, 6, is unchanged).EnvelopeGridstill acceptsffac >= 2.- The transverse edge's
unwatchedstatus is gone, every backend reading the edge:TransverseStatusno longer lists it andTransverseEdge.launchno longer takesreads=; dropreads=from a call. The boundary monitor'sunwatchedstretches, left by an execution run withboundary_check=None, are unchanged. - Removed
solprop.boundaries.split_step_factor,apply_split_stepandapply_band_mask,
which no backend ran: theabsorber_scheme="split_step"path is the backends' own. To
reproduce them, multiply a time-domain field bynumpy.exp(-0.5 * temporal_rate * step)
and mask a spectrum withnumpy.where(band_mask, spectrum, 0.0).
Processing, statistics and plots
- One plane-selection rule across
solprop.processing: every function takesplane=None, z=None, and naming a plane both by index and by position raisesProcessingError
everywhere (it raisedOutputErrorin the field and time accessors, and the beam readers
letzwin silently). With neither, a function returning one plane
(get_spectrogram, the readers ofprocessing.beams, the reconstructions of
processing.modal, the compressors,apply_transfer,fluence_map,field_plane)
reads the last plane, and a reader of every plane returns them all. The rule is stated in
the processing guide. - The plots take their default ranges from the run instead of fixed windows that clipped
picosecond fibre pulses and mid-infrared spectra: with nospec_range,prop_2d,
spec_1dandspectrogramshow the band the grid was declared over
(plotting.propagation.default_spec_range), and with notime_range,prop_2d,
time_1dandspectrogramshow where the drawn light is
(plotting.propagation.default_time_range: 0.05 % to 99.95 % of each trace's energy,
widened by a quarter on each side).prop_2ddefaults toaxis="wavelength"like every
other plot.spec_1d(log_min=1e-6)is nowdb_min=-60.0, in dB below the peak, as on
prop_2d(spectrogramnames its floordb_mintoo, at -40 dB by default).DEFAULT_WAVELENGTH_RANGE,DEFAULT_SLICE_WAVELENGTH_RANGE
andDEFAULT_TIME_RANGEare removed. - The array form of the compressors (
grid=,spectrum=ofcompress_taylor,
compress_material,compress_mirrors,compress_gratings,compress_prisms,
transform_limitandoptimise_cep) now takes the spectrum in the optics convention, the
oneoutput["field"]andplane_fieldreturn, socompress_taylor(grid=grid, spectrum=run.plane_field(-1))finds whatcompress_taylor(run)finds. A spectrum from a
pulse'sbuild(grid)is internal: passfourier.spectrum_to_optics(spectrum, kind=grid.kind). solprop.processing.compression.apply_transfertakes the output first, like every other
processing function:apply_transfer(output, transfer)replaces
apply_transfer(transfer, output).- The compressors and
apply_transferrefuse amodes=selection the run does not have, or an empty one, withModeError, as every other processing reader does, instead ofProcessingError: catchModeError(orValueError, which both subclass) around them. - The reconstruction accessors of
solprop.processing.modal(electric_field,
magnetic_field,reconstructed_flux,instantaneous_flux,coordinate_intensity,
plane_nodes) rebuild the run's reference tables from the requiredguide=and no
longer taketablespositionally:electric_field(run, guide=guide). Pass
tables=(from the newsolprop.processing.modal.reference_tables(run, guide=guide)) to
reuse one rebuild across many calls; a script no longer needs
solprop.translate.general.general_modal_route. They read the last plane by default
(plane=-1) instead of requiringplane=orz=. The tables alone are rebuilt by the
newsolprop.translate.general.reference_tables. - A malformed
StatsSpec(an unknown, repeated or reserved name, a bad window or region,
a periodic subset that is not a subset or names a statistic no backend evaluates between
planes, a period below 1, a missing far-field table) orstats.ApertureSet, an unknown
profile or weighting passed tostats.check_aperture_choices, and a spec that does not
fit a line grid (an aperture centred offy = 0, a half-plane bounded in y or an
ellipse, or a spectral region whosekappa_yinterval excludes zero) now raise
ProcessingError, aValueError, instead ofOutputError, aRuntimeError: they are
argument errors. CatchProcessingError(orValueError) whereOutputErrorwas
caught, around building a spec or its apertures and around a line run's statistics
tables. StatDefinition.implementedis removed: every statistic insolprop.stats.CATALOGUE
is implemented, and the reserved-name refusal it served had no entries. Each
StatDefinitionnow also says how a statistic is formed and treated (evaluate,
metric,weight,profile,plasma,general,advice), and the name sets such as
METRIC_WEIGHTED_STATISTICSandGENERAL_MODAL_ACCESSORSare derived from those
fields, with unchanged members.
Scans
- The
Batchscan executor is removed, with the batch machinery behind it on both
backends (SEP 52): on the native backend it costsizetimes the memory ofLocalfor
no gain in speed. A script that importsBatchnow fails at import: useLocal()to
run the points one after another on one reused backend, orPool()to run them in
parallel worker processes;QueueandSlurmspread them over controllers and cluster
jobs. Every executor still replays a fixed schedule. Also removed:
solprop.driver.batch,solprop.backends.batch,
solprop.backends.registry.select_batch,solprop.backends.BatchBackend,
Backend.max_batch,StatsSpec.same_tables, the reference'sNumpyBatchBackendand
solprop_native.batch(NativeBatchBackend). run_scanno longer takesstale_age: aLocalorPoolscan holds its file's lock
for its whole session, so arunningpoint it finds is always taken up again, and the
keyword never reachedQueueorSlurm. Remove it from calls; a durable queue's lease
isQueue(stale_age=...), and nowSlurm(stale_age=...)for the queue its tasks share.
python -m solprop.scan --stale-agenow reaches the tasks of--submitand
--emit-slurm, and is refused without--queue,--chunkor a Slurm mode, where it
did nothing.solprop.processing.scans.open, which shadowed the builtinopen, is renamed
open_scan, the namesolprop.solalready gave it:
from solprop.processing.scans import open_scan.
Backends and native
- solprop has exactly two backends,
nativeandnumpy_ref, with no tiers and no plugin backends (ADR-077).solprop.backends.registry.BACKENDS,BackendEntry,REMOVED_BACKENDSandFAR_FIELD_BACKENDSare removed;BACKEND_NAMESlists the two. A backend name that is neither,numba_cpuincluded, now raisesBackendErrornaming both wherever it is requested, whereselectraisedValueErrorfor an unknown one; passbackend="native","numpy_ref"or"auto". - Single and mixed precision are retired: solprop computes in IEEE 754 binary64 only (ADR-077). The
precisionkeyword ofSimulationSettings, theSimulation.from_*constructors and theprop_*functions, and a recipe'sprecisionkey, are gone (a recipe that gives it is refused as an unknown key); so aresolprop.translate.precision, the reference's binary32 path (NumpySingleBackend), the run summary's precision row, theprecisionfield ofsolprop_native.BuildInfo, the guide's single-precision page and gallery example, and every internalprecisionargument and field. The kernel'srun_optionsreply lists the installed backends underbackends, in place ofdoubleandsingle. To migrate, dropprecision=from calls and theprecisionkey from recipes. - The experimental
mlxbackend for Apple GPUs is retired (SEP 47 §6.6):backend="mlx", in a call or a recipe, raisesBackendErrorand never runs on another backend. Thesolprop[mlx]extra, the front end's MLX choice and themetalentry of the kernel's run options are gone; the front end shows a recipe's unavailable backend as it is named. With MLX's transform costs gone, thetransformskeyword ofFieldGrid.from_limitsandEnvelopeGrid.from_limits(a recipe grid that gives it is refused as an unknown key), thelibraryargument ofsolprop.grid.fft_cost,solprop.grid.TransformLibraryandTRANSFORM_LIBRARIES,solprop.backends.registry.metal_availableandSINGLE_ONLY, and themlx_*andsingle_precision_rowssizes ofsolprop.backends.memoryare removed. - A backend (
solprop.backends, unstable within 0.x under ADR-058) is built for one
problem and request and runs it in a session of its own; 0.2.0's direct stepping
interface and Python step loop are gone
(SEP 47).
Simulation.run,SimulationRunner, scans and theprop_*functions do all of this
themselves, with unchanged interfaces.
solprop.backends.registry.select(name, problem, request, ...)and the backend
constructors take the run's request after the problem, check the pair before they
allocate and expose it asBackend.request; execution choices such as the node budget
arrive assolprop.backends.session.ExecutionOptions(options=). A run starts with
backend.prepare(problem, request).start(start), or
solprop.backends.sessions.start_session, from asolprop.backends.session.Start
(Start.entrance(problem)for a fresh run), which also carries a resumed run's call
ledgers and Adams history;solprop.driver.run.run_problemtakes a requiredstart=in
place ofstart_plane=, and a caller no longer callsset_initialfirst. TheBackend
protocol loses its stepping members (set_initial,propagate_to,observe,
march_snapshot,restore_marchand the rest;available_device_memoryis the module
functionsolprop_native.available_device_memory()), andtimed_step()is replaced by
Backend.timing_probe(start), whosetrial(z, dz)takes one trial step that commits
nothing and whosefield()reads that trial's end state. Removed with the loop:
solprop.backends.driver,solprop.backends.multistep(CallLedgeris now
solprop.backends.ledger.CallLedger),solprop.backends.multistep_general,
solprop.backends.low_storage.LowStorageMarch(the NumPy reference's own marches are in
solprop.backends.numpy_ref.marches),solprop.backends.numpy_ref.admissionand
solprop.backends.exponential.refuse_formulation(its one Adams refusal is
refuse_adams), withCOUPLED_SECTIONSandEXPONENTIAL_REPRESENTATIONSof that
module, the reference backend'shelpersattribute,
solprop.backends.registry.statistics_refusal,NativeBackend.far_field_statistics
andsolprop_native's*_FIELDStuples.reachedandreplay_toleranceare now insolprop.stepper.schedule,
and the general route's node chunk insolprop.backends.node_chunk
(general_node_chunk). - The problem descriptor between translation and the backends (
solprop.translate,
unstable within 0.x under ADR-058) describes one trajectory and leaves the run's policy
to a separate request
(SEP 47,
SEP 52).
Simulation,SimulationSettingsand theprop_*functions take the same arguments as
before.solprop.translate.problem.KernelProblemis renamedPropagationProblem, with
no alias. Its arrays carry no leading batch axis (the problem'sshape,
initial.field0andinitial.noise0, the operator's value tables,StageTerms.phi,
Observation.fieldandnoise_phase, the periodic rows ofStepStats,
ResponseBudgetError.field,RunEstimate.shapeand the fields that
BoundaryMonitor.powerandSplitCrossing.occupancytake), so code that indexed[0]
drops the index;Initial.batch_params,Flags.single_batch,
assemble(batch_params=...)andplane_from_observation(member=...)are removed. The
route-specific fieldstransform,flux,transverse,tdseandcurrent_numerator
move into a closed union,problem.route, from the new module
solprop.translate.routes(aModalRoute, aGeneralRouteor aSpatialRoute);
problem.transformstill reads the route's transform, andtdse_of,flux_ofand
transverse_ofread a route's own leaves. The problem no longer hasstepperor
stats_spec: the run's policy travels in the immutable
solprop.translate.run_request.RunRequest, whichSimulation.run_request()returns,
andassemblereturns aTranslation(problem, request)pair
(problem, request = assemble(...)).PropagationProblem.validate()checks the problem
alone, the newsolprop.translate.problem.validate_run(problem, request)adds the
checks that read the run's policy, andvalidate_launch,metadata_for,
field_retention,check_snapshot_request,run_summaryandcheck_derived_problem
take the request. A hand-built problem whose route, polarisation count, vector Raman
terms or TDSE statistics a backend refused withBackendErroris now refused with
TranslationError(solprop.translate.admission.check_general_route). Moved:
node_kerr_tensor,node_kerr_formandnode_delayed_mapsfrom
solprop.backends.numpy_reftosolprop.translate.general,QUADRATURE_ALARMto
solprop.translate.modal,MARCH_SNAPSHOT_AUTO_BYTESfromsolprop.driver.runto
solprop.translate.run_request, andMAX_N_POLto
solprop.nonlinear.responses.MAX_N_POLalone;CompiledResponsesno longer takes
response_order. - The node chunk is the backend's execution choice, planned when the backend is prepared, not part of the translated problem (SEP 47, #361):
Transform.node_chunkis gone, andassemble,multimode_transform,free_transform,planar_transformandradial_transformno longer takenode_budget(free_transformno longer takes the time grid, norradial_transformn_pol).SimulationSettings.node_budgetkeeps its meaning and its chunks, may change after translation, stays outside the resume key and reaches the backend throughExecutionOptions(node_budget=...)(select(..., options=...)or the backend'soptions=); an explicit budget is authoritative.from_capillary,from_waveguide,prop_capillaryandprop_waveguidenow defaultnode_budgettoNone, the backend's choice (the same 64 MiB on a CPU build), and the general-guide refusal ofnode_budgetnow refuses any value other thanNone. The default budgets and the rule are insolprop.backends.node_chunk(DEFAULT_NODE_BUDGET,DEFAULT_SPATIAL_NODE_BUDGET,plan_node_chunk).
Errors, logging and imports
DriverErroris now aValueErrorrather than aRuntimeError, asGridError,
PulseErrorandNoiseErrorare: nearly every one is a refused argument, so
except ValueErrornow catches a badn_saveas it catches a bad grid. Code that caught
aDriverErroras aRuntimeErrorshould catchDriverError(orSolpropError).
Simulation.runand theprop_*functions refuse aresumethat is notFalse,
Trueor"interpolated"with aDriverErrornamingresume, rather than a bare
ValueError.
The few failures of a scan's environment rather than of its request -- a refused memory
query, a failed Slurm submission or queue lease refresh, a scan point interrupted in its
worker -- raise the newExecutorError, aRuntimeError.- The refusals of a non-positive or non-finite number and of an unknown keyword now read
the same across the design tools, pulses, gas flow, antiresonant tubes, the TDSE
specifications and the processing and plotting functions:<name> must be finite and positive, got <value>and<name> must be 'a', 'b' or 'c', got <value>. A numeric
string given where those functions expect a number is now refused rather than parsed. solprop.loghas two reporter protocols instead of six.ProgressReporternow declares
all six calls (summary,started,step,plane,finished,interrupted), each
with a no-op default that a subclass inherits, andScanReporterdeclares
point_reporter(defaultNone).InterruptibleReporter,SummarisingReporter,
PlaneObserverandWatchingScanReporterare removed: anisinstancetest against
them becomes one againstProgressReporterorScanReporter, andobserve_planestays
an optional method that a reporter may define. A reporter that subclassesNullReporter
orNullScanReporterneeds no change. One written from scratch to the four basic calls
must now also definesummaryandinterrupted, or subclassNullReporter(or
ProgressReporter) to inherit them; a run refuses it with aDriverErrorbefore it
starts. Likewise a scan reporter must definepoint_reporteror subclass
NullScanReporter(orScanReporter).- The packages re-export only what a user calls.
solprop.modeskeeps the modes, guides,
collections, materials and the mode protocol, and now also exports the derived
quantities ofsolprop.modes.base(beta,beta1,beta2,beta3,alpha,zdw,
aeff,loss_length,db_per_m,transmission); its numerical machinery (the wall
families and limits, connections, quadrature rules,GasFillMixin, tolerances) is
imported from its submodule, for example
from solprop.modes.wall import worst_wall_limits.solprop.outputno longer
re-exportsPlaneStore,PlaneLayout,CheckpointOutput,RetainingOutput,
TerminalCheckpoint,StatedInput,serialise,resolve_metadata_write,
package_versionsor the layout and convention constants;solprop.driverno longer
re-exportsmetadata_fororplane_from_observation(import the latter from
solprop.driver.run), and neither it norsolprop.driver.runre-exportsLogReporter
orProgressReporter: import the reporters fromsolprop.log.solprop.nonlinear
exportsOptmatRate.
Front end and command line
solprop exportno longer takes the required--pythonflag:solprop export recipe.tomlprints the Python script, and--form pythonnames that form explicitly. Drop--pythonfrom scripts that call it.- In the desktop front end, every sheet's Saved planes row offers Evenly spaced
(n_save) and Explicit positions (save_planes), and typing into one form removes
the other in the same undoable edit. A setup opens on the form it holds; the object
sheets no longer turn a count into a list of positions, nor rewrite the positions when
the length changes. An object-sheet count of 80 planes, which left out the entrance, is
n_save = 81.
Added
Simulation.run_request()returns the run request translation built beside the problem,
translating once, asSimulation.translate()does for the problem
(#619).- The desktop front end runs every simulation and scan as a process of its own, which outlives the window and is followed from its record, and runs them on other machines over SSH too: a
workstation, a Slurm cluster or a rented machine, picked on the Runs on line. Each run
keeps its record in its folder there, so it survives a closed window or a dropped network
and is found again on reconnecting; a Runs window lists every run on every machine, a
results file is analysed on its machine, and a machine can be set up with solprop from the
window. See Running on other machines. - Added
solprop.output.capability.quantities,Quantity,QuantityKindand
compression_refusal: what a stored record's derived quantities are on its basis, and
why the compressors refuse a basis.solprop.capabilities.Quantityand
QuantityKindare the same objects, re-exported. - Added
solprop.output.serialisation.deserialise, the partial inverse ofserialise
that the record types use: it rebuilds an inlined array record and returns any other
JSON value unchanged. plotting.spectrogram,time_1dandspec_1dtakeplane=, a saved plane's index (negative from the end; a sequence of them for the slices), as the processing readers do; giving bothplaneandzraisesProcessingError.- Added
solprop.log.ResumeChoice, the typeresume=takes onSimulation.runand theprop_*routes, so their signatures andhelp()showresume: bool | Literal['interpolated']under a public name. solprop scan --help(andpython -m solprop.scan --help) now explains every option, with its unit and default.solprop calibratefits the native backend to the machine it runs on (SEP 46; Calibrating solprop to your machine): in about 30 s (--quick), two minutes, or seven minutes (--thorough), it measures how the native backend should thread and plan its transforms here, and keeps a setting only where it reliably beats the built-in value. The profile is kept per user in the platform's cache directory (SOLPROP_CACHE_DIRmoves it;SOLPROP_CALIBRATION_PATHadds shared read-only directories, such as a cluster's per node type), keyed by machine, build and allocation, and every later run applies it and records the settings it applied in its metadata (calibration). The first native run with no profile for its machine, build and allocation calibrates quickly by itself after aCalibrationNotice, and a scan calibrates its workers' allocation first;SOLPROP_CALIBRATION=usenever measures andoffignores profiles. Without a profile (withSOLPROP_CALIBRATION=useoroff, or on a device build), a run uses the built-in table keyed by operating system, whichBuildInfo's threshold fields report.Simulation.calibrate()andsolprop calibrate --reciperefine the settings for one simulation, reused by every run and scan point of the same execution, and--show,--export,--importand--clearmanage profiles.solprop.solexportsStatsSpec, which a session passes tostats=.
Changed
- A coupled flow refused by its conditioning guard (the taper coupling of a lossy multimode capillary at the default
dz_max, for one) now names the largestdz_maxit admits, read exactly from itsexp(dz_max spread)bound, instead of leaving the step to be found by trial (#159). VincettiMode's effective core radius uses the coefficient Rosa, Melli and Vincetti (2021) print in their Eq. 10,3 + 20 wavelength / core_radius, instead of 10, so its index, dispersion and fitted area change while the API and the loss do not. For the tutorial fibre (15 µm core, six 9 µm tubes with 180 nm walls) at 800 nmbeta_2moves from -479 to -471 fs²/m, and filled with argon its zero-dispersion wavelength moves 1.7 to 3.7 nm longer between 5 and 30 bar. The coefficient is not a parameter: results with the old value of 10 need solprop 0.2 (#160).- The native backend's CPU transforms are faster on many threads (#598; ADR-075): a batch of transforms now threads by its shape, about one thread per row and the whole team only for many rows, instead of by its element count, and a multi-mode stage transforms its forward rows (projection, absorber, plasma currents) as one batch, as on a GPU (
SOLPROP_NATIVE_FORWARD_PACK=0turns that off). The tracking cases ran 0.98 of their time on geometric mean on 18–36 cores of an Intel Xeon Gold 6240 and 16 of an AMD EPYC 7763, the few-mode capillaries and the one-dimensional free-space beam 0.80–0.95. - On a Mac whose chip has cores of more than one kind, the thread budget is now the cores of the fastest kind (
hw.perflevel0.physicalcpu, 6 on an Apple M5 Max rather than all 18), unlessSOLPROP_THREADSis set: every thread of a parallel pass waits for the slowest, and five of six benchmark cases ran 1.17 to 1.49 times faster on the 6 top-tier cores (#333, ADR-070). SetSOLPROP_THREADSto use every core; the run'sthread_budget_sourcerecords"top-tier cores". - Python processes solprop starts (a run from the window, directly or as a Slurm job, the window's kernel, and
Poolworkers) takeOPENBLAS_THREAD_TIMEOUT=20unless it is set, as does the batch script of a Slurm scan (solprop.driver.executors.Slurm) for its controller, so NumPy's and SciPy's OpenBLAS pools no longer spin on every CPU for a moment as they load: importing the driver used 13.8 CPU seconds on a 72-CPU Linux machine, and now 0.75 (#383). The performance guide says how to set it for your own scripts. - A finished file run is readable through the handler it returned:
prop_*(..., output="run.h5")andSimulation.runhand back a closedHDF5Outputwhose reads
(run["field"],fields(),plane_field(), processing functions and plots) open the file
read-only for the one read and close it again, so no handle is held between reads. A
suspended writer still refuses, and the refusal now says why. Once another run has written or
continued a file at that path, the handler's read is refused, naming the file, and
open_filereads what the file now holds. - The README, the package metadata, the desktop front end's Help and the native backend's
error messages now link the manual of the newest release (/en/stable/) rather than the
development version (/en/latest/), and the installation page's advice for a platform
without a native wheel now allows for the yanked 0.1.0. - The transverse edge's read spacing has a growing backstop:
min(B, 4g/v_q), withBstarting atL/16and doubling at each read whose reach has not grown by a tenth since it started, up toL/4. A free-space run whose spectrum holds far from its edge no longer takes extra steps for its reads. On the suite'slinecase the edge costs 2.9 % of the run where it cost 12.8 %, with 13 reads where it took 23 (#396). A planar run also no longer evaluates its slab modes again at each run to set up the edge. - The native backend now keeps the FFTW plans its runs measure by default, so each transform shape is measured once per machine and build instead of on every run. Plans are kept per transform in
wisdom.jsonin the calibration store's directory for the machine and build, and a calibration profile's own plans take precedence.SOLPROP_FFTW_WISDOMnow only moves this file.SOLPROP_CALIBRATION=offkeeps no default file, andsolprop calibrate --clearremoves the plans. Plans kept by earlier releases are not read; their files can be deleted. The store is keyed by the machine fingerprint, which tells Apple silicon models apart (#136). - The front end's service layer (its kernel process, run workers, live reductions and their
messages) moved fromsolprop_gui.serviceinto solprop assolprop.service, so a machine
that only runs simulations for the desktop front end needs solprop alone, without Qt. It is
front-end support, not part of the user interface, and may change without notice. - The progress refusals of
solprop.log(set_default_progress,default_reporterand
BarReporter'speriod) raise aDriverErrorinstead of a bareValueError
(DriverErroris now aValueError, soexcept ValueErrorstill catches them); and
configure_logging(file=...)writes the log file as UTF-8 whatever the locale. - The native backend's idle OpenMP threads now spin briefly within native work instead of sleeping at once:
GOMP_SPINCOUNT=10000on GNU's runtime and, on LLVM's (macOS and Windows), a 1 ms block time inside native calls only. Waking sleeping threads cost 16 to 72 µs for each of a step's many short parallel regions; benchmark windows ran in about 0.8 of the time on an Apple M5 Max, two Intel Xeon Gold 6240 and a shared AMD EPYC 7763 node, and in 0.87 of it on an AMD EPYC 9B45 under Windows (ADR-071). Teams wider than a chip's fastest cores keep sleeping at once. SetOMP_WAIT_POLICY=passiveto restore the previous behaviour. - The native backend evaluates and finishes its statistics natively from a plan lowered once (SEP 47 section 6.4), so the default statistics of a modal, general modal, radial or free-space run no longer return to Python, and a general modal plane's statistics no longer copy the field to the host. A profile statistic (
density,pressure,core_radius) reads a table of its path, andzdwa table of each mode's zero-dispersion wavelength along z made once before the run; their measured errors, at most 1e-13 of a profile's magnitude and 1e-6 of a wavelength, are recorded in the run's execution record understatistics_tables. A modal power weight that varies in z is summed in another order, a rounding-level change. The native backend recordszdwasnanwhere the band holds no zero, asnumpy_refdoes, instead of raising, and refuses by name the metric statistics of a general modal basis whose metric varies inside one of its intervals. On every backend, a statistic the problem does not carry is refused by name before the run starts instead of at the first saved plane: a modal statistic such asomega0on a spatial run, a spatial statistic such asbeam_radiusorabsorbed_poweron a modal run (wherenumpy_refused to return the peak ionisation rate asabsorbed_power), the plasma integration diagnostics without a field-grid plasma column, and the electron density or peak ionisation rate without a plasma response. - The gas-flow functions (
physdata.transport.viscosity,molar_mass,sound_speedand thegasflowcalculations) validate a composition by the ruleMixture.fillapplies: its fractions must sum to one within the rounding of its entries (two ulps per entry) rather than within 1e-12, so a flow and a fill accept the same compositions. The refusal messages are the fill's. ModeCollection.orthonormalityandsolprop.modes.collection.orthonormality, and so the orthonormality check on a mode set given to a waveguide simulation, integrate the whole overlap matrix in one adaptive pass instead of pair by pair: 24 capillary HE1m modes in two polarisations take seconds instead of minutes, and agree with the pairwiseoverlapto its accuracy (#879).- Project and tooling: the benchmark harness gains performance-history rows for 0.2.0
(benchmarks/history/, on the same nine hardware sets as 0.1.0) and--counterson
trackandab, one separately reported run per worker with the native backend's
structural counters (returns to Python by cause, native calls, attempts, planes,
statistics rows, edge reads and host copies). History rows record the OpenMP wait policy
and are compared only within one native build profile, andtrack --append-history
refuses a native build stamped+dirtywithout--allow-dirty
(#138). - A scan's workers ask for passive waiting instead of setting
OMP_WAIT_POLICY=passivethemselves, so that a user's ownOMP_WAIT_POLICY,GOMP_SPINCOUNTorKMP_BLOCKTIMEnow reaches them, and so does a machine calibration's row for the workers' allocation (SEP 46); without either they wait as before. Their recordedopenmp_wait_policyreadspassive. - Snapshots now work with interpolated planes (
interpolate_planes=True), which they refused before: a requested snapshot is taken at the end of the step that crossed the plane being saved, once every plane that step crossed has been saved, or at the next accepted endpoint, so its running checkpoint is a state the march passed through, whichresume=Truecontinues withoutresume="interpolated", saving each later plane once. A step plane owed by a step that crossed an interpolated plane and ended on the next one is no longer saved twice at that position (SEP 47). - A kept plane's field is exported once, straight into its stored form, with the same stored bits (#346, SEP 47).
MemoryOutputhands the run the block row the plane will occupy, so the field is written once, where it is kept, with no host volume of its own;HDF5Outputis handed one new array, which h5py writes into the plane's chunk without a copy. On a 108 MiB Cartesian plane the native backend's saved plane no longer allocates a field into memory and one fewer into a file, and a modal plane onnativemakes two field-sized arrays where it made three. For a custom store,PlaneStoregainstakes_exports,field_destinationandsave_exported, withsolprop.output.records.StoredFieldbeside them; a store subclass that overridessaveis still given every plane, with its field, through it. - On a GPU build (CUDA or HIP) of the native backend, runs take the compiled session of a
CPU build, with its coverage and its refusals
(SEP 47),
and device builds also refuse the Adams carrier frame by name. On an NVIDIA A40 (CUDA)
the session takes the same steps, statistics and fields as the backend's previous march
on the same device (dense Runge–Kutta planes and the transverse edge's ramp sums within
rounding bounds); device builds are not yet qualified on either vendor. A saved plane's
field crosses from the device once, into its destination, with no extra host copy. - The native backend runs every run it admits in its own compiled session, with no Python
step loop
(SEP 45,
SEP 47).
Beside the Adams march it already had, it now steps the adaptive Runge–Kutta loop of
RungeKutta()and the low-storage replay (LowStorageRungeKutta) natively, and the
session also runs resumed runs, the noise models, dense output (interpolate_planes),
the temporal boundary monitor, a free-space run's transverse edge, the Adams carrier
frame on an operator stored as a z table (#255), and coupled flows wider than 16
channels or with bins off their eigenbasis route, which 0.2.0 stepped with solprop's
Python march; such a flow's step whose exponent would need more than 30 squarings is
refused by name. A run's backend metadata says which loop stepped it (adams_march,
rk_march). Some results move at the rounding level, because
the Runge–Kutta error norm, the split collar's crossing limit and the transverse edge's
safety-ramp shares are summed in another order: in a near-tie a split-scheme run's
collar bucket can move one place, and an edge warning or stop may differ from
numpy_ref's for a share within a rounding bound of its threshold. - A progress reporter now hears a run's attempted steps in batches, as the run's session delivers them: once per save plane, and at least every 256 attempts or 0.1 s in between. It no longer hears each step as it is taken (SEP 47 section 5.3). Each attempt is still reported once and in order. As a result, a stop flag that a reporter sets lands up to one batch later, at most 256 attempts or 0.1 s, on every backend, the NumPy reference included. A flag set from outside the run is still polled between batches, as before.
- Each execution record now states what a restart keeps and restores, under
outcome.execution["restart"]: whether a plane's or checkpoint's method history wasretained,omittedor isnot_applicable, with a reason (explicit_policy,automatic_policy,automatic_size_limit,snapshot_required,unavailable_history,output_cannot_store,write_failed,incompatible_representation,unsupported_method,no_method_history), and in a resumed execution what itrestored,reset(a Runge–Kutta resume's proposal and norm memory, an Adams history set aside) or foundnot_applicable(low-storage), and that the boundary monitor was reconstructed from its persisted records. A resume now warns once (SolpropWarning) when an Adams history it expected was omitted by the automatic 256 MiB limit, was not exportable, or cannot be read back (including a write cut short);resume_history=Falseis recorded without a warning (SEP 47). - Snapshots no longer require
step_planes=1: a requested snapshot is taken at the next accepted endpoint, and where no plane is saved there the run writes a running checkpoint, in the existing terminal-checkpoint record with a matchingrunningoutcome, from which the snapshot andresume=Truecontinue. The attempts and periodic rows since the last plane stay with that plane, once, and a later saved plane supersedes the checkpoint. A low-storage step abandoned in flight now falls back to the latest running checkpoint, or to the checkpoint the run resumed from, rather than to the last saved plane (SEP 47). - On a CUDA or HIP build, a run with no
node_budgetand no node chunk now plans its node chunk within a quarter of the accelerator's free memory, through the same rule and response admissions as the host's plan, and never takes fewer nodes than the host plan at the route's default budget (#361). Most spatial runs on a data-centre GPU then evaluate their responses in one chunk, which took 0.74-0.92 of the default's time on an AMD Instinct MI300X, at the cost of space-domain buffers for every node at once (about 5 GB more on a 128 x 128 Cartesian filament). The run recordsnode_chunk_rule = "device"in its backend metadata. CPU builds are unchanged. - On macOS arm64 the native backend's CPU kernels now take SLEEF's 1-ulp AdvSIMD vector
exp,logandsincosby default (SOLPROP_NATIVE_VECTOR_MATH=AUTO), as x86-64 builds do: on an Apple M5 Max the comb-to-continuum case ran 0.84 of its time at one thread, and the tracking cases 0.93 on geometric mean, with none slower beyond its spread (ADR-072, #339). Linux aarch64 keeps the system libm, where SLEEF measured level (1.00 on a Neoverse V2). - Smaller speed-ups, each with the same results. Building a graded-index guide evaluates
its material once per mode solve rather than once per finite element (the
grin_nonlinearbuild and translation from 24 s to 16 s on one core), and a large
free-space launch forms each distinct column's admittance once, in threads (a 384-node
Kerr beam's launch from 12.6 s to 7.1 s). A run's fixed host cost is smaller: the first
statistics no longer importscipy.signal(0.7 s), opening a run's output no longer
digests its configuration a second time, and package versions are read once per process
(#347). Host passes too small to thread
no longer read the CPU topology first (#556). On the native backend, free space's
separable stage propagators go through its vector maths (line0.89 of its time at one
thread; #338); radial transverse-edge
reads synthesise their rows in one matrix product (radial filaments down to 0.75 of
their one-thread windows on an Apple M5 Max); single-mode problems use Apple's
Accelerate as they use OpenBLAS; and on Arm hosts the plasma column's band filter sums
its taps in one pass (the plasma cases 1-6 % faster on an Apple M5 Max, #560). - On Apple silicon, where the native backend's idle threads spin within native calls on the top-tier cores, it threads smaller passes: every size threshold is divided by 16, since a parallel region there costs about a microsecond and the cluster shares its L2 cache. On an Apple M5 Max at six threads the Raman GNLSE ran 0.70 of its time and the comb-to-continuum 0.91, none slower (ADR-073). Other platforms keep the previous thresholds, which measured faster there.
- The TDSE response runs on the native backend's CPU build, and
backend="auto"now selects native for a TDSE run as for every other;backend="numpy_ref"still runs it, and a native GPU build refuses it by name (SEP 49). - solprop no longer pins a Pyroraptor revision: a TDSE run uses whatever provider is installed (by default its latest
main, until Pyroraptor has a release), and records the revision, build and execution space the provider reports; the provider's protocol version and its execution space againstTDSEExecution.deviceare still checked (SEP 49). - The TDSE response's atomic provider now runs in a worker process of its own, never in solprop's process, for presets, bases, consistency checks and runs alike; Ctrl-C, SIGTERM and a run's stop flag now stop a TDSE run during an atomic call, the call charged and the last accepted step checkpointed (SEP 49).
- The default search window of
modes.base.zdwandstats.zdw(stats.DEFAULT_ZDW_RANGE) now starts at 150 nm instead of 100 nm, above the noble gases' vacuum-ultraviolet lines and fused silica's absorption edge, where a lossless solve takes silica as transparent and finds zeros with no meaning; passwavelength_limitsto search below it.
Removed
- Removed the Roots button from a pinned value's editor in the desktop front end, which did nothing when pressed; the editor still takes the lowest or the highest root in the search range.
- Removed the hidden
--workflowoption ofsolprop-gui, which did nothing: the command now refuses it as an unknown argument. solprop.exceptions.HostMarchWarningis removed: the native backend steps every run it
admits in its own session and refuses the rest by name, so no configuration issued it.
Delete any import of it, or warning filter that names it, such as
ignore::solprop.exceptions.HostMarchWarning.- Building solprop-native from source: removed the
SOLPROP_NATIVE_GEMM_PROVIDERoption (every build uses the hybrid provider,build_info().gemm_provideris always"HYBRID"), thecuda-custom,cuda-nativeandcuda-tplpresets,SOLPROP_NATIVE_BUILD_BENCHMARKSand its GEMM microbenchmark,SOLPROP_NATIVE_ENABLE_THREADS(the Kokkos Threads host space; CPU builds run OpenMP) and IntelLLVM (icpx) support (Linux CPU builds take GCC 14 or newer, or Clang 14 or newer). A CPU build no longer needs a single-precision FFTW, and the wheels no longer carry one. - The native backend's private host-march switches are retired as production modes (SEP 47 §6.3): the environment variable
SOLPROP_ADAMS_MARCHis no longer read, andNativeBackendno longer takes anadams_marchkeyword. They selected solprop's Python march on the native engine for A/B comparisons; every native run now steps in the native session. A problem whose operator or prefactor representation the native stage tables cannot read, which no built-in configuration produces, is now refused by name when the backend is built instead of being stepped with stage rows formed on the host.
Fixed
- Recorded the position of a
resume="interpolated"continuation in the
interpolated_resumesannotation before its first step, so a session that stops or
fails later still names where it restarted; before, only a session that finished was
recorded (#152). - Fixed the
numpy_refdefinition ofon_axis_spectrum,aperture_on_axis_spectrumandspatial.node_spectrumat a field grid's zero-frequency and Nyquist bins: they now weigh those bins as the analytic signal does, a quarter of an interior bin, as the native backend already did, so both backends agree there and the sum timesd_omegais exactly the fluence (#155). modes.base.zdwnow searches the sampled sign ofbeta_2and keeps a sign change as a zero only where the analytic group delay has a resolved extremum andbeta_2keeps each sign for 1.5 % in frequency on either side; a change that is not a zero blocks the search only where the group delay is not finite or not continuous (a gas line), and the fine structure of a narrow feature, such as fused silica's OH absorption bands near 1.38 and 2.7 µm, is passed over. So a gas resonance's poles are no longer read as zeros, a window whose ends agree in sign no longer hides the zeros inside it, and the answer no longer depends on the window: a standard telecom fibre reports its 1.3 µm zero from a 1550 nm reference on any window that holds it. Several zeros in the window raiseModeErrornaming them, where an arbitrary one was returned orNoZeroDispersionErrorraised; the newnear=reference wavelength picks the nearest zero that no line separates from it.stats.zdwtakesnear=too, and thezdwrun statistic and the recipe's mode preview pass the grid's reference wavelength, so a krypton capillary whose band reaches its 120 nm lines records and previews its 770.5 nm zero instead ofnan(#157, #527).- A hand-built fill of the dispersion-only
Airentry, such asMixture.fill({"Air": 1.0}, 1.0), is now steered toMixture.air: its refusals of Kerr (carrier or dispersive), plasma (which called it a custom species) and an explicit Raman selection all nameMixture.airfor air with Kerr, plasma and Raman channels, and anenvelope=Truecapillary run withkerr=False, which runs linear, logs that once at INFO (#164). - Dropped optmat's internal tracker ids, references users cannot look up, from every
optmat text solprop passes on: its range and absorption warnings (MaterialRangeWarning),
the status reason of each material record (MaterialRecord.status_reason, and so the
run's material manifest andsolprop.capabilities.species) and the
MaterialStatusWarningbuilt from it, which also no longer doubles the reason's full
stop. The rest of each text is unchanged
(#166). - A
LocalorPoolscan that ends with an exception (an interrupt, a refused worker
admission, a point that conflicts with the file) gives back the points it had claimed,
and a rerun computes any point an earlier scan leftrunning, rather than skipping it
for ten minutes and reporting it as running
(#168). - The Adams page no longer says that a linear run beside a frozen-residual coupled flow is accurate only to its
dz_maxwhateverrtol(#252): that run's error followsrtol. What was measured was a launch far belowatol / rtol, which the error norm holds toatoland not tortol, under any integrator; the solver page now says so. - A
Simulationnow copies itsconfiguration=when it is built, andwith_inputthe
caller'sconfiguration=keys: dictionaries, lists, tuples and sets are rebuilt and
arrays become read-only copies, so changing them before the run no longer changes the
recorded configuration or its hash.PiecewiseLinear,PressureGradient,
FromCallable(its declared positions) andSeriesOfPathkeep read-only copies of the
arrays and series they are given, so changing a profile's table after passing it to a
simulation no longer changes the run or its record.SimulationSettingskeeps
componentsas a tuple copied from the sequence given
(#471). - The run summary of a native free-space run no longer says its transverse edge is unwatched: every backend reads the edge, so the summary no longer decides by the backend's name (#599).
- Preserved the original error and retained a retry owner when acquiring host BLAS
limits and rolling them back both fail. The next acquisition retries the rollback
before applying new limits, so a failed request no longer leaves a BLAS pool at its
width indefinitely (#697). SimulationSettingsnow refuses aresume_historythat is notTrue,Falseor
None. A recipe's[execution]table that wroteresume_history = "none"built a
run, and a Python export, that kept the Adams history always, the opposite of what it
said; omit the key for the automatic choice
(#703).- A
SimulationRunner, and the backend a scan keeps between points, is no longer reused
for settings that name another backend or node budget: a scan point builds a backend of
its own, and a directrunner.runafter such a change raises aDriverErrorbefore it
reads the input (#705). - The desktop front end no longer builds a class's sheet twice when the kernel answers its
route's description twice, once for the description fetched ahead and once for the one
asked as the setup opened; the second build replaced every widget on the sheet for
nothing (#791). - Fixed a segmentation fault of the native backend on a CUDA build for compute capability 8.6 (
AMPERE86, such as an NVIDIA A40): every radial run crashed in its first step, envelope or field, with or without a collar or statistics, with every stepper. The device GEMM's kernel is now a named functor; as an extended host-device lambda instantiated alike in several source files, a Release build called a null copy function. Other device targets and the other routes were not affected (#815). - An Adams run (
Multistep, the default of the capillary interfaces) no longer silently ignoresSimulationSettings(interval_cap=...): the Adams march caps its steps byMultistep(interval_cap=...), a different explicitinterval_capis now refused by name, and the run's stepper record and resume key carry the cap the march applied. A coupled-flow Adams run used to recordinterval_cap=Truewithout being capped; it now recordsFalse. - Fixed the Adams march dropping the attempt row of a rejected trial whose reduced
proposal fell belowdz_min: the completed trial is now recorded, on both the NumPy
reference and the native backend, before the floor'sConvergenceErroris raised; the
proposal, accepted state and call ledger are unchanged (#651). - The TDSE response's per-configuration memos and the envelope plasma's cycle integrals,
which kept one entry for every configuration or field range met, now keep the sixteen
most recent, so a long scan or front-end session no longer grows its memory with them. solprop.capabilities.outputnow states a spatial file's field in the run's stored unit
(V m radially, V/m on a Cartesian or line grid, sqrt(W/m) per y frequency on a planar
one) instead of sqrt(W), and no longer states a modal power, energy or spectral density
for it, whose readers refuse a spatial file (#425).scalar_paraxialcoupling into a capillary reports the omitted leaky-field physics for the field actually coupled, as the change of power launched into each mode. The recorded capillary envelope was measured only on Gaussian beams and equal-amplitude three-mode exits, so it understated the discrepancy for structured fields about tenfold: at delta = 2.5e-3 (a 75 µm capillary at 800 nm) a structured beam or a capillary exit of a few modes with arbitrary amplitudes changes the launched power by 1e-2 to 2e-2, against the 1.5e-3 the record allowed. The new envelope, evaluated against Marcatili's leaky HE1m field, is reported with scopefield. Its mode range now bounds the highest HE1m radial order present, up to 24, rather than the channel count, so two polarisations of four modes are no longer counted as eight and a set such as HE1,25 to HE1,33 is refused rather than counted as nine.- The
processing.scans.field_at_planereduction reads its own plane withOutput.plane_field, so it evaluates on a run saved withfields="planes"whose chosen plane kept its field, rather than raisingOutputError. - The desktop front end no longer keeps every publication figure it exports in memory: the
analysis process closes each figure once written, so a long session neither grows nor
warns of more than twenty open figures. - The desktop front end no longer shows a GNLSE fibre's results with a Noise and coherence page that could never be opened: no run is a seeded ensemble the page could read.
- The desktop front end's Home lists the workspace's runs on a thread, so a large or
network-mounted workspace no longer blocks the window at each refresh; it lists the runs
that have a results file. - The desktop front end now says at the foot of its window when solprop's kernel fails to give the examples, the list of gases, the run options, a class's example or a sheet's curve, where Home or the sheet was left empty without a word.
- The hollow modes (
MarcatiliMode,VincettiMode, the tabulated, rectangular and slab modes) now refuse analphacallable that returns a non-finite or negative attenuation, or one of the wrong shape, withModeError, asStepIndexModedoes, instead of carrying NaN intoneffor reading a negative value as gain; every family evaluatesalphathrough one helper. - A
GasFlowWarningabout a capillary or hollow-core fill raised through a recipe, a scan
or the service now names the caller's line, as one raised by a direct
Simulation.from_waveguidecall already did, instead of a line inside solprop. solprop.physdata.ideal_gas_density, anddensityandpressurewithideal=True,
now refuse a NaN or infinite pressure, number density or temperature with a
MaterialError, as the real-gas path already did, rather than returning NaN or
infinity.MemoryOutput.to_filenow writes the recipe a run was built from, so a recipe run kept in memory and written to a file can be resumed (solprop resume), read back withRecipe.from_output, and give its saved planes their basis identity, as the file anHDF5Outputwrites does.- The boundary monitor's record counts each committed step once: a step left unchecked and then checked at its saved plane is no longer counted among both the checked (
steps) and the skipped steps, so the two add up to the committed steps. Under interpolated planes, a plane that no check read since the previous one, as a later plane inside one step, records its collar and guard occupancies as unmeasured (None) rather than the previous collar reading and empty guards (#133). - Fixed a native Adams trial whose source evaluation failed leaving its prediction in the
state, so that the failed run's terminal checkpoint and march snapshot held the
prediction instead of the last accepted step (#129). - A native backend whose construction fails after its native workspace is built, by a
refusal, an error or an interrupt, now closes the workspace before raising, rather than
leaving it, and on a GPU build its device memory, to the garbage collector. - A CPU build of solprop-native with
SOLPROP_NATIVE_ENABLE_OPENMP=OFFis now refused when CMake configures it, with a message naming the options to set; it used to build and then be refused at every backend construction. - Selecting the native backend with a malformed process-start setting, such as a
non-numericSOLPROP_THREADS, now raises aBackendErrorcarrying the setting's
message instead of a bareValueErrororRuntimeErrorfrom the package import, and
solprop.backends.available()is documented as listing the installed backends. - A process started from one that imported the native backend no longer reports the inherited
OMP_PROC_BIND=falseas the user's choice: its run metadata'sopenmp_proc_bindisfalse, as in the parent, rather thanenvironment: OMP_PROC_BIND=false. The import marks the setting withSOLPROP_NATIVE_PROC_BIND. - Setting
OMP_PLACESwithoutOMP_PROC_BINDno longer caps every solprop thread pool and scan at the one core GNU OpenMP binds the main thread to: the thread budget now treatsOMP_PLACESalone as binding on, as libgomp does, and still believes a narrowing whenOMP_PROC_BIND=false(#172). OptmatRateraisesMaterialError, naming the species and the field, when optmat returns a NaN ionisation rate, instead of replacing it silently with the model's maximum rate; an infinite rate is still clipped to the maximum.- An output file whose recorded execution status (
meta/outcome) another build of the same output schema wrote now reads, as its run record does: an entry this build lacks is dropped and an absent one takes its default. A status that cannot be read is refused with anOutputErrornaming the file, where it used to raise a bareTypeError, and opening the file no longer leaves its handle open when it is refused. - The boundaries guide reads a band's absorbed energy from saved planes with an exact interval formula in place of the trapezoid, which overcounted a strongly absorbed band's loss by up to twice; the medium's own absorption is now its own share (#573).
- A
Poolscan point whose worker is interrupted, by Ctrl-C (which a terminal sends to
every worker) or SIGTERM, is now a stopped point, given back so that a rerun computes
it, instead of being committed asfailedwith aKeyboardInterrupttraceback. - Fixed a recipe pinning the capillary's
pressurebeside a temperature path failing
with aTypeErrorinside the solver:solprop.recipe.pins.solve_pinnow refuses it
with aRecipeErroron the pin, since a pinned pressure needs one temperature. GaussianPulsenow refuses a super-Gaussian ordermthat is not an integer of at least
1, asSpatialPulsedoes;PulseSumandSpatialPulserefuse a beam given as a temporal
pulse with aPulseErrorat construction instead of aTypeErrorat build time; and
PlanarPulse's printed form and the planar-grid refusal of aSpatialPulsename the
waistkeyword, not awaist_ythat does not exist.- A native run on a Python thread other than the one that imported
solprop_native, such as a front end's worker thread, now keeps to the thread budget: each native call sets that thread's OpenMP default width to the runtime's and restores it afterwards, so FFTW's threaded loops and an OpenMP OpenBLAS no longer take every CPU between narrower teams. Issue #130's reproduction ran 9 to 19 times slower on such a thread on two Intel Xeon Gold 6240, and 1.45 times slower on an Apple M5 Max, where it now matches the main thread (#130). - A Queue scan whose point owner exits while its process start is being read no longer fails with an unhandled
OSError; the owner is treated as unidentified until the next check (#760). - A recipe scan run on
QueueorSlurmnow records its recipe in the collected scan
file, as onLocalandPool, soRecipe.from_outputreopens it with its setup. - The on-axis plasma statistics on a Gauss-Radau field-scale rule read the whole axis row on a one-component transform (#663): when the modes have an axis field in a component the transform does not carry, as a rotated mode on
components=("x",)does, the rule's axis node no longer stands in for the axis row, so the statistic keeps that component (itshypotwith y on a field grid, the polarisation ellipse on an envelope grid) at the cost of one row scan. - A real-gas speed of sound (
physdata.transport.sound_speedwith a pressure) checks only the equation of state it comes from: it no longer warns that a gas's transport model is provisional (methane's), nor refuses a temperature inside the equation of state's range but outside the transport properties' range. refractive_index_minus_oneno longer loses precision at low pressure. It formedn - 1from1 + chi1, the cancellation it exists to avoid, so its relative error grew as the gas thinned: about 1e-12 for helium at 1 bar and up to 3e-7 at 1e-6 bar. It now forms it fromchi1itself, which scales with the density to rounding.- Fixed
coupling.regrid(..., crop_band=True)between two grids that share a lattice but not an active band (an explicitdt=, or limit pairs with the same short-wavelength end): it now removes the light outside the target's band, as itsRegridReportsays, instead of copying it and leavingcoupleto refuse the plane. - Fixed
solprop.output.resumabilityreporting that a writer still holds a file when the
writer lock could not be taken for another reason and the file's path contained the
words "another writer"; it now tells a held lock by its error type, not its message. Simulation.run(..., resume=True)no longer replaces the simulation's own noise
realisation with the one drawn from the resumed file's recorded seed. The redraw now
belongs to the resumed run alone, so a later freshrunof the same simulation is no
longer silently the resumed file's realisation; the resumed run itself is unchanged.- Keyword routes built on two threads at once no longer leave the process's warning
filters changed: each route's capture of the material warnings it names a keyword for
now waits for another thread's to end, where two overlapping captures restored each
other's filters and left every later warning recorded instead of shown. Poolscans now size their workers from the tightest control-group memory limit on the process's own path (version 1 and 2), not the root group's, so a scan under a systemd slice or other cgroup manager without Slurm variables is no longer admitted against the whole machine. An unreadable or malformed limit file, and a malformedSOLPROP_SCAN_CPU_OFFSETorSOLPROP_SCAN_CPU_COUNT, now raiseDriverErrornaming the file or variable instead of a bareOSErrororValueError(#170).solprop scanreports a refused or failed scan as onesolprop:line and exits with status 2, as the other commands do, instead of printing a traceback and exiting with 1.- Printing a
Scan, or showing it as a notebook cell's result, no longer raises for a
string, object or empty axis. - Rerunning a
LocalorPoolscan with every point already done no longer grows the scan file by rebuilding its consolidatedlayouts: they are rebuilt only when a point has been committed since they were last built, including by an earlier run that stopped before consolidating. Such a rerun now adds only itsexecutionsrow (#169). - The front end's analysis kernel keeps its own two-thread budget when the window is started with
SOLPROP_THREADSset (the window's value still goes to its runs), and draws the figures it exports with matplotlib's file-only Agg backend rather than the platform's interactive one. absorption_by_speciesof a gas-filled mode raisesModeErrorfor a single gas whosesusceptibility=law is absorbing, instead of reporting zero absorption while the law's loss is inneff; declaring the gas as a component of aMixtureattributes it.- A snapshot interval shorter than 60 s is honoured (#600): the 60 s retry back-off now follows only a failed or deferred snapshot attempt, where every successful publication used to impose it too.
- The desktop front end's spectrogram reports the gate solprop used: with no gate given it
showed a twentieth of the time range asked for, not of that range within the time window,
so a range wider than the window showed a wider gate than the map's. The default gate is
now given bysolprop.processing.fields.default_gate_fwhm. coupling.ScalarModeBasis.from_modesadmits several radial orders of one step-index fibre (HE11 with HE12, as LP01 and LP02), which it refused as modes of different fibres because each channel bounds its cladding at its own radius.- A
ModeCollectionof step-index channels of one fibre, whose outer radii differ, now integratesorthonormality()and its mode matrices over the widest channel's disc instead of refusing the set it accepted, and channels built withStepIndexMode.from_numerical_aperturefor one fibre are recognised as one guide; the newStepIndexMode.same_guidesays whether two channels share a guide.modes.collection.overlapis now the pair's entry oforthonormality, integrated to the same 1e-12 and refusing non-convergence withModeError, where it useddblquadat its default 1.5e-8 tolerance and only warned. It integrates the normalised product, so a supplied set of high-order capillary modes (from about 16 HE1m of a 75 µm capillary), whose normalisation integral is small, is no longer wrongly refused as not orthonormal. - A run stopped by its own
stop=flag now raises a failure to close its output, backend
or TDSE archive, instead of returning as a clean stop with the error lost. - The printed form of
TabulatedModeandTabulatedHollowModenow says what their loss is (loss=model,loss=none, ...) and names the fill as the other hollow modes do (Ar 1 bar,evacuated), andIndexTable's printed form calls its interpolation ruleloss_interpolation=rather thanloss=. - The TDSE provider's worker process no longer receives the running script's own
directory on its import path, so a module there named like a standard-library one
(a script'srandom.py, say) is not imported in the worker in its place. - Building a simulation no longer makes the caller's arrays read-only or keeps them by reference. Affected inputs: an absorber's rate arrays, the arrays passed to the translation layer's tables,
TabulatedDispersion'somegaandbeta, the backends' step histories, statistic rows and observations, and thesave_planes, knots and dispersion coefficients that the stepper and simulation settings,PathVariation,TaylorDispersion,InterpolatedDispersionandModalSamplingused to keep as views. An array a caller passes in is copied once. Arrays that solprop builds itself, such as translation tables, grid axes and masks, memoised ionisation rate tables and a backend's exported state, are frozen in place and passed on without a further copy (#759). VincettiModenow compares by identity, like every other mode, instead of by value: its
hash no longer changes when the mode logs its one-time gain warning, so a mode kept in
a set or used as a dictionary key is found again afterwards.- The
reprof a mixture-filledVincettiModenames the mixture's gases and pressure (He+Ar 2 bar), as the other mode families do, instead of the bare wordmixture. - The temporal collar's walk-off integral, read by
warn_walkoffand byabsorber(grid, walkoff=...), is now the rectangle sum over the periodic time axis, which is exact for the taper, rather than a trapezoid that left out one sample; a collar sized for a drift now removes exactly the statedexp(-2Γ)of its power, and the warning fires at the exact threshold (#490). - The walk-off
SolpropWarningofsolprop.boundaries.warn_walkoff, raised when a capillary
or hollow-core run builds its absorber, now names the caller's line instead of a line in
solprop's own route code. - Fixed the execution record of a run on Windows storing
Nonefor the host's
memory_bytesand the run'speak_rss_bytes: they now hold the installed physical
memory and the process's peak working set, read as the scan executors already did.