WOLFRAM

Enable JavaScript to interact with content and submit forms on Wolfram websites. Learn how
Wolfram Language & System Documentation Center

SystemModelUncertaintyPlot [sys,spec]

plots the uncertainty in outputs in the system model sys from uncertainty in inputs according to spec.

Details and Options
Details and Options Details and Options
Examples  
Basic Examples  
Scope  
Models  
Specification  
Uncertainty in Values  
Uncertainty in Inputs  
Slice Function  
Data Wrappers  
Options  
AxesLabel  
Filling  
FrameLabel  
Show More Show More
Method  
PlotLabel  
PlotLayout  
PlotLegends  
ProgressReporting  
SamplingPeriod  
ScalingFunctions  
TargetUnits  
Applications  
Trajectories Near Equilibrium  
System Tolerance  
Validation of Controlled Systems  
Orbital Maneuver  
Overshoot in Heating System  
Control Design in Robotics  
Properties & Relations  
Neat Examples  
See Also
Tech Notes
Related Guides
Related Links
History
Cite this Page

SystemModelUncertaintyPlot [sys,spec]

plots the uncertainty in outputs in the system model sys from uncertainty in inputs according to spec.

Details and Options

Examples

open all close all

Basic Examples  (1)

Plot the uncertainty in the voltage of a capacitor in an RC circuit when the resistance takes values in a given interval:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"ParameterValues" -> {"R" -> Quantity[Interval[{2, 7}], "Milliohms"]}|>]

Scope  (24)

Models  (4)

Plot uncertainty in two variables of a SystemModel :

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x", "y"}, "ParameterValues" -> {"theta" -> Interval[{0, π}]}|>, PlotRange -> All]

Plot the uncertainty in the output of an AffineStateSpaceModel :

Wolfram Language code: SystemModelUncertaintyPlot[AffineStateSpaceModel[{{Cos[x2], -1/10*x2 - Cos[x1^2]}, {{0}, {1}}, {x2}, {{0}}}, {x1, x2}, Automatic, {Automatic}, Automatic, SamplingPeriod -> None], <|"InitialValues" -> {x1 -> Interval[{1, 2}]}, "SimulationInterval" -> 3|>]

Plot the uncertainty in the output of a NonlinearStateSpaceModel :

Wolfram Language code: SystemModelUncertaintyPlot[NonlinearStateSpaceModel[{{Cos[x] + 4*a*Sin[x/2]}, {x + Sin[x]}}, {x}, {}, {Automatic}, Automatic, SamplingPeriod -> None], <|"ParameterValues" -> {a -> Interval[{1, 10}]}|>]

Plot the uncertainty in the output of a DiscreteInputOutputModel :

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

Use a SquareWave input:

Wolfram Language code: SystemModelUncertaintyPlot[diom, <|"ParameterValues" -> {a -> Interval[{0.1, 1}]}, "Inputs" -> {1 -> SquareWave}|>, PlotRange -> All]

Specification  (4)

Plot the uncertainty for a specific output:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x"}, "ParameterValues" -> {"theta" -> Interval[{0, π}]}|>, PlotRange -> All]

Plot the uncertainty in a model using a custom number of simulations:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"SimulationCount" -> 5, "Outputs" -> {"x", "y"}, "ParameterValues" -> {"theta" -> Interval[{0, π}]}|>, PlotRange -> All]

Plot the uncertainty for a specific output using a custom simulation interval:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x"}, "SimulationInterval" -> {0, 3}, "ParameterValues" -> {"theta" -> Interval[{0, π}]}|>, PlotRange -> All]

Models with "Epoch" in their simulation settings are plotted as values at a sequence of dates:

Wolfram Language code: model = SystemModel[[image], <|"ModelName" -> "MyModel", "SimulationSettings" -> {"Epoch" -> Now, "StopTime" -> Quantity[3, "Hours"]}|>]

Plot the model:

