#1
char Aclass(3,24)
Adymosim
1.4
Modelica experiment file


#    Experiment parameters
double experiment(7,1)
       0                   # StartTime    Time at which integration starts
                           #              (and linearization and trimming time)
       1                   # StopTime     Time at which integration stops
       0                   # Increment    Communication step size, if > 0
     500                   # nInterval    Number of communication intervals, if > 0
 1.0000000000000000E-004   # Tolerance    Relative precision of signals for
                           #              simulation, linearization and trimming
       0                   # MaxFixedStep Maximum step size of fixed step size
                           #              integrators, if > 0.0
       8                   # Algorithm    Integration algorithm as integer (1...28)
                           #
                           #             | model|       |        | dense | state |
                           # Algorithm   | typ  | stiff | order  | output| event |
                           # ------------+------+-------+--------+-------+-------+
                           #  1 | deabm  |  ode |   no  |  1-12  |  yes  |   no  |
                           #  2 | lsode1 |  ode |   no  |  1-12  |  yes  |   no  |
                           #  3 | lsode2 |  ode |  yes  |  1-5   |  yes  |   no  |
                           #  4 | lsodar |  ode |  both |1-12,1-5|  yes  |  yes  |
                           #  5 | dopri5 |  ode |   no  |   5    |   no  |   no  |
                           #  6 | dopri8 |  ode |   no  |   8    |   no  |   no  |
                           #  7 | grk4t  |  ode |  yes  |   4    |   no  |   no  |
                           #  8 | dassl  |  dae |  yes  |  1-5   |  yes  |  yes  |
                           #  9 | odassl | hdae |  yes  |  1-5   |  yes  |  yes  |
                           # 10 | mexx   | hdae |   no  |  2-24  |   no  |   no  |
                           # 11 | euler  |  ode |   no  |   1    |   no  |  yes  |
                           # 12 | rkfix2 |  ode |   no  |   2    |   no  |  yes  |
                           # 13 | rkfix3 |  ode |   no  |   3    |   no  |  yes  |
                           # 14 | rkfix4 |  ode |   no  |   4    |   no  |  yes  |
                           #>=14| others |  ode |yes/no |  2-5   |   yes |  yes  |
                           # ---+--------+------+-------+--------+-------+-------+
                           # euler and rkfix have fixed stepsize.


#    Method tuning parameters
double method(27,1)
       1                   # grid     type of communication time grid, defined by
                           #          = 1: equidistant points ("Increment/nInterval")
                           #          = 2: vector of grid points ("tgrid")
                           #          = 3: variable step integrator (automatically)
                           #          = 4: model (call of "increment" in Dymola, e.g.
                           #                      incr=Time > 2 then 0 else 0.1
                           #                      dummy=increment(incr))
                           #          grid = 1,3 is stopped by "StopTime"
                           #          grid = 2   is stopped by "tgrid(last)"
                           #          grid = 4   runs forever (stopped by model)
       1                   # nt       Use every NT time instant, if grid = 3
       3                   # dense    1/2/3 restart/step/interpolate GRID points
       1                   # evgrid   0/1 do not/save event points in comm. time grid
       1                   # evu      0/1 U-discontinuity does not/trigger events
       0                   # evuord       U-discontinuity order to consider (0,1,...)
       0                   # error    0/1/2 One message/warning/error messages
       0                   # jac      0/1 Compute jacobian numerically/by BLOCKJ
       0                   # xd0c     0/1 Compute/set XD0
       0                   # f3       0/1 Ignore/use F3 of HDAE (= index 1)
       0                   # f4       0/1 Ignore/use F4 of HDAE (= index 2)
       0                   # f5       0/1 Ignore/use F5 of HDAE (= invar.)
       0                   # debug    flags for debug information (1<<0 uses pdebug) 
     100                   # pdebug       priority of debug information (1...100)
       0                   # fmax     Maximum number of evaluations of BLOCKF, if > 0
       0                   # ordmax   Maximum allowed integration order, if > 0
       0                   # hmax     Maximum absolute stepsize, if > 0
       0                   # hmin     Minimum absolute stepsize, if > 0 (use with care!)
       0                   # h0       Stepsize to be attempted on first step, if > 0
 2.0000000000000000E-014   # teps     Bound to check, if 2 equal time instants
 1.0000000000000000E-010   # eveps    Hysteresis epsilon at event points
      20                   # eviter   Maximum number of event iterations
 9.9999999999999995E-007   # delaym   Minimum time increment in delay buffers
       1                   # fexcep   0/1 floating exception crashes/stops dymosim
       1                   # tscale   clock-time = tscale*simulation-time, if grid = 5
                           #          > 1: simulation too slow
                           #          = 1: simulation-time = real-time
                           #          < 1: simulation too fast
       1                   # shared   (not used)
    2473                   # memkey   (not used)


#    Output parameters
int settings(13,1)
 0                         # lprec    0/1 do not/store result data in double
 1                         # lx       0/1 do not/store x  (state variables)
 1                         # lxd      0/1 do not/store xd (derivative of states)
 1                         # lu       0/1 do not/store u  (input     signals)
 1                         # ly       0/1 do not/store y  (output    signals)
 0                         # lz       0/1 do not/store z  (indicator signals)
 1                         # lw       0/1 do not/store w  (auxiliary signals)
 1                         # la       0/1 do not/store a  (alias     signals)
 0                         # lperf    0/1 do not/store performance indicators
 0                         # levent   0/1 do not/store event point
 1                         # lres     0/1 do not/store results on result file
 0                         # lshare   0/1 do not/store info data for shared memory on dsshare.txt
 1                         # lform    0/1 ASCII/Matlab-binary storage format of results
                           #              (for simulation/linearization; not for trimming)


