Wolfram Language & System Documentation Center

SystemModelCalibrate

SystemModelCalibrate[data,smodel,pars]

calibrates the parameters pars in the system model smodel according to data.

SystemModelCalibrate[data,{smodel,cons},pars]

calibrates the parameters pars subject to the constraints cons.

SystemModelCalibrate[…,spec]

calibrates following the specification spec.

SystemModelCalibrate[…,"prop"]

gives the value of the property "prop".

SystemModelCalibrate

SystemModelCalibrate[data,smodel,pars]

calibrates the parameters pars in the system model smodel according to data.

SystemModelCalibrate[data,{smodel,cons},pars]

calibrates the parameters pars subject to the constraints cons.

SystemModelCalibrate[…,spec]

calibrates following the specification spec.

SystemModelCalibrate[…,"prop"]

gives the value of the property "prop".

Details and Options

SystemModelCalibrate is used to calibrate parameter values in a system model to match simulation results with real-world data.

Given measured data from the real-world system, the goal is to calibrate parameters pars in the smodel to produce simulated data that is as close as possible to the measured data.
The calibrated parameters are , where are non-negative weights and ℓ is a loss function with typical form , which is approximated by the sampled data as .
Several quality measures of how well data and calibrated model agree can be computed as properties.

The system model smodel 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

data is an association of the form <|x₁data₁,…|>, where x_i is a variable in smodel and data_i is its corresponding data.
pars is a list of tunable parameters in smodel. It can have the following forms:
{θ₁,…} calibration parameters starting from values in smodel

{{θ₁,},…} calibration parameter θ_i starting from point
spec is an Association that allows the following keys:

"SimulationInterval"	{t_min,t_max}	simulate from time t_min to t_max
"ParameterValues"	{p₁val₁,…}	parameter p_i has value val_i
"InitialValues"	{x₁val₁,…}	variable x_i has initial value val_i
"Inputs"	{in₁fun₁,…}	input in_i has value fun_i[t] at time t
"CalibratedModelName"	name	name for calibrated SystemModel
"ExtendModel"	False	whether the calibrated SystemModel extends smodel
"Weights"	{w₁,…}	positive multi-objective sum weights w_i for each calibration variable in data

The "CalibratedModelName" name can have the following forms:
Automatic automatically generate a model name (default)

"name" name calibrated model "name"

None set calibrated values in place in smodel
By default, SystemModelCalibrate[data,smodel,pars,spec] returns a model with parameters set to the calibrated values.

Properties

SystemModelCalibrate[…,"CalibratedSystemModel"] returns a CalibratedSystemModel object csmodel that can be used to extract additional properties using the form csmodel["prop"].
SystemModelCalibrate[…,"prop"] can be used to directly get the value of csmodel["prop"].
Typical properties that can be retrieved with SystemModelCalibrate[…,"prop"] include:

	"CalibratedModel"	new model with calibrated parameters
	"CalibratedParameters"	parameter estimates
	"ParameterConfidence"	parameter confidence information
	"MeanPredictionBandsPlot"	mean predictions confidence bands plot with calibration data
	"SinglePredictionBandsPlot"	plot of confidence bands based on single observations with calibration data

Properties related to data and the calibrated model include:

	"CalibratedSimulationData"	calibrated model simulation results
	"CalibrationData"	calibration data in data
	"ValidationData"	validation set data
	"CalibratedModelName"	model name of new model with calibrated parameters
	"CalibrationDataResponse"	response values in the calibration data
	"ValidationDataResponse"	response values in the validation data
	"CalibratedDataResponse"	calibrated model values for the calibration data
	"CalibratedValidationDataResponse"	calibrated model values for the validation data

Types of residuals include:

	"CalibrationDataResiduals"	difference between actual and predicted responses
	"ValidationDataResiduals"	difference between validation and predicted responses
	"StandardizedResiduals"	residuals for calibration data divided by the standard error for each residual

Properties of predicted values include:

	"CorrelationMatrix"	asymptotic parameter correlation matrix
	"MeanPredictionBands"	confidence bands for mean predictions
	"MeanPredictionConfidence"	confidence information for the mean predictions of calibration data
	"SinglePredictionBands"	confidence bands based on single observations
	"SinglePredictionConfidence"	confidence information for the predicted response of single observations of calibration data

Properties that measure goodness of calibration include:

	"MSE"	mean squared error for each calibration variable, i.e.
	"RMSE"	root mean squared error for each calibration variable, i.e.
	"RRMSE"	relative root mean squared error for each calibration variable, i.e.

Properties that store calibration details include:

	"CalibrationParameterConstraints"	calibration parameter constraints cons
	"CalibrationVariables"	calibration variables in data
	"InitialCalibrationParameters"	calibration parameters pars and their calibration start values
	"InputModel"	model smodel
	"InputModelName"	model name of SystemModel smodel
	"SimulationInterval"	simulation interval used in calibration

Options

The following options can be given:

ConfidenceLevel	95/100	confidence level for parameters and predictions
FitRegularization	None	regularization for pars
Method	Automatic	what simulation and calibration methods to use
NormFunction	Norm	the norm to minimize
ProgressReporting	$ProgressReporting	control display of progress
ValidationSet	None	validation data
VarianceEstimatorFunction	Automatic	function for estimating the error variance

With ConfidenceLevel->p, probability-p confidence intervals are computed for parameter and prediction intervals.
FitRegularization and NormFunction can be used to change the calibration target into , where is a regularization function, e.g. $g(theta)=lambda TemplateBox[{theta, 2}, Norm2]^2$ (Tikhonov) or (Lasso), and the loss function is given by , where is the norm function.
The following settings for ValidationSet can be given:

	None	use only the existing calibration data to measure quality (default)
	data	validation set in the same form as calibration data data
	Scaled[frac]	reserve a specified fraction of the calibration data for validation

With the setting VarianceEstimatorFunction->f, the common variance is estimated by f[res,w], where res is the list of residuals and w is the list of weights.
Method settings take the form Method  <|"sub₁"val₁,…|>.
Method suboptions "sub_i" include:
"CalibrationMethod" Automatic calibration method

"SimulationMethod" Automatic simulation method
"CalibrationMethod" settings are the same as the Method settings in FindMinimum.
"SimulationMethod" settings are the same as the Method settings in SystemModelSimulate.
Distributional assumptions are based on an unconstrained model calibrated by minimizing the default loss function.

Examples

open all close all

Basic Examples (2)

Use data of the angular velocity of a component to calibrate a model of a hybrid motor:

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

Wolfram Language code: dataw = {...};

Calibrate the values of the resistance and the damping:

Wolfram Language code: cmodel = SystemModelCalibrate[<|"Inertia2.w" -> dataw|>, model, {"Resistor1.R", "SpringDamper1.d"}]

Simulate with the calibrated parameters and compare with the data:

Wolfram Language code:

Show[SystemModelPlot[cmodel, {"Inertia2.w"}, 40], ListPlot[dataw, PlotStyle -> RGBColor[0.880722, 0.611041, 0.142051]], PlotRange -> All]

Use data of an output of a NonlinearStateSpaceModel to calibrate the model:

Wolfram Language code:

nsys = NonlinearStateSpaceModel[{{u + a*Cos[Subscript[x, 2]] - Cos[Subscript[x, 1]*Subscript[x, 2]], 
   -Cos[1 + Subscript[x, 2]] + Subscript[x, 1]}, {Subscript[x, 1]}}, 
 {Subscript[x, 1], Subscript[x, 2]}, {u}, {Automatic}, Automatic, SamplingPeriod -> None];

Wolfram Language code: datay = {...};

Calibrate a parameter value:

Wolfram Language code: csmodel = SystemModelCalibrate[<|1 -> datay|>, nsys, {{a, 1}}, "CalibratedSystemModel"]

Compute the single prediction bands and plot them together with the data and the calibrated simulation response:

Wolfram Language code: csmodel["SinglePredictionBandsPlot"]//First

Scope (15)

Data (3)

Provide data for as many variables as you want to calibrate:

Wolfram Language code:

nsys = NonlinearStateSpaceModel[{{v, a + f - v - 
    9*x}, {x}}, {x, v}, {f}, 
 {Automatic}, Automatic, SamplingPeriod -> None];

Wolfram Language code: datax = {...};

Wolfram Language code: datav = {...};

Calibrate a parameter value:

Wolfram Language code: csmodel = SystemModelCalibrate[<|x -> datax, v -> datav|>, nsys, {a}, "CalibratedSystemModel"]

Simulate with the calibrated parameter and compare with the data:

Wolfram Language code: csmodel["SinglePredictionBandsPlot"]//Dataset

Use data with units to calibrate a model of a rocket takeoff:

Wolfram Language code: model = [image];

Wolfram Language code: datam = QuantityArray[IconizedObject[«data»], {"Seconds", "Kilograms"}];

Calibrate the mass flow rate with data of the mass of the ship:

Wolfram Language code: SystemModelCalibrate[<|"m" -> datam|>, {model, 0.39 < "k" < 0.46}, {"k"}, "CalibratedParameters"]

Use the time-value pairs of a time series as data to calibrate a model:

Wolfram Language code:

nsys = NonlinearStateSpaceModel[
 {{a + Tanh[u - Subscript[x, 1]*
       Subscript[x, 2]], b + 
    Tanh[a + u*Subscript[x, 2]]}, 
  {Subscript[x, 1]}}, {Subscript[x, 1], Subscript[x, 2]}, 
 {u}, {Automatic}, Automatic, SamplingPeriod -> None];

Wolfram Language code: datay = TimeSeries[{...}];

Calibrate the values of two parameters:

Wolfram Language code: SystemModelCalibrate[<|1 -> datay|>, nsys, {a, b}]

Models (4)

Use data generated with an input signal to calibrate 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"}];

