Results and Read-Back

Read stored analysis results as text, check them in a script and export them as CSV from the terminal.

The result commands read the results JSlope has stored for a scenario and print them in the terminal. The queries change nothing and add no undo step, so you can run them at any time, including while an analysis or a script runs. result.export downloads a file, so it is an operation, not a query: the Console refuses it while another command or a script runs.

Changing the model clears the scenario's LEM, transient stage and FEA results, so the queries then report that there is no result. A Rockfall run is kept after a change and marked stale.

Most take scenario= to read another scenario without switching to it; the default is the active scenario. The LEM queries take method= to read one analysis method: "bishop-simplified", "janbu-simplified", "janbu-corrected", "morgenstern-price" or "spencer".

Transient scenarios

A transient groundwater scenario has one LEM result per stage. result.lem, result.lem.slices, result.lem.surfaces, result.assert and the LEM exports take stage= to read one stage, such as stage="initial". Without it they read the stage with the lowest FOS (for method= when given), whatever stage the stage player shows, and name the stage they read:

› result.lem stage="rise"
✓ LEM result of "Rainfall" at stage "Rise": 1 method.

result.table, scenario.list and analysis.status also report a transient scenario's lowest stage FOS and name its stage.

Overview of every scenario

scenario.list
result.table
analysis.status

scenario.list lists the groups and scenarios with their Master, enabled and linked state, result status and lowest stored FOS with its method, such as 1.25 (Spencer), or 1.1 (Spencer, stage Peak) for a transient scenario. Each failed scenario is followed by a line giving its reason.

result.table tabulates the stored FOS of every scenario by method, with its status, and the reason for each failure:

› result.table
✓ 2 scenarios of 2 have a stored LEM result.
  id          scenario         status    Bishop Simplified  Spencer
  scenario-1  Master Scenario  complete  1.31               1.25
  drained     Drained          failed    0.95               -
  Drained: Search stopped at the iteration limit.

analysis.status shows what is running, the active scenario's result status and lowest FOS, and where each analysis runs: Runs on: LEM device, Rockfall device, groundwater device.

LEM results

Command	Shows
`result.lem`	For each method: FOS, λ, entry and exit, centre and radius or the surface points, the search and how many surfaces it evaluated, invalid-surface counts by reason, FEA-LEM Check, Surface Refinement and warnings
`result.lem.slices`	A table of every slice of the critical surface: width, base angle, weight, strength, stress, pore pressure and material
`result.lem.slices slice=3`	Every Slice Data value of slice 3, counted from 1 at the left end of the surface
`result.lem.surfaces maxFos=1.5 limit=50`	The stored slip surfaces, lowest FOS first, with entry, exit, centre and radius, sliding volume (m³/m) and maximum slice depth (m); 20 are listed unless `limit=` says otherwise
`result.lem.surfaces minVolume=20 maxDepth=6`	Only the surfaces that pass the limits, as the Filter Surfaces window applies them: `minFos`/`maxFos`, `minVolume`/`maxVolume` and `minDepth`/`maxDepth`, each a minimum, a maximum or (both given) a range, combined with AND
`result.stages`	For a transient scenario, each stage's time in the scenario's time unit, FOS, method and status or error. Each stage shows its lowest FOS across all methods, whatever method filter the GUI graph uses; `method=` shows one method, as a single-method GUI graph does. It fails when the scenario has no transient groundwater result
`result.probabilistic`	For each method: deterministic FOS, P25, P50, P75, mean, standard deviation, minimum, maximum, P(FOS < 1) and reliability index β
`result.probabilistic samples=true`	Also every sample's FOS and sampled inputs; the log shows the first 200 samples and the data holds them all

Where a query needs one method, such as the slices of a surface, it uses the critical method, the one with the lowest FOS, unless method= names another.

› result.lem method="spencer"
✓ LEM result of "Master Scenario": 1 method.
  Spencer: FOS 1.25
    Search: Grid Search; surfaces evaluated 120, invalid 0
    Entry (0, 10), exit (20, 2)
    Centre (11, 20), radius 15 m
    Lambda 0.31

Rockfall, Runout and FEA results

Command	Shows
`result.rockfall`	Rock counts, maximum runout, P95 and P99 stopping points, the travel-distance and endpoint distributions, and the peak impacts on collectors and barriers
`result.rockfall.impacts`	A summary of the peak impacts on every collector and barrier
`result.rockfall.impacts target="collector-1"`	Every peak impact on one collector or barrier
`result.runout`	The Runout summary and JRunout Results values: runout distances, rill angle, areas, swell, volumes, catch/failure ratio and termination
`result.fea kind="mesh"`	Both mesh summaries; add `analysis="groundwater"` or `analysis="stress"` for one
`result.fea kind="groundwater"`	The groundwater status, field range and water balance
`result.fea kind="stress"`	The stress status, maximum displacement, support reactions and plastic statistics
`result.groundwater.query id="probe-1"`	A transient probe's heads and pore pressure, or a discharge section's discharge and cumulative volume, at each stage; `history=true` lists every recorded time step