#    Names of initial variables
char initialName(31,10)
u
y
k
Ti
Td
Nd
initType
xi_start
xd_start
y_start
P.k
P.y
I.k
I.initType
I.y_start
I.y
I.der(y)
D.k
D.T
D.initType
D.x_start
D.y_start
D.y
D.x
D.der(x)
D.zeroGain
Gain.k
Gain.u
Add.k1
Add.k2
Add.k3

double initialValue(31,6)
 -1       0                       0                       0                
  5   256   # u
  0       0                       0                       0                
  4   256   # y
 -1       1                       0                       0                
  1   280   # k
 -1 5.0000000000000000E-001 9.9999999999999997E-061 1.0000000000000000E+100
  1   280   # Ti
 -1       1                       0                 1.0000000000000000E+100
  1   280   # Td
 -1      10                 9.9999999999999997E-061 1.0000000000000000E+100
  1   280   # Nd
  0       5                       1                       5                
  6   258   # initType
 -1       0                       0                       0                
  1   280   # xi_start
 -1       0                       0                       0                
  1   280   # xd_start
 -1       0                       0                       0                
  1   280   # y_start
 -1       1                       0                       0                
  1   280   # P.k
  0       0                       0                       0                
  6   256   # P.y
  0       0                       0                       0                
  6   256   # I.k
  0       3                       1                       4                
  6   258   # I.initType
  0       0                       0                       0                
  6   256   # I.y_start
 -1       0                       0                       0                
  2   272   # I.y
  0       0                       0                       0                
  3   256   # I.der(y)
  0       0                       0                       0                
  6   256   # D.k
  0 9.9999999999999997E-061 9.9999999999999997E-061 1.0000000000000000E+100
  6   256   # D.T
  0       1                       1                       4                
  6   258   # D.initType
  0       0                       0                       0                
  6   256   # D.x_start
 -1       0                       0                       0                
  1   280   # D.y_start
  0       0                       0                       0                
  6   256   # D.y
 -1       0                       0                       0                
  2   272   # D.x
  0       0                       0                       0                
  3   256   # D.der(x)
  0       0                       0                       0                
  6  1281   # D.zeroGain
  0       0                       0                       0                
  6   256   # Gain.k
  0       0                       0                       0                
  6   256   # Gain.u
 -1       1                       0                       0                
  1   280   # Add.k1
 -1       1                       0                       0                
  1   280   # Add.k2
 -1       1                       0                       0                
  1   280   # Add.k3


# Matrix with 6 columns defining the initial value calculation
# (columns 5 and 6 are not utilized for the calculation but are
#  reported by dymosim via dymosim -i for user convenience):
#
# column 1: Type of initial value
#           = -2: special case: for continuing simulation (column 2 = value)
#           = -1: fixed value (column 2 = fixed value)
#           =  0: free value, i.e., no restriction (column 2 = initial value)
#           >  0: desired value (column 1 = weight for optimization
#                                column 2 = desired value)
#                 use weight=1, since automatic scaling usually
#                 leads to equally weighted terms
# column 2: fixed, free or desired value according to column 1.
# column 3: Minimum value (ignored, if Minimum >= Maximum).
# column 4: Maximum value (ignored, if Minimum >= Maximum).
#           Minimum and maximum restrict the search range in initial
#           value calculation. They might also be used for scaling.
# column 5: Category of variable.
#           = 1: parameter.
#           = 2: state.
#           = 3: state derivative.
#           = 4: output.
#           = 5: input.
#           = 6: auxiliary variable.
# column 6: Data type of variable.
#           = 0: real.
#           = 1: boolean.
#           = 2: integer.
#
# Initial values are calculated according to the following procedure:
#
# - If parameters, states and inputs are FIXED, and other variables
#   are FREE, no special action takes place (default setting).
#
# - If there are only FIXED and FREE variables and the number of
#   FREE parameters, states and inputs is IDENTICAL to the number of
#   FIXED state derivatives, outputs and auxiliary variables, a non-linear
#   equation is solved to determine a consistent set of initial conditions.
#
# - In all other cases the following optimization problem is solved:
#      min( sum( weight(i)*( (value(i) - DESIRED(i))/scale(i) )^2 ) )
#   under the constraint that the differential equation is fulfilled
#   at the initial time. In most cases weight(i)=1 is sufficient, due
#   to the automatic scaling (if DESIRED(i) is not close to zero,
#   scale(i) = DESIRED(i). Otherwise, the scaling is based on the
#   nominal value (and maybe minimum and maximum values given in 
#   column 3 and 4). If these values are zero, scale(i)=1 is used).
#
char initialDescription(31,88)
Connector of Real input signal [:#(prefix=input)]
Connector of Real output signal
Gain
Time Constant of Integrator [s]
Time Constant of Derivative block [s]
The higher Nd, the more ideal the derivative block
Type of initialization [:#(type=Integer)]
Initial or guess value value for integrator output (= integrator state)
Initial or guess value for state of derivative block
Initial value of output
Gain value multiplied with input signal
Output signal connector
Integrator gain [s-1]
Type of initialization (InitialState and InitialOutput are identical) [:#(type=Integer)]
Initial or guess value of output (= state)
Connector of Real output signal
der(Connector of Real output signal)
Gains [s]
Time constants (T>0 required; T=0 is ideal derivative block) [s]
Type of initialization [:#(type=Integer)]
Initial or guess value of state
Initial value of output (= state)
Connector of Real output signal
State of block
der(State of block)
[:#(type=Boolean)]
Gain value multiplied with input signal
Input signal connector
Gain of upper input
Gain of middle input
Gain of lower input