Wolfram Language code: SystemModelUncertaintyPlot[model, <|"Outputs" -> {"room.temperature.T"}, "ParameterValues" -> {"room.roomInertia.C" -> Range[70000, 90000, 5000]}|>]

Uncertainty in Values  (5)

Plot the uncertainty generated from giving a list of values for a parameter:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x"}, "ParameterValues" -> {"theta" -> Range[0, 1 / 2, 1 / 200]}|>, PlotRange -> All]

Plot the uncertainty generated from sampling an interval for a parameter value:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x"}, "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}|>, PlotRange -> All]

Plot the uncertainty generated from sampling a distribution for a parameter value:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x"}, "ParameterValues" -> {"theta" -> NormalDistribution[2, 0.1]}|>, PlotRange -> All]

Plot the uncertainty generated from sampling a geometric region for a parameter value:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x"}, "ParameterValues" -> {"theta" -> MeshRegion[{{0}, {1}, {2}}, Line[{1, 2, 3}]]}|>, PlotRange -> All]

Plot the uncertainty generated from sampling a Circle for two initial values:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x", "y"}, "InitialValues" -> {{"x", "y"} -> Circle[]}|>, PlotRange -> All]

Uncertainty in Inputs  (3)

Plot the uncertainty generated when an ARIMAProcess is used for an input:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"SimulationInterval" -> {0, 10}, "Outputs" -> {"syse.sys.rs"}, "Inputs" -> {"T" -> ARIMAProcess[{-.01}, 1, {.01}, 10^-6]}|>, PlotRange -> All, TargetUnits -> "Millimeters"]

Plot the 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.1k Sin[0.15t])]], {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: SystemModelUncertaintyPlot[[image], <|"Inputs" -> {"deltaFJ" -> inputs}|>, PlotRange -> All]

Plot the uncertainty generated when using a two-dimensional process for two inputs:

Wolfram Language code: SystemModelUncertaintyPlot[\!\(\*GraphicsBox[«8»]\), <|"Outputs" -> {"w"}, "Inputs" -> {{"V", "TL"} -> MAProcess[{{{.2, .1}, {-.1, .2}}}, {{0.001, 0}, {0, 0.001}}]}|>, PlotRange -> All]

Slice Function  (4)

Plot the range between the minimum and maximum of the temporal data:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x"}, "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}, "SliceFunction" -> "MinMax"|>, PlotRange -> All]

Plot custom quantiles of the temporal data:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x"}, "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}, "SliceFunction" -> {"Quantiles", {0, 0.45, 0.5, 0.55, 1}}|>, PlotRange -> All]

Plot confidence bands for the temporal data with custom confidence levels:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x"}, "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}, "SliceFunction" -> {"Confidence", {0.95, 0.98, 0.99}}|>, PlotRange -> All]

Plot a custom slice function:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x"}, "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}, "SliceFunction" -> {Mean[#] - StandardDeviation[#]&, Mean, Mean[#] + StandardDeviation[#]&}|>, PlotRange -> All, PlotLegends -> {μ - σ, μ, μ + σ}]

Data Wrappers  (4)

Use wrappers on a single variable:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> Style["x", StandardRed], "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}|>]

Use wrappers for several variables in a "Shared" PlotLayout :

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {Style["vx", StandardRed], Style["y", StandardOrange]}, "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}|>, PlotLayout -> "Shared"]

Wrappers can be nested:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> Labeled[Style["x", StandardRed], "position", Below], "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}|>]

Use wrappers for several variables in a "Shared" PlotLayout :

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {Callout[Style["vx", StandardRed], "velocity", Above], Callout[Style["y", StandardOrange], "position", Below]}, "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}|>, PlotLayout -> "Shared"]

Add a Tooltip :

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> Tooltip["x", "position"], "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}|>]

Customize the plot legend for a single variable:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> Legended["x", "position"], "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}|>]

Customize the plot legend for several variables in a "Shared" PlotLayout :

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {Legended["vx", "velocity"], Legended["y", "position"]}, "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}|>, PlotLayout -> "Shared"]

Options  (17)

AxesLabel  (2)

AxesLabel is set to None by default in the default PlotLayout :

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x"}, "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}|>, PlotRange -> All, Frame -> False, Axes -> True]

