Wolfram Language & System Documentation Center

SystemModelValidate

SystemModelValidate[sys,req]

validates the requirement req in the system model sys.

SystemModelValidate[sys,req,spec]

validates the requirement req according to spec.

SystemModelValidate[sim,…]

validates the requirement for the SystemModelSimulationData object sim.

SystemModelValidate[…,"prop"]

gives the value of the property "prop".

SystemModelValidate

SystemModelValidate[sys,req]

validates the requirement req in the system model sys.

SystemModelValidate[sys,req,spec]

validates the requirement req according to spec.

SystemModelValidate[sim,…]

validates the requirement for the SystemModelSimulationData object sim.

SystemModelValidate[…,"prop"]

gives the value of the property "prop".

Details and Options

SystemModelValidate is typically used to validate system behaviors related either to safety or performance requirements.

The requirement req is used to describe how signals evolve over time and will be either true or false as a whole for the system sys.
The requirement req is specified using the following temporal scoping constructs:
SystemModelAlways[t,texpr] texpr is always true for

SystemModelEventually[t,texpr] texpr is eventually true for
The global values and are given by the simulation interval of the system sys by default.
The temporal expression texpr is a Boolean-valued function of time t and can be given as:

	f₁[t]<=f₂[t], f₁[t]>=f₂[t], ...	with f₁[t] and f₂[t] real valued
	b₁[t]&&b₂[t],b₁[t]\|\|b₂[t], ...	with b₁[t] and b₂[t] Boolean valued
	SystemModelSustain[texpr,{min,max}]	when texpr is True at least min and at most max time units
	SystemModelUntil[texpr₁,texpr₂]	when texpr₁ is True until texpr₂ first becomes True
	SystemModelDelay[texpr,δ]	when texpr[t-δ] is True

The time variable t is specified in the scoping constructs SystemModelAlways or SystemModelEventually.
SystemModelValidate returns a SystemModelValidationData object val by default that can be used to extract additional properties using the form val["prop"].
SystemModelValidate[…,"prop"] can be used to directly get the value of val["prop"].
Validations with uncertainty in parameter, initial values or input signals return success probability, with optional failure configuration reporting.
Specifications in the association spec related to uncertainty include:

"InitialValues"	{v₁val₁,…}	variable v_i has initial value val_i
"Inputs"	{in₁fun₁,…}	input in_i has value fun_i
"ParameterValues"	{p₁val₁,…}	parameter p_i has value val_i

Specifications in spec related to reporting and simulation include:

"MaxFailureIntervals"	Automatic	number of failure configurations to report
"SimulationCount"	200	target number of simulations
"SimulationInterval"	{t_min,t_max}	simulate from time t_min to t_max

Typical properties that can be retrieved with SystemModelValidate[…,"prop"] include:

	"Configuration"	failure configurations to report
	"FailureIntervals"	intervals of t at which texpr is False
	"FailureIntervalsPlot"	plot of failure intervals
	"FailurePlot"	plot of validation of texpr
	"FirstFailureTime"	first t at which texpr is False
	"SuccessProbability"	requirement validation result

The system model sys can have the following forms:

	SystemModel[…]	general system model
	StateSpaceModel[…]	state-space model
	TransferFunctionModel[…]	transfer function model
	AffineStateSpaceModel[…]	affine state-space model
	NonlinearStateSpaceModel[…]	nonlinear state-space model
	DiscreteInputOutputModel[…]	discrete input-output model

When multiple sources of uncertainty are provided, simulations are performed covering their combinations, using the target number of simulations as an upper bound.
The values val_i in "ParameterValues" and "InitialValues" can take the following forms:

	pval	a single value
	{pval₁,…}	custom list of values randomly sampled
	int	an Interval or CenteredInterval uniformly sampled
	dist	an Around or a distribution to sample
	reg	a region to sample uniformly

Multidimensional regions and distributions val_d for sets of d variables can be set with {v₁,…,v_d}val_d.
The inputs fun_i in "Inputs" can take the following forms:
f a single function f[t] at time t

