accelerate, refine, and test hybrid dynamic system on host computer by using rsim system target file -凯发k8网页登录

about rapid simulation data setup

the format and setup of input data for a rapid simulation depends on your requirements.

the rsim target requires that mat-files used as input for from file and inport blocks contain data. the grt target inserts mat-file data directly into the generated code, which is then compiled and linked as an executable. in contrast, rsim allows you to replace data sets for each successive simulation. a mat-file containing from file or inport block data must be present if a from file block or inport block exists in your model.

create a mat-file that includes a model parameter structure

to create a mat-file that includes a model global parameter structure (model_p),

if you want to run simulations over varying data sets, consider converting the parameter structure to a cell array and saving the parameter variations to a single mat-file.

get the parameter structure for a model.  get the global parameter structure (model_p) for a model by calling the function rsimgetrtp.

param_struct = rsimgetrtp('model')

the rsimgetrtp function forces an update diagram action for the specified model and returns a structure that contains the following fields.

the parameter structure contains the following information.

the code generator reports a tunable fixed-point parameter according to its stored value. for example, an sfix(16) parameter value of 1.4 with a scaling of 2^-8 has a value of 358 as an int16.

in the following example, rsimgetrtp returns the parameter structure for the example model to param_struct.

param_struct = rsimgetrtp('rtwdemo_rsimtf')

param_struct = 
    modelchecksum: [1.7165e 009 3.0726e 009 2.6061e 009 2.3064e 009]
       parameters: [1x1 struct]

save the parameter structure to a mat-file.  after you issue a call to rsimgetrtp, save the return value of the function call to a mat-file. using a command-line option, you can then specify that mat-file as input for rapid simulations.

the following example saves the parameter structure returned for rtwdemo_rsimtf to the mat-file myrsimdemo.mat.

save myrsimdemo.mat param_struct;

for information on using command-line options to specify required files, see run rapid simulations.

convert the parameter structure for running simulations on varying data sets.  to use rapid simulations to test changes to specific parameters, you can convert the model parameter structure to a cell array. you can then access a specific parameter set by using the @ operator to specify the index for a specific parameter set in the file.

to convert the structure to a cell array:

alternatively, you can modify the block parameters in the model, and use rsimgetrtp to create multiple parameter sets:

for more information on how to specify each parameter set when you run the simulations, see change block parameters for an rsim simulation.

create a mat-file for a from file block

you can use a mat-file as the input data source for a block. the format of the data in the mat-file must match the data format expected by that block. for example, if you are using a matrix as an input for the mat file, this cannot be different from the matrix size for the executable.

to create a mat-file for a from file block:

create a mat-file for an inport block

you can use a mat-file as the input data source for an inport block.

the format of the data in the mat-file must adhere to one of the three column-based formats listed in the following table. the table lists the formats in order from least flexible to most flexible.

the supported formats and the following procedure are illustrated in .

to create a mat-file for an inport block:

rapid simulations

using the rsim target, you can build a model once and run multiple simulations to study effects of varying parameter settings and input signals. you can run a simulation directly from your operating system command line, redirect the command from the matlab command line by using the bang (!) character, or execute commands from a script.

from the operating system command line, use

rtwdemo_rsimtf

from the matlab command line, use

!rtwdemo_rsimtf

the following table lists ways you can use rsim target command-line options to control a simulation.

the following sections use the example model in examples to illustrate some of these command-line options. in each case, the example assumes you have already done the following:

requirements for running rapid simulations

the following requirements apply to both fixed and variable step executables.

set a clock time limit for a rapid simulation

if a model experiences frequent zero crossings and the model's minor step size is small, consider setting a time limit for a rapid simulation. to set a time limit, specify the -l option with a positive integer value. the simulation aborts after running for the specified amount of clock time (not simulation time). for example,

  !rtwdemo_rsimtf -l 20

based on your clock, after the executable runs for 20 seconds, the program terminates. you see a message similar to one of the following:

you do not need to do anything to your model or to its configuration to use this option.

override a model simulation stop time

by default, a rapid simulation runs until the simulation time reaches the time specified the configuration parameters dialog box, on the solver pane. you can override the model simulation stop time by using the -tf option. for example, the following simulation runs until the time reaches 6.0 seconds.

!rtwdemo_rsimtf -tf 6.0

the rsim target stops and logs output data using mat-file data logging rules.

