Command line

Diokle is built on the Daedalus codebase. The daedalus command, the Python daedalus package, the Daedalus Modelica library and this repository keep their Daedalus names.

daedalus is one executable with a command per task. Every command takes the model sources (.mo files or directories, loaded recursively) and the model's full name:

daedalus <command> [sources...] -m <Model> [options]

Only the classes a model needs are parsed, so pointing at a large library costs little; parsed library files are cached on disk between runs (~/.cache/daedalus; DAEDALUS_CACHE moves it and DAEDALUS_NO_CACHE turns it off).

In plain terms: each command does one job on a model, such as checking it, simulating it or listing its unit problems. The table below lists them, and the options further down change how each one runs.

#Commands

The same compiler is also a Python package, import daedalus, for notebooks and scripts: see Python API.

#Simulating

# Experiment annotation defaults
daedalus simulate library/Daedalus -m Daedalus.Examples.LandingGear.SinkRates -o sink.mat

# Override the interval, tolerance, method and parameters
daedalus simulate library/Daedalus -m Daedalus.Examples.TorqueConverter.StallTest \
    --stop 6 --tol 1e-8 --method dopri5 -p engine.J=0.3 -o stall.mat

# CSV of selected variables
daedalus simulate library/Daedalus -m Daedalus.Examples.QuarterCar.BumpComparison \
    -o bump.csv --vars clean.body.s,aerated.body.s

translated in 11.7 ms; simulated in 7.2 ms (158 steps, 10 rejected (0 Newton), 378 f-evals, 3 jacobians, 2 events)

.mat results use Dymola's dsres layout, so Dymola, OMEdit, DyMat, ModelicaRes and existing post-processing scripts read them.

Add --profile to see where the solver spends its steps and time, and --method auto to let it switch between Dopri5 and BDF; see Performance analyzer and Solvers.

#Libraries

The bundled Daedalus library is a source directory like any other, and so is the Modelica Standard Library:

git clone -b v4.1.0 --depth 1 https://github.com/modelica/ModelicaStandardLibrary msl
daedalus simulate msl/Modelica msl/ModelicaServices msl/Complex.mo \
    -m Modelica.Mechanics.Rotational.Examples.CoupledClutches -o clutches.mat

-L DIR adds a library directory the same way, and DAEDALUS_LIB (or --lib) points at the bundled library.

#Steady states and trim

daedalus steady crates/daedalus-core/tests/models/steady.mo -m Steady.Pendulum \
    --free tau --target angle=0.5

trim of Steady.Pendulum at t = 0 (2 Newton iterations, residual 0.000e0)

states:
  phi = 0.5
  w   = 0

free variables:
  tau = 3.7625316269657856

targets:
  angle = 0.5 (target 0.5)

eigenvalues of the state Jacobian (stable):
  -2.343750e-1 - 3.272067e0i
  -2.343750e-1 + 3.272067e0i

The torque that holds the pendulum at 0.5 rad is m·g·L·sin(0.5) = 3.76 N·m, and the equilibrium is stable. Without --free and --target, steady finds the equilibrium for the inputs as they are. See Scripts and steady states.

#Scripts

daedalus run regression.mos --msl ~/ModelicaStandardLibrary

runs a Dymola or OpenModelica .mos script: loading files and libraries, translating, simulateModel and simulate, parameter sweeps with simulateExtendedModel, linearizeModel, steadyState and trim, with loops and conditionals. See Scripts and steady states.

#Testing a whole library

daedalus test-library library/Daedalus -m Daedalus

Each model runs in its own process, in parallel (--jobs N, default: all cores), with a time limit (--timeout S, default 60). CI runs this on every pull request, and a nightly job runs the MSL examples against their reference results (see Modelica Standard Library).

#Options

#Performance

Models run as machine code: the hot tapes (derivatives, outputs, zero crossings and algebraic loops) are compiled with Cranelift when the simulation starts, which takes a few milliseconds for most models. The results are bit for bit the same as the interpreter's (--no-jit); across the 555 MSL, Daedalus and MultiBodyVehicle examples the total run time drops by about 35%, and by half or more on multibody models (SevenPostRig 2.5 s to 1.2 s, EngineV6 5.7 s to 2.3 s).

The benchmark is tools/gen_chain.py: a chain of N masses and spring-dampers driven by a sine force, a stiff system with 2N states, simulated for 1 s with BDF at tolerance 1e-6.

python3 tools/gen_chain.py 2000 > chain.mo
daedalus simulate library/Daedalus chain.mo -m Chain --stop 0.2 -o chain.mat