Wolfram Language code: datay = {...};

Wolfram Language code: input = Sin[Range[-5, 5]];

Specify the input signal to calibrate a parameter value:

Wolfram Language code: csmodel = SystemModelCalibrate[<|1 -> datay|>, diom, {a}, <|"Inputs" -> {1 -> input}|>, "CalibratedSystemModel"]

Compute the single prediction bands and plot them together with the data and the calibrated simulation response:

Wolfram Language code: csmodel["SinglePredictionBandsPlot"]//First

Use data generated with an input signal to calibrate a TransferFunctionModel:

Wolfram Language code:

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

Wolfram Language code: datay = {...};

Wolfram Language code: input = UnitStep;

Specify the input signal to calibrate a parameter value:

Wolfram Language code: csmodel = SystemModelCalibrate[<|1 -> datay|>, tfm, {a}, <|"Inputs" -> {1 -> input}|>, "CalibratedSystemModel"]

Compute the single prediction bands and plot them together with the data and the calibrated simulation response:

Wolfram Language code: csmodel["SinglePredictionBandsPlot"]//First

Use data generated with an input signal to calibrate a StateSpaceModel:

Wolfram Language code:

ssm = StateSpaceModel[{{{0, b}, {-a, -b}}, {{0}, {1}}, {{-1, 2}}, 
  {{0}}}, SamplingPeriod -> None, SystemsModelLabels -> None];

Wolfram Language code: datay = {...};

Wolfram Language code: input = Tanh;

Specify the input signal to calibrate parameter values:

Wolfram Language code:

csmodel = SystemModelCalibrate[<|1 -> datay|>, ssm, {{a, 1}, {b, 1}}, <|"Inputs" -> {1 -> input}|>, "CalibratedSystemModel"]

Compute the single prediction bands and plot them together with the data and the calibrated simulation response:

Wolfram Language code: csmodel["SinglePredictionBandsPlot"]//First

Use data of the output of an AffineStateSpaceModel to calibrate the model:

Wolfram Language code:

assm = AffineStateSpaceModel[{{a*Cos[Subscript[x, 2]] - 
    0.5*a*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];

Wolfram Language code: datay = {...};

Calibrate a parameter value:

Wolfram Language code: csmodel = SystemModelCalibrate[<|1 -> datay|>, assm, {{a, 1}}, "CalibratedSystemModel"]

Compute the single prediction bands and plot them together with the data and the calibrated simulation response:

Wolfram Language code: csmodel["SinglePredictionBandsPlot"]//First

Parameters and Constraints (3)

Indicate initial guess values for the calibration parameters:

Wolfram Language code:

nsys = NonlinearStateSpaceModel[
 {{a + Tanh[u - Subscript[x, 1]*
       Subscript[x, 2]], b + 
    Tanh[a + u*Subscript[x, 2]]}, 
  {Subscript[x, 1]}}, {Subscript[x, 1], Subscript[x, 2]}, 
 {u}, {Automatic}, Automatic, SamplingPeriod -> None];

Wolfram Language code: datay = {...};

Calibrate two parameter values:

Wolfram Language code: SystemModelCalibrate[<|1 -> datay|>, nsys, {{a, 0.7}, {b, -0.5}}]

Introduce constraints for the calibration parameters:

Wolfram Language code:

nsys = NonlinearStateSpaceModel[
 {{a + Tanh[u - Subscript[x, 1]*
       Subscript[x, 2]], b + 
    Tanh[a + u*Subscript[x, 2]]}, 
  {Subscript[x, 1]}}, {Subscript[x, 1], Subscript[x, 2]}, 
 {u}, {Automatic}, Automatic, SamplingPeriod -> None];

Wolfram Language code: datay = {...};

Calibrate two parameter values:

Wolfram Language code:

csmodel = SystemModelCalibrate[<|1 -> datay|>, {nsys, 0.75 < a < 0.8, -0.6 < b < -0.55}, {{a, 0.77}, {b, -0.57}}, "CalibratedSystemModel"]

Confidence intervals are computed assuming an unconstrained model:

Wolfram Language code: csmodel["ParameterConfidence"]

Introduce constraints for the calibration parameters when fitting several variables:

Wolfram Language code:

nsys = NonlinearStateSpaceModel[{{v, a + f - v - 
    9*x}, {x}}, {x, v}, {f}, 
 {Automatic}, Automatic, SamplingPeriod -> None];

Wolfram Language code: datax = {...};

Wolfram Language code: datav = {...};

Calibrate a parameter value:

Wolfram Language code: SystemModelCalibrate[<|x -> datax, v -> datav|>, {nsys, 0.5 < a < 1.5}, {{a, 1}}]

Specification (4)

Specify a model name for the calibrated model:

Wolfram Language code: model = [image];

Wolfram Language code: datay = {...};

Calibrate the value of a parameter, specifying the calibrated model name:

Wolfram Language code:

SystemModelCalibrate[<|"y" -> datay|>, {model, 3 < "a" < 5}, {{"a", 4}}, <|"CalibratedModelName" -> "MyCalibratedModel"|>]

Create a calibrated model that extends the input model:

Wolfram Language code:

cmodel = SystemModelCalibrate[<|"y" -> datay|>, {model, 3 < "a" < 5}, {{"a", 4}}, <|"CalibratedModelName" -> "ExtendsInputModel", "ExtendModel" -> True|>]

Wolfram Language code: cmodel["ExtendsModels"]

Use data generated with an input signal to calibrate a model:

Wolfram Language code:

ssm = StateSpaceModel[{{{0, b}, {-a, -b}}, {{0}, {1}}, {{-1, 2}}, 
  {{0}}}, SamplingPeriod -> None, SystemsModelLabels -> None];

Wolfram Language code: datay = {...};

Wolfram Language code: input = Tanh;

Specify the input signal to calibrate parameter values:

Wolfram Language code: SystemModelCalibrate[<|1 -> datay|>, ssm, {{a, 1}, {b, 1}}, <|"Inputs" -> {1 -> input}|>]

Specify a fixed value for a parameter to calibrate another:

Wolfram Language code: SystemModelCalibrate[<|1 -> datay|>, ssm, {{a, 1}}, <|"Inputs" -> {1 -> input}, "ParameterValues" -> {b -> 1.54}|>]

Specify initial values and a simulation interval to calibrate a model:

Wolfram Language code:

assm = AffineStateSpaceModel[{{a*Cos[Subscript[x, 2]] - 
    0.5*a*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];

Wolfram Language code: datay = {...};

Calibrate a parameter value:

Wolfram Language code:

SystemModelCalibrate[<|1 -> datay|>, assm, {{a, 1}}, <|"InitialValues" -> {Subscript[x, 1] -> 0.01}, "SimulationInterval" -> {0, 5}|>]

Provide weights for the calibration of several variables:

Wolfram Language code:

nsys = NonlinearStateSpaceModel[{{v, a + f - v - 
    9*x}, {x}}, {x, v}, {f}, 
 {Automatic}, Automatic, SamplingPeriod -> None];

Wolfram Language code: datax = {...};

Wolfram Language code: datav = {...};

Wolfram Language code: weights = {1, 2};

Calibrate a parameter value:

Wolfram Language code: csmodel = SystemModelCalibrate[<|x -> datax, v -> datav|>, nsys, {a}, <|"Weights" -> weights|>, "CalibratedSystemModel"]

Compute the single prediction bands and plot them together with the data and the calibrated simulation response:

Wolfram Language code: csmodel["SinglePredictionBandsPlot"]//Dataset

Properties (1)

Find the list of available properties:

Wolfram Language code:

nsys = NonlinearStateSpaceModel[{{u + a*Cos[Subscript[x, 2]] - 
    Cos[Subscript[x, 1]*Subscript[x, 2]], 
   -Cos[1 + Subscript[x, 2]] + Subscript[x, 1]}, 
  {Subscript[x, 1]}}, {Subscript[x, 1], Subscript[x, 2]}, 
 {u}, {Automatic}, Automatic, SamplingPeriod -> None];

Wolfram Language code: datay = {...};

Wolfram Language code: SystemModelCalibrate[<|1 -> datay|>, nsys, {{a, 1}}, "Properties"]//Shallow

These can be extracted more conveniently from the CalibratedSystemModel:

Wolfram Language code: csmodel = SystemModelCalibrate[<|1 -> datay|>, nsys, {{a, 1}}, "CalibratedSystemModel"]

Wolfram Language code: csmodel["Properties"]

Extract the single prediction bands plot:

Wolfram Language code: csmodel["SinglePredictionBandsPlot"]//First

Extract the single prediction bands plot with a custom confidence level:

Wolfram Language code: csmodel["SinglePredictionBandsPlot", ConfidenceLevel -> 0.5]//First

Extract the single prediction bands plot with a custom variance estimator function:

Wolfram Language code: csmodel["SinglePredictionBandsPlot", VarianceEstimatorFunction -> (Mean[Abs[#]]&)]//First

Extract the calibrated model and the calibrated parameters:

Wolfram Language code: csmodel[{"CalibratedModel", "CalibratedParameters"}]

Extract the single prediction bands:

Wolfram Language code: csmodel["SinglePredictionBands"]//Short

Extract the single prediction bands evaluated at time t:

Wolfram Language code: csmodel["SinglePredictionBands", t]//Short

Extract the root mean squared error for each calibration variable:

Wolfram Language code: csmodel["MSE"]

Extract the root mean squared error for each calibration variable providing a validation set:

Wolfram Language code:

csmodel["MSE", ValidationSet -> <|1 -> {{2.6, 1.8}, {2.7, 1.56}, {2.8, 1.4}, {2.9, 1.2}, {3., 1.2}, {3.1, 1.0}, {3.2, 1.0}, {3.3, 0.8}}|>]

Extract parameter confidence information, including estimates, standard errors, confidence intervals,

-statistics for parameter estimates

, and

‐values for parameter

‐statistics:

Wolfram Language code: csmodel["ParameterConfidence"]

Options (8)

ConfidenceLevel (1)

Use data of the states of a model to calibrate a parameter:

Wolfram Language code:

nsys = NonlinearStateSpaceModel[{{v, a + f - v - 
    9*x}, {x}}, {x, v}, {f}, 
 {Automatic}, Automatic, SamplingPeriod -> None];

Wolfram Language code: datax = {...};

Wolfram Language code: datav = {...};

Use the default confidence level:

Wolfram Language code: SystemModelCalibrate[<|x -> datax, v -> datav|>, nsys, {a}, "SinglePredictionBandsPlot"]

Specify a custom confidence level of 0.5:

Wolfram Language code: SystemModelCalibrate[<|x -> datax, v -> datav|>, nsys, {a}, "SinglePredictionBandsPlot", ConfidenceLevel -> 0.5]

FitRegularization (1)

Use data of an output to calibrate a model:

Wolfram Language code:

nsys = NonlinearStateSpaceModel[
 {{a + Tanh[u - Subscript[x, 1]*
       Subscript[x, 2]], b + 
    Tanh[a + u*Subscript[x, 2]]}, 
  {Subscript[x, 1]}}, {Subscript[x, 1], Subscript[x, 2]}, 
 {u}, {Automatic}, Automatic, SamplingPeriod -> None];

Wolfram Language code: datay = {...};

Use a loss function with no regularization to calibrate parameters:

Wolfram Language code: SystemModelCalibrate[<|1 -> datay|>, nsys, {a, b}, "CalibratedParameters"]

Use a Lasso regularization to calibrate parameters:

Wolfram Language code: SystemModelCalibrate[<|1 -> datay|>, nsys, {a, b}, "CalibratedParameters", FitRegularization -> {"LASSO", 2}]

Use a Tikhonov regularization to calibrate parameters:

Wolfram Language code: SystemModelCalibrate[<|1 -> datay|>, nsys, {a, b}, "CalibratedParameters", FitRegularization -> {"Tikhonov", 2}]

Method (2)

Use data of the mass of a ship to calibrate a model of a rocket takeoff:

Wolfram Language code: model = [image];

Wolfram Language code: datam = IconizedObject[«data»];

Use the default simulation method to calibrate the value of the mass flow rate:

Wolfram Language code: SystemModelCalibrate[<|"m" -> datam|>, {model, 0.39 < "k" < 0.46}, {"k"}, "SinglePredictionBandsPlot"]//First

Calibrate, specifying a number of interpolation points for simulation:

Wolfram Language code:

SystemModelCalibrate[<|"m" -> datam|>, {model, 0.39 < "k" < 0.46}, {"k"}, "SinglePredictionBandsPlot", Method -> <|"SimulationMethod" -> {"InterpolationPoints" -> 6}|>]//First

Use data of an output to calibrate a model:

Wolfram Language code:

nsys = NonlinearStateSpaceModel[
 {{a + Tanh[u - Subscript[x, 1]*
       Subscript[x, 2]], b + 
    Tanh[a + u*Subscript[x, 2]]}, 
  {Subscript[x, 1]}}, {Subscript[x, 1], Subscript[x, 2]}, 
 {u}, {Automatic}, Automatic, SamplingPeriod -> None];

Wolfram Language code: datay = {...};

Use the default fitting method to calibrate parameters:

Wolfram Language code: csmodel = SystemModelCalibrate[<|1 -> datay|>, nsys, {a, b}, "CalibratedSystemModel"];

Wolfram Language code: csmodel["CalibratedParameters"]

Wolfram Language code: csmodel["SinglePredictionBandsPlot"]//First

Use the conjugate gradient method to calibrate parameters:

Wolfram Language code:

csmodelg = SystemModelCalibrate[<|1 -> datay|>, nsys, {a, b}, "CalibratedSystemModel", Method -> <|"CalibrationMethod" -> "ConjugateGradient"|>];

Wolfram Language code: csmodelg["CalibratedParameters"]

Wolfram Language code: csmodelg["SinglePredictionBandsPlot"]//First

NormFunction (1)

Use data of an output to calibrate a model:

Wolfram Language code:

nsys = NonlinearStateSpaceModel[
 {{a + Tanh[u - Subscript[x, 1]*
       Subscript[x, 2]], b + 
    Tanh[a + u*Subscript[x, 2]]}, 
  {Subscript[x, 1]}}, {Subscript[x, 1], Subscript[x, 2]}, 
 {u}, {Automatic}, Automatic, SamplingPeriod -> None];

Wolfram Language code: datay = {...};

Use the default norm in the loss function to calibrate parameters:

Wolfram Language code: SystemModelCalibrate[<|1 -> datay|>, nsys, {a, b}, "CalibratedParameters"]

Use the -norm in the loss function to calibrate parameters:

Wolfram Language code: SystemModelCalibrate[<|1 -> datay|>, nsys, {a, b}, "CalibratedParameters", NormFunction -> (Norm[#, Infinity]&)]

Use the 1-norm in the loss function to calibrate parameters

Wolfram Language code: SystemModelCalibrate[<|1 -> datay|>, nsys, {a, b}, "CalibratedParameters", NormFunction -> (Norm[#, 1]&)]

ProgressReporting (1)

Use data of the mass of a ship to calibrate a model of a rocket takeoff:

Wolfram Language code: model = [image];

Wolfram Language code: datam = IconizedObject[«data»];

Calibrate the value of the mass flow rate with the default progress reporting:

Wolfram Language code: SystemModelCalibrate[<|"m" -> datam|>, {model, 0.39 < "k" < 0.46}, {"k"}, "CalibratedParameters"]

Calibrate without progress reporting:

Wolfram Language code:

SystemModelCalibrate[<|"m" -> datam|>, {model, 0.39 < "k" < 0.46}, {"k"}, "CalibratedParameters", ProgressReporting -> False]

ValidationSet (1)

Use data of an output to calibrate a model:

Wolfram Language code:

nsys = NonlinearStateSpaceModel[
 {{a + Tanh[u - Subscript[x, 1]*
       Subscript[x, 2]], b + 
    Tanh[a + u*Subscript[x, 2]]}, 
  {Subscript[x, 1]}}, {Subscript[x, 1], Subscript[x, 2]}, 
 {u}, {Automatic}, Automatic, SamplingPeriod -> None];

Wolfram Language code: datay = {...};

Calibrate parameters using no validation data:

Wolfram Language code: SystemModelCalibrate[<|1 -> datay|>, nsys, {a, b}, "RMSE"]

Calibrate parameters by reserving a fraction of the calibration data for validation:

Wolfram Language code: SystemModelCalibrate[<|1 -> datay|>, nsys, {a, b}, "RMSE", ValidationSet -> Scaled[0.1]]

Use a particular random seed in the selection of validation data to ensure predictable results:

Wolfram Language code:

BlockRandom[SystemModelCalibrate[<|1 -> datay|>, nsys, {a, b}, "RMSE", ValidationSet -> Scaled[0.1]], RandomSeeding -> 1234]

Use a custom validation set to calibrate parameters:

Wolfram Language code:

SystemModelCalibrate[<|1 -> datay|>, nsys, {a, b}, "RMSE", ValidationSet -> <|1 -> {{0.75, 0.9}, {1., 0.7}, {1.25, 1.1}, {1.5, 1.2}, {1.75, 1.15}}|>]

VarianceEstimatorFunction (1)

Use data of the states of a model to calibrate a parameter:

Wolfram Language code:

nsys = NonlinearStateSpaceModel[{{v, a + f - v - 
    9*x}, {x}}, {x, v}, {f}, 
 {Automatic}, Automatic, SamplingPeriod -> None];

Wolfram Language code: datax = {...};

Wolfram Language code: datav = {...};

Use the default estimate of error variance:

Wolfram Language code: SystemModelCalibrate[<|x -> datax, v -> datav|>, nsys, {a}, "SinglePredictionBandsPlot"]

Estimate the variance by the mean absolute error:

Wolfram Language code:

SystemModelCalibrate[<|x -> datax, v -> datav|>, nsys, {a}, "SinglePredictionBandsPlot", VarianceEstimatorFunction -> (Mean[Abs[#]]&)]

Applications (5)

Industrial Manufacturing (1)

Use temperature data to estimate the heat transfer coefficient in a model of a continuous stirred-tank reactor:

Wolfram Language code: model = [image];

Use the measured temperature of the tank and the cooling medium:

Wolfram Language code:

dataTr = QuantityArray[IconizedObject[«dataTr»], {"Hours", "Kelvins"}];
dataTj = QuantityArray[IconizedObject[«dataTj»], {"Hours", "Kelvins"}];

Set the cooling medium flow rate used in the measurement as input:

Wolfram Language code: mediumFlowRate = <|"Inputs" -> {"FJ" -> Function[0.02]}|>;

Fit the heat transfer coefficient:

Wolfram Language code:

csmodel = Quiet[SystemModelCalibrate[<|"TR" -> dataTr, "TJ" -> dataTj|>, model, {"U"}, mediumFlowRate, "CalibratedSystemModel", Method -> <|"CalibrationMethod" -> "PrincipalAxis"|>], {FindMinimum::fmmp}]

Compute the single prediction bands and plot them together with the data and the calibrated simulation response:

Wolfram Language code: csmodel["SinglePredictionBandsPlot"]//Dataset

Plot the residuals against time for the tank temperature:

Wolfram Language code:

ListPlot[Transpose[{dataTr[[All, 1]], csmodel["CalibrationDataResiduals"]["TR"]}], Sequence[Frame -> True, Filling -> Axis, FrameLabel -> {"h", "residual TR"}, PlotLabel -> "Residual vs Time"]]

Model Simplification (1)

Recreate the behavior of a speaker by calibrating a simpler circuit using simulation results as input data:

Wolfram Language code: speaker = [image];

Wolfram Language code: rl = [image];

Compare the behavior of both models before calibration:

Wolfram Language code: sims = SystemModelSimulate[speaker];

Wolfram Language code: simrl = SystemModelSimulate[rl];

Wolfram Language code: SystemModelPlot[{sims, simrl}, {"vs.v"}]

Retrieve simulation results as data and use them for calibration:

Wolfram Language code: datav = sims["RawData", "vs.v"];

Wolfram Language code: csmodel = SystemModelCalibrate[<|"vs.v" -> datav|>, {rl, 0.001 < l < 0.5}, {l}, "CalibratedSystemModel"]

Compare the calibrated model with the speaker:

Wolfram Language code: SystemModelPlot[{sims, csmodel["CalibratedSimulationData"]}, {"vs.v"}]

Conveyor Belt Friction (1)

Calibrate the viscous contribution to friction in a model of a body held by a spring on top of an accelerating conveyor belt:

Wolfram Language code: beltv[t_] := vb + ab t;

The total kinetic friction can be modeled as a combination of viscous, Coulomb and Stribeck components:

Wolfram Language code: viscous[v_] := -d (v - beltv[t]);

Wolfram Language code: coulomb[v_] := -c Sign[v - beltv[t]];

Wolfram Language code: stribeck[v_] := -s Sign[v] Exp[-σ Abs[v]];

Wolfram Language code: friction[v_] := viscous[v] + coulomb[v] + stribeck[v];

The equations of motion must include the event-generating effect of the static friction, which holds the body static with respect to the belt until an upper bound is breached by external forces:

Wolfram Language code: spring[x_] := -k (x - l);

Wolfram Language code:

eqs = {m v'[t] == If[stuck[t] == 1, m beltv'[t], spring[x[t]] + friction[v[t]]], 
	x'[t] == v[t], WhenEvent[v[t] == beltv[t], stuck[t] -> Boole[spring[x[t]]^2 < μ^2]], WhenEvent[spring[x[t]]^2 > μ^2, stuck[t] -> 0]};

Set initial values for the position and velocity of the body and the discrete variable tracking the impact of static friction:

Wolfram Language code: initeqs = {x[0] == 1, v[0] == 0, stuck[0] == 0};

Set parameter values and create the system model:

Wolfram Language code: parVals = {m -> 1, l -> 1, d -> 5, c -> 5, s -> 1, μ -> 100, k -> 1000, σ -> 2, vb -> 1 / 10, ab -> 1 / 100};

Wolfram Language code:

model = CreateSystemModel["ConveyorBeltFriction", Join[eqs, initeqs], t, <|"DiscreteVariables" -> {stuck}, "ParameterValues" -> parVals|>]

Calibrate the contribution of the viscous term with data for the position of the body:

Wolfram Language code: datax = {...};

Wolfram Language code: csmodel = SystemModelCalibrate[<|x -> datax|>, {model, 1 < d < 20}, {d}, "CalibratedSystemModel"]

Find the 95% confidence interval for the viscous friction factor:

Wolfram Language code: csmodel["ParameterConfidence"]

Compute the single prediction bands and plot them together with the data and the calibrated simulation response:

Wolfram Language code: csmodel["SinglePredictionBandsPlot"]//First

Compute the extremes of the position and velocity for the calibrated simulation data:

Wolfram Language code: SystemModelMeasurements[csmodel["CalibratedSimulationData"], {"MinValue", "MaxValue"}]

Reverse Engineering of Controller (1)

Deduce the controller parameters in a controlled system for which you have step response data:

Wolfram Language code:

plant = TransferFunctionModel[{{{6}}, (1 + 2*s)*(1 + 4*s)*
   (1. + 6*s)}, s];

Wolfram Language code: csys = PIDTune[plant, "PID", "ReferenceOutput"];

Wolfram Language code: sim = SystemModelSimulate[csys, 50, <|"Inputs" -> {1 -> UnitStep}|>];

Wolfram Language code: data = sim["RawData", Subscript[, 1]];

Connect the plant model to a controller with symbolic parameters:

Wolfram Language code:

pid = TransferFunctionModel[{{{s^2*Subscript[k, d] + 
     Subscript[k, i] + s*Subscript[k, 
       p]}}, s}, s];

Wolfram Language code: csysWithPars = SystemsModelFeedbackConnect[SystemsModelSeriesConnect[pid, plant]];

Calibrate the parameters in the model with the step response data of the controlled system:

Wolfram Language code:

csmodel = SystemModelCalibrate[<|1 -> data|>, {csysWithPars, 0.01 < Subscript[k, p] < 10, 0.01 < Subscript[k, i] < 10, 0.01 < Subscript[k, d] < 10}, {{Subscript[k, p], 0.5}, {Subscript[k, i], 1}, {Subscript[k, d], 1}}, <|"Inputs" -> {1 -> UnitStep}|>, "CalibratedSystemModel"]

Compare the simulation results of the calibrated model with the reverse-engineered model:

Wolfram Language code:

SystemModelPlot[{sim, csmodel["CalibratedSimulationData"]}, {Subscript[, 1]}, PlotStyle -> {Automatic, Directive[RGBColor[0.922526, 0.385626, 0.209179], Dashed]}, PlotRange -> All]

Reduced Three-Body Problem (1)

Estimate the mass of a planet that orbits a star from the trajectory of one of its moons in a reduced three-body planetary system:

Wolfram Language code:

starPlanetSystemEqs = {μ12 r[t]^2θ'[t] == Sqrt[a (1 - e^2) 𝒢 m1 m2 μ12], r[t] == (a(1 - e^2)/1 + e Cos[θ[t] - θr]), {x1[t], y1[t]} == -(m2/m1 + m2){xr[t], yr[t]}, {x2[t], y2[t]} == (m1/m1 + m2){xr[t], yr[t]}, {xr[t], yr[t]} == r[t]{Cos[θ[t]], Sin[θ[t]]}};

The dynamics of the moon are dictated by Newtonian gravity:

Wolfram Language code:

moonEqs = {m3 vx3'[t] == -𝒢 m1 m3(x3[t] - x1[t]/((x3[t] - x1[t])^2 + (y3[t] - y1[t])^2)^3 / 2) - 𝒢 m2 m3(x3[t] - x2[t]/((x3[t] - x2[t])^2 + (y3[t] - y2[t])^2)^3 / 2), m3 vy3'[t] == -𝒢 m1 m3(y3[t] - y1[t]/((x3[t] - x1[t])^2 + (y3[t] - y1[t])^2)^3 / 2) - 𝒢 m2 m3(y3[t] - y2[t]/((x3[t] - x2[t])^2 + (y3[t] - y2[t])^2)^3 / 2), {vx3[t], vy3[t]} == {x3'[t], y3'[t]}};

Set parameter values for the system and initial values for the trajectory of the moon:

Wolfram Language code: parVals = {𝒢 -> 1, m1 -> 1, m2 -> 0.0059, m3 -> 0.00001, a -> 1, e -> 0.0549, θr -> 0, μ12 -> (m1 m2/m1 + m2)};

Wolfram Language code: initVals = {x3 -> 0.9, vy3 -> 0.6};

Create a model from the equations, parameters and initial values:

Wolfram Language code:

model = CreateSystemModel["ReducedTBP", Join[starPlanetSystemEqs, moonEqs], t, <|"ParameterValues" -> parVals, "InitialValues" -> initVals|>]

Simulate the model before calibration and plot the trajectories of the three bodies:

Wolfram Language code: sim = SystemModelSimulate[model, 4];

Wolfram Language code: ParametricPlot[Evaluate[{sim[{x1, y1}, t], sim[{x2, y2}, t], sim[{x3, y3}, t]}], {t, 0, 4}, ...]

Calibrate a model with data for the trajectory of the moon:

Wolfram Language code: datax3 = {...};

Wolfram Language code: datay3 = {...};

Wolfram Language code:

csmodel = SystemModelCalibrate[<|x3 -> datax3, y3 -> datay3|>, {model, 0.001 < m2 < 0.007}, m2, "CalibratedSystemModel", Method -> <|"CalibrationMethod" -> "NMinimize"|>]

Retrieve the simulation data and plot the trajectories for the calibrated model:

Wolfram Language code: simcal = csmodel["CalibratedSimulationData"];

Wolfram Language code: cPlot = ParametricPlot[Evaluate[{simcal[{x1, y1}, t], simcal[{x2, y2}, t], simcal[{x3, y3}, t]}], {t, 0, 4}, ...]

Compare the data with the calibrated trajectory:

Wolfram Language code:

Show[cPlot, ListPlot[Transpose[{datax3[[All, 2]], datay3[[All, 2]]}], PlotStyle -> RGBColor[0.922526, 0.385626, 0.209179], PlotLegends -> {"data"}]]

Top

SystemModelCalibrate

Details and Options

Properties

Options

Examples

Basic Examples (2)

Scope (15)

Data (3)

Models (4)

Parameters and Constraints (3)

Specification (4)

Properties (1)

Options (8)

ConfidenceLevel (1)

FitRegularization (1)

Method (2)

NormFunction (1)

ProgressReporting (1)

ValidationSet (1)

VarianceEstimatorFunction (1)

Applications (5)

Industrial Manufacturing (1)

Model Simplification (1)

Conveyor Belt Friction (1)

Reverse Engineering of Controller (1)

Reduced Three-Body Problem (1)

See Also

Tech Notes

Related Guides

Related Links

History

Text

CMS

APA

BibTeX

BibLaTeX