{f₁,…} a custom list of functions randomly sampled

rproc a random process to sample
Vector-valued functions and processes fun_d for sets of d inputs can be set with {in₁,…,in_d}fun_d.
The following options can be given:

Method	Automatic	what simulation method to use
ProgressReporting	$ProgressReporting	control display of progress
SamplingPeriod	Automatic	sample period for random processes

Examples

open all close all

Basic Examples (3)

Validate a bound in the voltage of a resistor in a model of a circuit:

Wolfram Language code: val = SystemModelValidate[[image], SystemModelAlways[t, "R2.p.v"[t] < 0.55]]

Plot the voltage and the bound:

Wolfram Language code: SystemModelPlot[[image], {"R2.p.v", 0.55}, PlotRange -> All]

Show the failure plot:

Wolfram Language code: val["FailurePlot", 1]

Validate safety bounds in the temperature response of a heating system when the incoming heat flow is in a region:

Wolfram Language code: model = \!$\*GraphicsBox[«8»]$;

Set the interval for the heat flow:

Wolfram Language code: uncertainty = <|"ParameterValues" -> {"burner.Q_flow" -> Quantity[Interval[{1500, 1800}], "Watts"]}|>;

Validate for all times after 2000 seconds:

Wolfram Language code:

SystemModelValidate[model, SystemModelAlways[t, 2001 ≤ t, 342.15 < "heater.mediums[1].T"[t] < 343.65], Join[uncertainty, <|"SimulationCount" -> 50|>]]

Plot the uncertainty in the temperature for the given heat flow interval together with the bounds:

Wolfram Language code:

SystemModelUncertaintyPlot[model, Join[<|"Outputs" -> "heater.mediums[1].T"|>, uncertainty, <|"SimulationCount" -> 50|>], ...]

Validate bounds for the position of a camera in a model of vertical stabilization against force disturbances in the form of white noise:

Wolfram Language code: model = \!$\*GraphicsBox[«8»]$;

Set the noisy input:

Wolfram Language code: uncertainty = <|"Inputs" -> {"fw" -> WhiteNoiseProcess[1000]}|>;

Validate the condition for the whole simulation interval:

Wolfram Language code:

SystemModelValidate[model, SystemModelAlways[t, -0.02 < "xce"[t] < 0.02], Join[uncertainty, <|"SimulationCount" -> 50|>], IconizedObject[«option»]]

Plot the uncertainty in the position of the camera together with the bounds:

Wolfram Language code: SystemModelUncertaintyPlot[model, Join[<|"Outputs" -> "xce", "SimulationCount" -> 50|>, uncertainty], ...]

Scope (21)

Basic Uses (3)

Validate the requirement, "The DC voltage in the rectifier should not exceed 540 V for more than 0.002 s.":

Wolfram Language code: req = SystemModelAlways[t, !SystemModelSustain["uDC"[t] > 540, {0.002, ∞}]];

Wolfram Language code: val = SystemModelValidate[\!$\*GraphicsBox[«8»]$, req]

Show the failure plot:

Wolfram Language code: val["FailurePlot", 1]

The DC voltage goes above 540 for 0.00252 s:

Wolfram Language code: ArcLength /@ val["FailureIntervals", 1]

Start with a model of a tank system and simulate it for 30 s:

Wolfram Language code: sim = SystemModelSimulate[[image], 30];

Validate the requirement, "Whenever the water level in the first tank is above 1.2 m, and for at least 6 s more, the water level in the second tank should be above 0.6 m.":

Wolfram Language code: req = SystemModelAlways[t, SystemModelDelay[1.2 < "tank1.h"[t], {0, 6}]0.6 < "tank2.h"[t]];

Wolfram Language code: val = SystemModelValidate[sim, req]

Show the failure plot:

Wolfram Language code: val["FailurePlot", 1]

The water level in the second tank goes below 0.6 m too early:

Wolfram Language code: SystemModelPlot[sim, {"tank2.h", 0.6}]

Start with a model of a controlled inverted pendulum system:

Wolfram Language code: model = [image];

Validate the requirement, "Whenever the angular velocity in the motor is below 700 rad/s until the position of the cart reaches 0.9 m, the angle of the pendulum must be between and 0.1 rad.":

Wolfram Language code: req = SystemModelAlways[t, SystemModelUntil["extendedSystem.dcMotor.w"[t] < 700, 0.9 ≤ "x"[t]]Abs["phi"[t]] < 0.1];

Specify uncertainty for the resistance in the motor and set a number of simulations:

Wolfram Language code:

spec = <|"ParameterValues" -> <|"extendedSystem.dcMotor.R" -> Quantity[Interval[{10, 15}], "Ohms"]|>, "SimulationCount" -> 50|>;

The model fails the requirement in all simulations:

Wolfram Language code: val = SystemModelValidate[model, req, spec]

Show the failure plot for the stored failure configuration:

Wolfram Language code: val["FailurePlot", 1]

Simulate with the failure configuration:

Wolfram Language code: sim = SystemModelSimulate[model, val["Configuration", 1]]

The angle of the pendulum fails this control specification:

Wolfram Language code: SystemModelPlot[sim, {-0.1, "phi", 0.1}, PlotRange -> All]

Systems (3)

Validate a requirement for a state variable in an AffineStateSpaceModel:

Wolfram Language code:

SystemModelValidate[AffineStateSpaceModel[{{2*Cos[Subscript[x, 2]] - 
    Cos[Subscript[x, 1]*Subscript[x, 2]], 
   -Cos[1 + Subscript[x, 2]] + Subscript[x, 1]}, {{1}, {0}}, 
  {-Subscript[x, 1]}, {{0}}}, {Subscript[x, 1], 
  Subscript[x, 2]}, {{u, 0}}, {Automatic}, Automatic, 
 SamplingPeriod -> None], SystemModelAlways[t, -Subscript[x, 1][t] < 0.5]]

Validate a SystemModelEventually requirement for the step response of an output variable in a TransferFunctionModel with a parameter that follows a normal distribution:

Wolfram Language code: spec = <|"ParameterValues" -> {a -> NormalDistribution[1, 0.1]}, "Inputs" -> {1 -> UnitStep}|>;

The requirement is for the output to have a lower bound:

Wolfram Language code: req = SystemModelEventually[t, 1.6 ≤ Subscript[, 1][t]];

This requirement generally fails:

Wolfram Language code:

SystemModelValidate[TransferFunctionModel[{{{2*(1 - a*s)}}, 
  2*(1 + s/2 + s^2)}, s], req, spec]

Validate a requirement for the output and input variables in a DiscreteInputOutputModel:

Wolfram Language code:

diom = DiscreteInputOutputModel[Association["SampledSeries" -> TemporalData[TimeSeries, 
    {{{{a + u[0]}, {(u[0] + a*u[1])/2}, {(u[0] + a*u[1] + 2*a*u[2])/3}}}, {{0, 2, 1}}, 1, 
     {"Discrete", 1}, {"Discrete", 1}, {1}, {MissingDataMethod -> None, 
   ... ime", "LastValue", "OutputCount", "OutputVariables", "Path", 
  "PathComponent", "PathComponents", "PathFunction", "PathLength", "SamplingPeriod", "StateCount", 
  "TemporalData", "TimePath", "Times", "TimeSeries", "TimeValues", "Type", "Values"}];

Specify a parameter uncertainty on a, an input sequence u and a simulation count:

Wolfram Language code:

spec = <|"ParameterValues" -> {a -> NormalDistribution[4, 0.5]}, "Inputs" -> {u -> TimeSeries[Sin[Range[-5, 5]]]}, "SimulationCount" -> 50|>;

The requirement is that the output y[t] is bounded by the input u[t]:

Wolfram Language code: req = SystemModelAlways[t, Abs[y[t]] ≤ Abs[u[t]] + 4];

This requirement generally fails:

Wolfram Language code: SystemModelValidate[diom, req, spec]

Requirements (2)

The model simulation interval is used when time domain conditions are not given in a SystemModelAlways requirement:

Wolfram Language code: model = \!$\*GraphicsBox[«8»]$;

Wolfram Language code: SystemModelValidate[model, SystemModelAlways[t, Abs["uDC"[t]] < 545]]

Specify a time domain:

Wolfram Language code: SystemModelValidate[model, SystemModelAlways[t, 0.02 ≤ t, Abs["uDC"[t]] < 545]]

The model simulation interval is used when time domain conditions are not given in an SystemModelEventually requirement:

Wolfram Language code: model = \!$\*GraphicsBox[«8»]$;

Wolfram Language code: SystemModelValidate[model, SystemModelEventually[t, Abs["uDC"[t]] > 545]]

Specify a time domain:

Wolfram Language code: SystemModelValidate[model, SystemModelEventually[t, 0.02 ≤ t, Abs["uDC"[t]] > 545]]

Specifications (3)

Select a number of simulations to perform with "SimulationCount" when parameters, initial values or inputs have uncertainty:

Wolfram Language code: req = SystemModelEventually[t, 1.6 ≤ Subscript[, 1][t]];

Specify a parameter uncertainty on a and an input function:

Wolfram Language code: spec = <|"ParameterValues" -> {a -> NormalDistribution[1, 0.1]}, "Inputs" -> {1 -> UnitStep}|>;

Validate the requirement:

Wolfram Language code:

val = SystemModelValidate[TransferFunctionModel[{{{2*(1 - a*s)}}, 
  2*(1 + s/2 + s^2)}, s], req, Append[spec, "SimulationCount" -> 50]]

Retrieve the number of simulations:

Wolfram Language code: val["SimulationCount"]

Select a simulation interval to use in validation with "SimulationInterval":

Wolfram Language code: req = SystemModelEventually[t, 1.6 ≤ Subscript[, 1][t]];

Specify a parameter uncertainty on a and an input function:

Wolfram Language code: spec = <|"ParameterValues" -> {a -> NormalDistribution[1, 0.1]}, "Inputs" -> {1 -> UnitStep}|>;

Validate the requirement:

Wolfram Language code:

val = SystemModelValidate[TransferFunctionModel[{{{2*(1 - a*s)}}, 
  2*(1 + s/2 + s^2)}, s], req, Append[spec, "SimulationInterval" -> {0, 2.5}]]

Retrieve the simulation interval:

Wolfram Language code: val["SimulationInterval"]

Select a maximum number of failure configurations for each requirement with "MaxFailureIntervals":

Wolfram Language code: req = SystemModelEventually[t, 1.6 ≤ Subscript[, 1][t]];

Specify a parameter uncertainty on a and an input function:

Wolfram Language code: spec = <|"ParameterValues" -> {a -> NormalDistribution[1, 0.1]}, "Inputs" -> {1 -> UnitStep}|>;

Validate the requirement:

Wolfram Language code:

val = SystemModelValidate[TransferFunctionModel[{{{2*(1 - a*s)}}, 
  2*(1 + s/2 + s^2)}, s], req, Append[spec, "MaxFailureIntervals" -> 2]]

Retrieve the failure intervals:

Wolfram Language code: val["FailureIntervals"]

Uncertainty in Values (5)

Validate a requirement with uncertainty generated from giving a list of values for a parameter:

Wolfram Language code: unc = <|"ParameterValues" -> {a -> Range[0, 2, 0.1]}|>;

Set an input function:

Wolfram Language code: input = <|"Inputs" -> {1 -> UnitStep}|>;

Validate the requirement:

Wolfram Language code:

SystemModelValidate[TransferFunctionModel[{{{2*(1 - a*s)}}, 
  2*(1 + s/2 + s^2)}, s], SystemModelEventually[t, 1.6 ≤ Subscript[, 1][t]], Join[unc, input]]

Validate a requirement with uncertainty generated from sampling an interval for a parameter value:

Wolfram Language code: unc = <|"ParameterValues" -> {a -> Interval[{0, 2}]}|>;

Set an input function:

Wolfram Language code: input = <|"Inputs" -> {1 -> UnitStep}|>;

Validate the requirement:

Wolfram Language code:

SystemModelValidate[TransferFunctionModel[{{{2*(1 - a*s)}}, 
  2*(1 + s/2 + s^2)}, s], SystemModelEventually[t, 1.6 ≤ Subscript[, 1][t]], Join[unc, input]]

Validate a requirement with uncertainty generated from sampling a distribution for a parameter value:

Wolfram Language code: unc = <|"ParameterValues" -> {a -> NormalDistribution[1, 1]}|>;

Set an input function:

Wolfram Language code: input = <|"Inputs" -> {1 -> UnitStep}|>;

Validate the requirement:

Wolfram Language code:

SystemModelValidate[TransferFunctionModel[{{{2*(1 - a*s)}}, 
  2*(1 + s/2 + s^2)}, s], SystemModelEventually[t, 1.6 ≤ Subscript[, 1][t]], Join[unc, input]]

Validate a requirement with uncertainty generated from sampling a geometric region for a parameter value:

Wolfram Language code: unc = <|"ParameterValues" -> {a -> MeshRegion[{{0}, {1}, {2}}, Line[{1, 2, 3}]]}|>;

Set an input function:

Wolfram Language code: input = <|"Inputs" -> {1 -> UnitStep}|>;

Validate the requirement:

Wolfram Language code:

SystemModelValidate[TransferFunctionModel[{{{2*(1 - a*s)}}, 
  2*(1 + s/2 + s^2)}, s], SystemModelEventually[t, 1.6 ≤ Subscript[, 1][t]], Join[unc, input]]

Validate a requirement with uncertainty generated from sampling a Circle for two parameter values:

Wolfram Language code: unc = <|"ParameterValues" -> {{a, b} -> Circle[{1, 1}, 0.2]}|>;

Set an input function:

Wolfram Language code: input = <|"Inputs" -> {1 -> UnitStep}|>;

Validate the requirement:

Wolfram Language code:

SystemModelValidate[TransferFunctionModel[{{{2*(1 + b - a*s)}}, 
  2*(1 + s/2 + s^2)}, s], SystemModelEventually[t, 1.6 ≤ Subscript[, 1][t]], Join[unc, input]]

Uncertainty in Inputs (3)

Validate a requirement with uncertainty generated when an ARIMAProcess is used for an input:

Wolfram Language code: unc = <|"Inputs" -> {"T" -> ARIMAProcess[{-0.8}, 1, {.01}, 10 ^ -6]}|>;

Specify a simulation interval and a number of simulations:

Wolfram Language code: sim = <|"SimulationInterval" -> {0, 10}, "SimulationCount" -> 50|>;

Validate the requirement:

Wolfram Language code: req = SystemModelAlways[t, -0.0001 < "syse.sys.rs"[t] < 0.0001];

Wolfram Language code: SystemModelValidate[[image], req , Join[unc, sim]]

Validate a requirement with uncertainty generated when using a two-dimensional process for two inputs:

Wolfram Language code: unc = <|"Inputs" -> {{"V", "TL"} -> MAProcess[{{{.2, .1}, {-.1, .2}}}, {{0.001, 0}, {0, 0.001}}]}|>;

Specify a number of simulations:

Wolfram Language code: sim = <|"SimulationCount" -> 50|>;

Validate the requirement:

Wolfram Language code: req = SystemModelAlways[t, -0.2 < "w"[t] < 0.2];

Wolfram Language code: SystemModelValidate[\!$\*GraphicsBox[«8»]$, req , Join[unc, sim]]

Validate a requirement with uncertainty generated when several functions are used as input:

Wolfram Language code: inputs = Table[With[{k = k}, Function[t, 0.1 (k Tanh[t] + 0.1 k Sin[0.15 t])]], {k, 1, 10}];

Wolfram Language code: Plot[Through[inputs[x]], {x, 0, 60}]

Use these profiles for the input flow rate in a continuous stirred tank reactor:

Wolfram Language code: unc = <|"Inputs" -> {"deltaFJ" -> inputs}|>;

Validate the requirement:

Wolfram Language code: req = SystemModelAlways[t, "deltaTR"[t] < "deltaTJ"[t] + 10];

Wolfram Language code: SystemModelValidate[[image], req, unc]

Properties (2)

Validate a requirement producing a SystemModelValidationData object:

Wolfram Language code:

model = TransferFunctionModel[{{{2*(1 - a*s)}}, 
  2*(1 + s/2 + s^2)}, s];

Specify a parameter uncertainty on a :

Wolfram Language code: unc = <|"ParameterValues" -> {a -> NormalDistribution[1, 0.1]}|>;

Set an input function and a number of simulations:

Wolfram Language code: sim = <|"Inputs" -> {1 -> UnitStep}, "SimulationCount" -> 50|>;

Validate the requirement:

Wolfram Language code: req = SystemModelAlways[t, 1.55 ≥ Subscript[, 1][t]];

Wolfram Language code: val = SystemModelValidate[model, req, Join[unc, sim]]

Retrieve the success probability:

Wolfram Language code: val["SuccessProbability"]

Retrieve the stored failure configurations:

Wolfram Language code: val["Configuration"]

Retrieve the failure plot for the stored failure configuration:

Wolfram Language code: val["FailurePlot", 1]

Display a plot of the time intervals where the requirement failed for the stored failure configuration:

Wolfram Language code: val["FailureIntervalsPlot", 1]

Validate a requirement producing a SystemModelValidationData object:

Wolfram Language code:

model = TransferFunctionModel[{{{2*(1 - a*s)}}, 
  2*(1 + s/2 + s^2)}, s];

Specify a parameter uncertainty on a:

Wolfram Language code: unc = <|"ParameterValues" -> {a -> NormalDistribution[1, 0.1]}|>;

Set an input function and a number of simulations:

Wolfram Language code: sim = <|"Inputs" -> {1 -> UnitStep}, "SimulationCount" -> 50|>;

Retrieve the success probability:

Wolfram Language code: req = SystemModelAlways[t, 1.55 ≥ Subscript[, 1][t]];

Wolfram Language code: SystemModelValidate[model, req, Join[unc, sim], "SuccessProbability"]

Retrieve the stored failure configurations:

Wolfram Language code: SystemModelValidate[model, req, Join[unc, sim], "Configuration"]

Display time intervals where the requirement failed:

Wolfram Language code: SystemModelValidate[model, req, Join[unc, sim], "FailureIntervals"]

Retrieve the first time where the requirement failed:

Wolfram Language code: SystemModelValidate[model, req, Join[unc, sim], "FirstFailureTime"]

Options (3)

Method (1)

Set a custom simulation method with Method:

Wolfram Language code: req = SystemModelAlways[t, "R2.p.v"[t] ≤ 0.587];

Wolfram Language code: SystemModelValidate[[image], req, Method -> {Automatic, "InterpolationPoints" -> 100}]

ProgressReporting (1)

Control progress reporting with ProgressReporting:

Wolfram Language code: req = SystemModelAlways[t, "R2.p.v"[t] ≤ 0.587];

Wolfram Language code: SystemModelValidate[[image], req, ProgressReporting -> False]

SamplingPeriod (1)

Validate a requirement with uncertainty generated when an ARIMAProcess is used for an input:

Wolfram Language code: unc = <|"Inputs" -> {"T" -> ARIMAProcess[{-.01}, 1, {.01}, 10 ^ -6]}|>;

Specify a simulation interval and a number of simulations:

Wolfram Language code: sim = <|"SimulationInterval" -> {0, 10}, "SimulationCount" -> 50|>;

Set a custom sampling period when sampling the random process when validating:

Wolfram Language code: req = SystemModelAlways[t, -0.2 < "syse.sys.rs"[t] < 0.2];

Wolfram Language code: SystemModelValidate[[image], req , Join[unc, sim], SamplingPeriod -> 5]

Applications (4)

Measurement Validation (1)

Start with a model of a camera attached to the top of a moving vehicle:

Wolfram Language code: model = \!$\*GraphicsBox[«8»]$;

Simulate the model with a vertical force perturbation:

Wolfram Language code:

bumpInputs = <|"Inputs" -> {"fa" -> Function[t, 0], "fw" -> Function[t, 2000 UnitStep[t]]}|>;
simModel = SystemModelSimulate[model, 20, bumpInputs]

Plot the position of the camera:

Wolfram Language code: SystemModelPlot[simModel, "xce", PlotRange -> All]

Compute the settling time for the position of the camera with a 25% settling threshold:

Wolfram Language code: settlingT = SystemModelMeasurements[<|"Model" -> simModel, "Outputs" -> "xce"|>, "SettlingTime"]

Compute the initial and final values for the position of the camera:

Wolfram Language code:

{start, stop} = simModel["SimulationInterval"];
{xInit, xFinal} = simModel["xce", {start, stop}];

Use validation to verify the measurement of the settling time using its definition:

Wolfram Language code: req = SystemModelAlways[t, settlingT ≤ t, Abs["xce"[t] - xFinal] / Abs[xFinal - xInit] ≤ 0.02];

Wolfram Language code: SystemModelValidate[simModel, req]

Earlier times do not satisfy the condition:

Wolfram Language code: reqEarly = SystemModelAlways[t, settlingT - 0.01 ≤ t, Abs["xce"[t] - xFinal] / Abs[xFinal - xInit] ≤ 0.02];

Wolfram Language code: SystemModelValidate[simModel, reqEarly]

Electrical Vehicle (1)

Start with a simple model of an electrical vehicle following the US EPA Highway Fuel Economy Driving Schedule (HWFET):

Wolfram Language code: model = \!$\*GraphicsBox[«8»]$;

Validate the requirement, "The temperature in the battery can only be above 28 ºC for an interval of at most 8.5 minutes.":

Wolfram Language code: req = SystemModelAlways[t, !SystemModelSustain["T"[t] > 28 + 273.15, {Quantity[8.5, "Minutes"], Infinity}]];

Wolfram Language code: valT = SystemModelValidate[model, req]

Show the failure plot:

Wolfram Language code: valT["FailurePlot", 1]

Plot the temperature with the bound:

Wolfram Language code:

SystemModelPlot[model, {"T", 28 + 273.15}, GridLines -> {MinMax[valT["FailureIntervals", 1]] / 3600, None}, GridLinesStyle -> Directive[Thick, LightDarkSwitched[Darker[Red]], Dashed]]

The requirement fails only in one occasion. To see this, validate the requirement, "The temperature in the battery can reach at most 28 ºC.":

Wolfram Language code: valT2 = SystemModelValidate[model, SystemModelAlways[t, "T"[t] ≤ 28 + 273.15]]

Compute the failure interval lengths to see that only one interval is longer than 8.5 minutes:

Wolfram Language code: ArcLength /@ valT2["FailureIntervals", All] / 60

System Tolerance (1)

The performance of a circuit depends heavily on its components and parameter tolerances. When the resistance of one of the components in this model of a speaker follows a truncated normal distribution, the variation in the current going through the speaker can be measurable:

Wolfram Language code: model = [image];

Set the resistance uncertainty:

Wolfram Language code: unc = <|"ParameterValues" -> {"r1.R" -> TruncatedDistribution[{0, ∞}, NormalDistribution[6, 5]]}|>;

Set the simulation interval and the number of simulations:

Wolfram Language code: sim = <|"SimulationInterval" -> Quantity[40., "Milliseconds"], "SimulationCount" -> 50|>;

Plot the uncertainty in the speaker current:

Wolfram Language code: SystemModelUncertaintyPlot[model, Join[<|"Outputs" -> "speaker.l.i"|>, unc, sim]]

Use the uncertainty to sample and validate a requirement for a bound for the distance between the simulation results and reference data:

Wolfram Language code: inFun = Interpolation[{...}];

Wolfram Language code: req = SystemModelAlways[t, Abs["speaker.l.i"[t] - inFun[t]] ≤ 0.001];

Wolfram Language code: val = SystemModelValidate[model, req, Join[unc, sim]]

Extract a failure configuration, simulate the model and fetch the simulation result:

Wolfram Language code: simConf = SystemModelSimulate[model, Quantity[40., "Milliseconds"], val["Configuration", 1]]

Wolfram Language code: i[t] = simConf["speaker.l.i", t]

Plot the distance between the result for the failure configuration and the reference data:

Wolfram Language code: Plot[Evaluate[{Abs[i[t] - inFun[t]], 0.001}], {t, 0, 0.04}, PlotRange -> All]

Plot the failure intervals:

Wolfram Language code: val["FailureIntervalsPlot", 1]

Orbit Stability (1)

Validate the stability of a toy spacecraft in a circular orbit against force disturbances:

Wolfram Language code: model = [image];

Bounds for the radial coordinate should be respected when a radial force that follows a WienerProcess acts on it:

Wolfram Language code: unc = <|"Inputs" -> {"fr" -> WienerProcess[0, 10^-3]}|>;

Set a number of simulations:

Wolfram Language code: sim = <|"SimulationCount" -> 50|>;

Set a number of stored failure configurations:

Wolfram Language code: rep = <|"MaxFailureIntervals" -> 3|>;

Validate the requirement:

Wolfram Language code: req = SystemModelAlways[t, 0.37 < r[t] < 0.39];

Wolfram Language code: val = SystemModelValidate[model, req, Join[unc, sim, rep], SamplingPeriod -> 100]

Extract the failure configurations and plot them together with the bounds:

Wolfram Language code: failures = val["Configuration"];

Wolfram Language code: SystemModelPlot[model, r, #, ...]& /@ failures//Quiet

Resample and plot the uncertainty for the radial coordinate:

Wolfram Language code: SystemModelUncertaintyPlot[model, Join[<|"Outputs" -> "r"|>, unc, sim], ...]

Top

More Learning

Tech Support

Wolfram Solutions

Wolfram Solutions For Education

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

SystemModelValidate

Details and Options

Examples

Basic Examples (3)

Scope (21)

Basic Uses (3)

Systems (3)

Requirements (2)

Specifications (3)

Uncertainty in Values (5)

Uncertainty in Inputs (3)

Properties (2)

Options (3)

Method (1)

ProgressReporting (1)

SamplingPeriod (1)

Applications (4)

Measurement Validation (1)

Electrical Vehicle (1)

System Tolerance (1)

Orbit Stability (1)

Text

CMS

APA

BibTeX

BibLaTeX

	SystemModelAlways[t,texpr]	texpr is always true for
	SystemModelEventually[t,texpr]	texpr is eventually true for

SystemModelValidate

Details and Options

Examples

Basic Examples (3)

Scope (21)

Basic Uses (3)

Systems (3)

Requirements (2)

Specifications (3)

Uncertainty in Values (5)

Uncertainty in Inputs (3)

Properties (2)

Options (3)

Method (1)

ProgressReporting (1)

SamplingPeriod (1)

Applications (4)

Measurement Validation (1)

Electrical Vehicle (1)

System Tolerance (1)

Orbit Stability (1)

See Also

Tech Notes

Related Guides

Related Links

History

Text

CMS

APA

BibTeX

BibLaTeX