Times from result.groundwater.query and result.stages are in the scenario's time unit.

Reports from analyses

Analyses print a short report under their result, and under the failure message when they fail:

analysis.lem.run gives the critical FOS and method, such as Critical FOS = 1.234 (Spencer).
analysis.lem.run scope="enabled" (Compute All Enabled) gives a table of every scenario by method, and a line for each scenario that failed. When any fail, the message is Compute All Enabled finished with N failed scenario(s): ….
A stopped run that keeps its results still reports them: Stop and Keep on analysis.lem.run, or on Compute All Enabled, prints the kept FOS, and a stopped Rockfall batch prints the scenarios it finished.
A transient LEM run or groundwater solve gives the stage table.
analysis.rockfall.run gives each scenario's Rockfall metrics.
runout.run gives the maximum runout, the number of particles and steps, and the simulated time.

Checking a result

result.assert fails, and so stops a script, when the stored FOS is out of bounds:

result.assert minFos=1.3
result.assert minFos=1 maxFos=3
result.assert scenario="drained" minFos=1.5 method="spencer"

Give minFos, maxFos or both. Without method= it checks the lowest FOS across methods. For a transient scenario it checks the lowest FOS across the computed stages unless stage= names one, and the message names the stage. A pass prints, for example, FOS 1.25 (Spencer) of "Master Scenario" is ≥ 1.2.; a failure prints Assertion failed: FOS 1.25 (Spencer) of "Master Scenario" is below 1.3.

script.echo text="…" prints its text as the result, to label a script's output.

Exporting CSV files

result.export downloads a CSV file. It runs only when nothing else is running; in a script it runs in turn like any other line. Where the GUI has an Export CSV button for the same result, the file and its name match it; "lem-slices", "lem-surfaces" and "stages" are terminal-only formats.

result.export what="lem-slices"
result.export what="lem-surfaces" method="spencer"
result.export what="plot" plot="lem-local-fos" method="spencer"
result.export what="rockfall-distribution" metric="endpointX"
result.export what="groundwater-history" id="probe-1"

`what=`	Exports
`"lem-slices"`	The slice table of the critical surface, or of `method=`
`"lem-surfaces"`	The stored slip surfaces, with sliding volume and maximum slice depth columns
`"stages"`	The transient stage FOS table
`"probabilistic"`	The probabilistic samples
`"rockfall-distribution"`, `"rockfall-cumulative"`	The Rockfall distribution of travel distance, or with `metric="endpointX"` the final x (runout from the Toe Point when there is one)
`"rockfall-impacts"`	The collector and barrier impacts
`"groundwater-history"`	The history of the probe or discharge section named by `id=`; for a section, `series="volume"` exports cumulative volume instead of discharge
`"plot"`	The result plot named by `plot=`

"stages" and plot="transient-fos" use each stage's lowest FOS across all methods, not the viewport's method filter, so they can differ from the GUI's Graph FOS vs time when it is filtered; method= reproduces a single-method GUI graph.

Arguments that do not apply to the export are refused rather than ignored: metric= outside the Rockfall distributions, id= and series= outside "groundwater-history" (and series= for a probe), method= with the Rockfall and groundwater history exports, and stage= outside the LEM exports.

plot= is needed with what="plot" and allowed only with it. The plots are "lem-local-fos", "lem-normal-stress", "lem-shear-stress", "lem-shear-strength", "lem-fs-lambda", "lem-interslice-function" and "transient-fos".

Server runs

When you are signed in and run analyses on the JWG server (see Where analyses run), these commands do what the Server runs section of the Results pane does:

server.runs.list
server.run.cancel id="run-1"
server.run.apply id="run-1"
server.run.apply id="run-1" job="job-2"

server.runs.list refreshes the list of runs in progress and runs with results to recover, and prints one line per run and per job with their ids. It is refused when you are signed out or your account is unverified or the current Terms have not been accepted for new runs, and fails when the server cannot be reached.
server.run.cancel asks the server to cancel a run that is still in progress.
server.run.apply downloads a finished run's results and applies them to the scenario they came from, if its inputs still match the model. It applies the job named by job=, or the run's only job with a result. Applying cannot be stopped once it starts. Like a model edit, it waits while an analysis runs or a dialog such as Define Properties is open.

server.runs.list and server.run.cancel do not change the model, so they also work while a script runs.