Set custom labels:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x"}, "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}|>, PlotRange -> All, AxesLabel -> {"time", "position"}, Frame -> False, Axes -> True]

Filling  (2)

Known slice functions use a customized Filling by default:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x"}, "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}|>, PlotRange -> All]

Set a custom filling:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x"}, "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}|>, PlotRange -> All, Filling -> {1 -> {5}}]

FrameLabel  (2)

The units of the plotted variables are used as the FrameLabel by default:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x"}, "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}|>, PlotRange -> All]

Set custom labels:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x"}, "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}|>, FrameLabel -> {"time", "position"}, PlotRange -> All]

Method  (1)

Set a custom simulation method with Method :

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x"}, "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}|>, Method -> <|"SimulationMethod" -> {"InterpolationPoints" -> 10}|>, PlotRange -> All]

PlotLabel  (1)

Set a custom plot label:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x", "y"}, "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}|>, PlotRange -> All, PlotLabel -> {"Position: x", "Position: y"}]

PlotLayout  (2)

Obtain an Association with individual plots for each output:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x", "vy"}, "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}|>, PlotRange -> All, PlotLayout -> "Association"]

Merge individual plots:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x", "vy"}, "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}|>, PlotRange -> All, PlotLayout -> "Shared"]

PlotLegends  (2)

Known slice functions use customized PlotLegends by default:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x"}, "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}, "SliceFunction" -> {"Quantiles", {0, 0.45, 0.5, 0.55, 1}}|>, PlotRange -> All]

Set a custom plot legend:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x"}, "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}, "SliceFunction" -> {"Quantiles", {0, 0.45, 0.5, 0.55, 1}}|>, PlotLegends -> {None, None, "Median", None, None}]

ProgressReporting  (1)

Control progress reporting with ProgressReporting :

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x"}, "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}|>, PlotRange -> All, ProgressReporting -> False]

SamplingPeriod  (1)

Set a custom sampling period when sampling a random process:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"SimulationInterval" -> {0, 10}, "Outputs" -> {"syse.sys.rs"}, "Inputs" -> {"T" -> ARIMAProcess[{-.01}, 1, {.01}, 10^-6]}|>, PlotRange -> All, TargetUnits -> "mm", SamplingPeriod -> 5]

ScalingFunctions  (2)

Plot the model with log-scaled values using ScalingFunctions :

Wolfram Language code: SystemModelUncertaintyPlot[AffineStateSpaceModel[{{x1, 2*x1}, {{}}}, {{x1, 1}, {x2, 1}}], <|"Outputs" -> {x1, x2}, "InitialValues" -> {x1 -> {1, 10, 100, 1000}}|>, ScalingFunctions -> "Log"]

Models with "Epoch" in its simulation settings are plotted as values at a sequence of dates:

Wolfram Language code: model = SystemModel[[image], <|"ModelName" -> "MyModel", "SimulationSettings" -> {"Epoch" -> Now}|>]

Plot the model:

Wolfram Language code: SystemModelUncertaintyPlot[model, <|"Outputs" -> {"H"}, "ParameterValues" -> {"k" -> Range[100, 130, 5]}|>]

Use ScalingFunctions {None ,Automatic } to produce simulation time plots instead:

Wolfram Language code: SystemModelUncertaintyPlot[model, <|"Outputs" -> {"H"}, "ParameterValues" -> {"k" -> Range[100, 130, 5]}|>, ScalingFunctions -> {None, Automatic}, TargetUnits -> {"Years", Automatic}]

Use DateTicksFormat to format for date tick labels:

Wolfram Language code: SystemModelUncertaintyPlot[model, <|"Outputs" -> {"H"}, "ParameterValues" -> {"k" -> Range[100, 130, 5]}|>, ScalingFunctions -> {DateScale[DateTicksFormat -> "YearShort"], Automatic}]