if the model includes a from file block, the end of the simulation is regulated by the stop time setting specified in the configuration parameters dialog box, on the solver pane, or with the rsim target option -tf. the values in the block time vector are ignored. however, if the simulation time exceeds the endpoints of the time and signal matrix (if the final time is greater than the final time value of the data matrix), the signal data is extrapolated to the final time value.

read the parameter vector into a rapid simulation

to read the model parameter vector into a rapid simulation, you must first create a mat-file that includes the parameter structure as described in create a mat-file that includes a model parameter structure. you can then specify the mat-file in the command line with the -p option.

for example:

specify new signal data file for a from file block

if your model's input data source is a block, you can feed the block with input data during simulation from a single mat-file or you can change the mat-file from one simulation to the next. each mat-file must adhere to the format described in create a mat-file for a from file block.

to change the mat-file after an initial simulation, you specify the executable with the -f option and an oldfile.mat=newfile.mat parameter, as shown in the following example.

from file blocks require input data of type double. if you need to import signal data of a data type other than double, use an inport block (see create a mat-file for an inport block) or a from workspace block with the data specified as a structure.

workspace data must be in the format:

variable.time
variable.signals.values

if you have more than one signal, use the following format:

variable.time
variable.signals(1).values
variable.signals(2).values

specify signal data file for an inport block

if your model's input data source is an inport block, you can feed the block with input data during simulation from a single mat-file or you can change the mat-file from one simulation to the next. each mat-file must adhere to one of the three formats described in create a mat-file for an inport block.

to specify the mat-file after a simulation, you specify the executable with the -i option and the name of the mat-file that contains the input data. for example:

change block parameters for an rsim simulation

as described in create a mat-file that includes a model parameter structure, after you alter one or more parameters in a simulink block diagram, you can extract the parameter vector, model_p, for the entire model. you can then save the parameter vector, along with a model checksum, to a mat-file. this mat-file can be read directly by the standalone rsim executable, allowing you to replace the entire parameter vector or individual parameter values, for running studies of variations of parameter values representing coefficients, new data for input signals, and so on.

rsim can read the mat-file and replace the entire model_p structure whenever you change one or more parameters, without recompiling the entire model.

for example, assume that you changed one or more parameters in your model, generated the new model_p vector, and saved model_p to a new mat-file called mymatfile.mat. to run the same rtwdemo_rsimtf model and use these new parameter values, use the -p option, as shown in the following example:

!rtwdemo_rsimtf -p mymatfile.mat
load rtwdemo_rsimtf 
plot(rt_yout)

if you have converted the parameter structure to a cell array for running simulations on varying data sets, as described in convert the parameter structure for running simulations on varying data sets, you must add an @n suffix to the mat-file specification. n is the element of the cell array that contains the specific input that you want to use for the simulation.

the following example converts param_struct to a cell array, changes parameter values, saves the changes to mat-file mymatfile.mat, and then runs the executable using the parameter values in the second element of the cell array as input.

param_struct = rsimgetrtp('rtwdemo_rsimtf');
param_struct = rsimsetrtpparam(param_struct,2);
param_struct.parameters{1}

ans = 
       datatypename: 'double'
         datatypeid: 0
            complex: 0
         dttransidx: 0
             values: [-140 -4900 0 4900]
                map: []
    structparaminfo: []

param_struct.parameters{2}.values=[-150 -5000 0 4950];
save mymatfile.mat param_struct;
!rtwdemo_rsimtf -p mymatfile.mat@2 -o rsim2.mat

specify a new output file name for a simulation

if you have specified one or more of the save to workspace parameters — time, states, outputs, or final states — in the configuration parameters dialog box, on the data import/export pane, the default is to save simulation logging results to the file model.mat. for example, the example model rtwdemo_rsimtf normally saves data to rtwdemo_rsimtf.mat, as follows:

!rtwdemo_rsimtf
created rtwdemo_rsimtf.mat

you can specify a new output file name for data logging by using the -o option when you run an executable.

!rtwdemo_rsimtf -o rsim1.mat

in this case, the set of parameters provided at the time of code generation, including from file block data parameters, is run.

specify new output file names for to file blocks

in much the same way as you can specify a new system output file name, you can also provide new output file names for data saved from one or more to file blocks. to do this, specify the original file name at the time of code generation with a new name, as shown in the following example:

!rtwdemo_rsimtf -t rtwdemo_rsimtf_data.mat=mynewrsimdata.mat

in this case, assume that the original model wrote data to the output file rtwdemo_rsimtf_data.mat. specifying a new file name forces rsim to write to the file mynewrsimdata.mat. with this technique, you can avoid overwriting an existing simulation run.