TargetUnits  (1)

Set custom units with TargetUnits :

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> {"x"}, "ParameterValues" -> {"theta" -> Interval[{0, 2π}]}|>, PlotRange -> All, TargetUnits -> {"Seconds", "Decimeters"}]

Applications  (6)

Trajectories Near Equilibrium  (1)

Plot the uncertainty in the angle and angular velocity of a simple damped pendulum when the initial conditions take values near equilibrium points:

Wolfram Language code: model = CreateSystemModel["DampedPendulum", {ω'[t] == -g Sin[θ[t]] / l - b ω[t], θ'[t] == ω[t]}, t, {θ∈"Units.SI.Angle"}, <|"ParameterValues" -> {g -> 10, l -> 1 / 2, b -> 2}|>]

When the system starts at rest at small angles, it evolves toward the stable ground position:

Wolfram Language code: SystemModelUncertaintyPlot[model, <|"SimulationInterval" -> 5, "Outputs" -> θ, "InitialValues" -> {θ -> CenteredInterval[0, π / 4]}|>, ...]

When the system starts near the unstable fully inverted position, it also evolves toward the ground position:

Wolfram Language code: SystemModelUncertaintyPlot[model, <|"SimulationInterval" -> 5, "Outputs" -> θ, "InitialValues" -> {θ -> Interval[{3π / 4, π - π / 100}]}|>, ...]

Plot a few randomly chosen trajectories:

Wolfram Language code: SystemModelUncertaintyPlot[model, <|"SimulationInterval" -> 5, "Outputs" -> θ, "InitialValues" -> {θ -> Interval[{3π / 4, π - π / 100}]}, "SliceFunction" -> Table[With[{k = k}, Part[#, k]&], {k, RandomSample[Range[200], 20]}]|>, ...]

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: SystemModelUncertaintyPlot[[image], <|"Outputs" -> "speaker.l.i", "SimulationInterval" -> Quantity[40, "Milliseconds"], "ParameterValues" -> {"r1.R" -> TruncatedDistribution[{0, ∞}, NormalDistribution[6, 5]]}|>]

External disturbances can also affect the performance of a circuit. For instance, the input voltage of the speaker can be affected by high-frequency signals:

Wolfram Language code: inputs = Table[With[{k = k}, Function[{t}, 2.5Sin[2 π t 50] + k Sin[2 π t 2000]]], {k, 0, 0.6, 0.05}];
Wolfram Language code: Plot[Through[inputs[t]], {t, 0, 0.01}]

Plot the uncertainty in the current of the speaker when affected by these high-frequency disturbances:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> "speaker.l.i", "SimulationInterval" -> Quantity[10, "Milliseconds"], "Inputs" -> {"vi" -> inputs}|>, TargetUnits -> {"Milliseconds", "Milliamperes"}]

Validation of Controlled Systems  (1)

Validate a controlled ball and beam system by placing the ball away from the stable position:

The system model:

Wolfram Language code: model = [image];

The farther away the ball starts from the equilibrium point, the more the system will struggle bringing it back to the stable position:

Wolfram Language code: spec = <|"SimulationInterval" -> {0, 1.2}, "InitialValues" -> {"syse.sys.ballAndBeamDynamics.rs" -> Interval[{0, 0.15}]}|>;
Wolfram Language code: SystemModelUncertaintyPlot[model, Append[spec, "Outputs" -> {"syse.sys.ballAndBeamDynamics.rs"}], PlotRange -> All, PlotLabel -> "r"]

The control effort peaks at the start and then later a few more times to stop the ball from overshooting the stable position:

Wolfram Language code: SystemModelUncertaintyPlot[model, Append[spec, "Outputs" -> {"syse.sys.T"}], PlotRange -> All, PlotLabel -> "Control effort"]

Controlled systems should also be validated against external disturbances. Stress the controlled ball and beam system with a white noise torque disturbance and plot the control effort as the system experiences various sampling periods of the noise:

Wolfram Language code: SystemModelUncertaintyPlot[model, <|"SimulationInterval" -> {0, 1.2}, "Outputs" -> {"syse.sys.T"}, "Inputs" -> {"T" -> WhiteNoiseProcess[0.1]}|>, SamplingPeriod -> 0.3, PlotRange -> All, PlotLabel -> "Control effort"]

Orbital Maneuver  (1)

Study the effect of a short-time tangential boost on a toy spacecraft in a circular orbit:

Wolfram Language code: model = ConnectSystemModelComponents["BoostModel", {"orbit"∈"Control.CircularOrbit", "zero"∈"Blocks.Sources.Constant", "boost"∈"Blocks.Sources.Pulse"}, {"orbit.fr""zero.y", "orbit.fphi""boost.y"}, IconizedObject[«model settings»]]

Boosts of large magnitude can lead to unbounded trajectories:

Wolfram Language code: sim = SystemModelSimulate[model, {"orbit.x", "orbit.y"}, Quantity[8, "Hours"], <|"ParameterValues" -> {"boost.amplitude" -> {0, 600, 700, 800, 900, 1000}}|>];
Wolfram Language code: SystemModelPlot[sim, PlotLegends -> None, Axes -> False, Frame -> True]

Bounded or unbounded trajectories can unfold if the magnitude of the boost follows a normal distribution. Plot the uncertainty in the distance to the center of force:

Wolfram Language code: SystemModelUncertaintyPlot[model, <|"Outputs" -> {"orbit.r"}, "ParameterValues" -> {"boost.amplitude" -> NormalDistribution[600, 100]}|>]

Overshoot in Heating System  (1)

Start with a model of a heating system where heat flow switches directions in the middle of the simulation:

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

Select the temperature in a pipe as output and specify the simulation interval:

Wolfram Language code: pipe9T = <|"Outputs" -> "pipe9.mediums[1].T", "SimulationInterval" -> 100|>;

Choose the diameter of a pipe as parameter and an interval as sampling region:

Wolfram Language code: uncertainty = <|"ParameterValues" -> {"pipe8.diameter" -> Interval[{0.012, 0.055}]}|>;

Plot uncertainty in the temperature of a pipe with respect to the diameter of a pipe and see the effect in the overshoot:

Wolfram Language code: SystemModelUncertaintyPlot[model, Join[pipe9T, uncertainty], PlotRange -> {Automatic, {18, 50}}, PlotLabel -> "Temperature overshoot"]

Select the temperature in two pipes as outputs:

Wolfram Language code: pipes89T = <|"Outputs" -> {"pipe9.mediums[1].T", "pipe8.mediums[1].T"}, "SimulationInterval" -> 100|>;

Plot uncertainty in the temperatures:

Wolfram Language code: SystemModelUncertaintyPlot[model, Join[pipes89T, uncertainty], PlotRange -> All, PlotLayout -> "Shared", PlotLabel -> "Temperature overshoots"]

Control Design in Robotics  (1)

Start with a model of a robot performing a time-constrained motion carrying a load of 300 kg with a target rotation angle of 60°:

Wolfram Language code: model = SystemModel[\!\(\*GraphicsBox[«8»]\), <|"ParameterValues" -> {"mLoad" -> 300}, "ModelName" -> "IndustrialRobot"|>];

Select the rotation angle as output and specify the simulation interval:

Wolfram Language code: angle = <|"Outputs" -> "mechanics.r1.angle", "SimulationInterval" -> 1.856, "InterpolationPoints" -> 500|>;

Choose the gain in a controller as the parameter and an interval as sampling region:

Wolfram Language code: uncertainty = <|"ParameterValues" -> {"kp1" -> Interval[{1, 30}]}|>;

Plot uncertainty in the rotation angle with respect to the controller gain and see the effect in the target angle at the end of the simulation:

Wolfram Language code: SystemModelUncertaintyPlot[model, Join[angle, uncertainty], PlotRange -> {{1.2, 1.85}, {50, 65}}, PlotLabel -> "Rotation angle", GridLines -> {{}, {60}}]

Properties & Relations  (2)

Use SystemModelPlot to plot individual curves:

Wolfram Language code: model = \!\(\*GraphicsBox[«8»]\);
Wolfram Language code: SystemModelPlot[model, {"Inertia2.w"}, <|"ParameterValues" -> {"Inertia2.J" -> 2}|>]

Use SystemModelPlot to plot individual curves when doing a parameter sweep:

Wolfram Language code: SystemModelPlot[model, {"Inertia2.w"}, <|"ParameterValues" -> {"Inertia2.J" -> {1, 2, 3}}|>]

Use SystemModelPlot to plot sensitivity bands computed with SystemModelSimulateSensitivity :

Wolfram Language code: sim = SystemModelSimulateSensitivity[model, 10, {"Inertia2.J"}, <|"ParameterValues" -> {"Inertia2.J" -> 2}|>]
Wolfram Language code: SystemModelPlot[sim, {{"Inertia2.w", "Inertia2.J", 0.5}}]

Use SystemModelUncertaintyPlot to plot uncertainty:

Wolfram Language code: SystemModelUncertaintyPlot[model, <|"Outputs" -> "Inertia2.w", "ParameterValues" -> {"Inertia2.J" -> CenteredInterval[{{1, 1, 536870912, -29}, 63}]}|>]

Interval and CenteredInterval are sampled as regions:

Wolfram Language code: model = \!\(\*GraphicsBox[«8»]\);
Wolfram Language code: SystemModelUncertaintyPlot[model, <|"Outputs" -> "Inertia2.w", "ParameterValues" -> {"Inertia2.J" -> CenteredInterval[{{1, 1, 858993460, -33}, 66}]}|>]

Around and VectorAround are sampled as their corresponding distributions:

Wolfram Language code: SystemModelUncertaintyPlot[model, <|"Outputs" -> "Inertia2.w", "ParameterValues" -> {"Inertia2.J" -> Around[2., 0.1]}|>]

Neat Examples  (1)

Visualize the sensitivity of a chaotic system with respect to small changes in initial conditions:

Wolfram Language code: SystemModelUncertaintyPlot[[image], <|"Outputs" -> "x", "InitialValues" -> {"x" -> CenteredInterval[{{0, 0, 549755814, -39}, 72}]}|>]
Wolfram Research (2024), SystemModelUncertaintyPlot, Wolfram Language function, https://reference.wolfram.com/language/ref/SystemModelUncertaintyPlot.html.

Text

Wolfram Research (2024), SystemModelUncertaintyPlot, Wolfram Language function, https://reference.wolfram.com/language/ref/SystemModelUncertaintyPlot.html.

CMS

Wolfram Language. 2024. "SystemModelUncertaintyPlot." Wolfram Language & System Documentation Center. Wolfram Research. https://reference.wolfram.com/language/ref/SystemModelUncertaintyPlot.html.

APA

Wolfram Language. (2024). SystemModelUncertaintyPlot. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/SystemModelUncertaintyPlot.html

BibTeX

@misc{reference.wolfram_2026_systemmodeluncertaintyplot, author="Wolfram Research", title="{SystemModelUncertaintyPlot}", year="2024", howpublished="\url{https://reference.wolfram.com/language/ref/SystemModelUncertaintyPlot.html}", note=[Accessed: 17-August-2026]}

BibLaTeX

@online{reference.wolfram_2026_systemmodeluncertaintyplot, organization={Wolfram Research}, title={SystemModelUncertaintyPlot}, year={2024}, url={https://reference.wolfram.com/language/ref/SystemModelUncertaintyPlot.html}, note=[Accessed: 17-August-2026]}
Top [フレーム]

AltStyle によって変換されたページ (->オリジナル) /