`func` = `f_type`, input(*)

Definition of a function.
A function in the CALC-program is a very low-level command, operating directly to the main memory of the CALC-program. If the name of the function not is defined in the main memory, command 'func' will create a new memory cell in the main memory. If the name of the function already exists in the main memory, command 'func' will overwrite the contents in the earlier defined memory cell. Variables created by the func-command are primarily mathematically oriented. Some functions can end with the letters `_init`, which means that these function-statement will only be executed in the input reading phase of the CALC-program.
First a brief summary is given of the available subcommands in func, followed by a detailed description of each subcommand.

Creates a variable which is the absolute value of another variable.

  func abs       `f_name' +-`var
  func abs_init  `f_name' +-`var

Calculates accelerations in a body-fixed system using the total force acting on the mass.
Accelerations in all three directions x, y and z are calculated in the command. The accelerations are expressed in a body-fixed coordinate system. Command accp_bodyf only handles mass type m_rigid_6 without constraints.
If your mass have constraints, please use command func accp_bodyfix instead.

The accelerations calculated by accp_bodyf do not consider structural vibration. In order to take structural vibration into consideration, the user must supply flexible mode shapes of the body in the acceleration points. Normally this is done by the preprocessor NPICK, but if the user likes to create his/hers own flexible mode shapes this can be done in command ad_acc_flex3.

  func accp_bodyf  `f_name', `mass', +-`Rp(1:3)

Calculates accelerations like func accp_bodyf but the static values from accel local_all has been removed.

Input and output data arguments are exactly as func accp_bodyf.

Calculates accelerations in a body-fixed system by derivating the speed of the mass.
Accelerations in all three directions are calculated in the command. The accelerations are expressed in a body-fixed coordinate system. Command accp_bodyfix handles all type of masses, command accp_bodyfix can also handle masses with constraints.
NOTA BENE command accp_bodyfix shall not be used if esys is defined with e_abs_bend. Because e_abs_bend contains a perfect ideal designed geometry of the transition curve, which causes high acceleration levels at the break-points between transition curves and circular curves. If you must use esys is defined with e_abs_bend, please lowpass-filter the accelerations before storing them on the .id-file.
The accelerations calculated by accp_bodyfix do not consider structural vibration. In order to take structural vibration into consideration, the user must supply flexible mode shapes of the body in the acceleration points. Normally this is done by the preprocessor NPICK, but if the user likes to create his/hers own flexible mode shapes this can be done in command ad_acc_flex3.

  func accp_bodyfix  `f_name' `mass' +-`Rp(1:3)

Add structural vibrations to a previously defined acceleration node.
Command "func ad_acc_flex3" adds structural vibration accelerations to rigid mass accelerations. Before this command can be given, rigid body acceleration nodes must be defined in command: `func acc_bodyf`, `func acc_bodyf0` or `func acc_bodyfix`.

  func ad_acc_flex3  `f_name' `m_name' (+-`)nforms (+-`)e_form(3,n)

Variables generated in the main output data field:

Input variables:

Output variables:
No output variables are created. This function only adds structural vibration accelerations to the rigid body accelerations calculated by `func acc_bodyf`, `func acc_bodyf0` or `func acc_bodyfix`.

Operations on variables.
Creates a new variable which is dependent on two input variables:

In the case f_type=`div` and abs(var2) < 1.e-30, the result will be set to 1.e30.

  func add         `f_name'=  +-`var1  +-`var2
  func cabs        `f_name'=  +-`var1  +-`var2
  func sub         `f_name'=  +-`var1  +-`var2
  func mul         `f_name'=  +-`var1  +-`var2
  func div         `f_name'=  +-`var1  +-`var2
  func power       `f_name'=  +-`var1  +-`var2
  func add_init    `f_name'=  +-`var1  +-`var2
  func sub_init    `f_name'=  +-`var1  +-`var2
  func mul_init    `f_name'=  +-`var1  +-`var2
  func div_init    `f_name'=  +-`var1  +-`var2
  func power_init  `f_name'=  +-`var1  +-`var2

Operations on the Y-vector of a memory field.
Subcommand `add_vect_scal` stands for addition of a scalar to all components in the Y-vector. Subcommand `sub_vect_scal` stands for subtraction of a scalar to all components in the Y-vector. Subcommand `mul_vect_scal` stands for multiplication of a scalar to all components in the Y-vector. Subcommand `div_vect_scal` stands for division of a scalar to all components in the Y-vector. In the case f_type=`div_vect_scal` and abs(var2) < 1.e-30, the result will be set to 1.e30.

  func add_vect_scal       `f_name' +-`field1 +-`var2
  func sub_vect_scal       `f_name' +-`field1 +-`var2
  func mul_vect_scal       `f_name' +-`field1 +-`var2
  func div_vect_scal       `f_name' +-`field1 +-`var2
  func add_vect_scal_init  `f_name' +-`field1 +-`var2
  func sub_vect_scal_init  `f_name' +-`field1 +-`var2
  func mul_vect_scal_init  `f_name' +-`field1 +-`var2
  func div_vect_scal_init  `f_name' +-`field1 +-`var2

Operations on the Y-vector of a memory field.
Subcommand `add_vect_vect` stands for addition of the Y-vectors in the two memory fields. The addition is made component by component. Subcommand `sub_vect_vect` stands for subtraction of the Y-vectors in the two memory fields. The subtraction is made component by component.

  func add_vect_vect       `f_name' +-`field1 +-`field2
  func sub_vect_vect       `f_name' +-`field1 +-`field2
  func add_vect_vect_init  `f_name' +-`field1 +-`field2
  func sub_vect_vect_init  `f_name' +-`field1 +-`field2

Calculation of trigonometric functions.
Calculates one of the trigonometric functions arc-cos, arc-sin,Acton, cosinus, sinus or tangent for the input variable `var', and stores the result in f_name. The units of the angles' are given in radians.

  func acos  `f_name' +-`var
  func asin  `f_name' +-`var
  func atan  `f_name' +-`var
  func cos   `f_name' +-`var
  func sin   `f_name' +-`var
  func tan   `f_name' +-`var

Arc-tangent function with two argument, nominator and denominator.

  func atan2       `f_name'  +-`nom  +-`denom
  func atan2_init  `f_name'  +-`nom  +-`denom

Creation of a character constant.
The character constant f_name is only given its value from fchar in the input reading phase of the calculation. The contents of f_name cannot be redefined in the calculation phase.

  func char  `f_name' fchar

Concatenates two character variables or strings.

  func char_concat2  `f_name'= fchar1 fchar2

Send a UNIX-command to the system.
The answer from the system should produce a real value, otherwise an error will occur. If the output from the system consists of several items, only the first value is feed into variable f_name.

  func command  `f_name' `command` arg1, arg2, arg3,,, etc.

Example:
File ex_sin2.tsimf shows an example of how to use "func command" for making a co-simulation. File ex_sin2.octavef show how to write a file in program octave which can be used for co-simulation.

Creation of a variable.
The variable f_name is only given its value at the input reading phase of the calculation. If any other command changes its value, it will not be restored by this function.

  func const  `f_name' +-`value

Creation of several constant variables.
The variables is only given their's value at the input reading phase of the calculation. If any other command changes their's value, it will not be restored by this function. Command const_block will continue to read new variables until command end_block, terminates the const_block-group.

  func const_block

            `f_name_1'= +-`value_1
            `f_name_2'= +-`value_2
            `f_name_3'= +-`value_3
                .            .
                .            .
            `f_name_n'= +-`value_n

       end_block

Copying of a value into a variable.
This statement copies a value from an other variable or constant, into a new variable f_name. The copying operation is performed every time the execution passes this statement.

  func copy       `f_name' +-`var
  func copy_init  `f_name' +-`var

Creates a memory field consisting of a X-vector and a Y-vector.
The X-vector is filled with numbers from 1, 2, 3,,,etc. up to npoints. All components in the Y-vector is filled with the value var1.

  func cr_mem  `f_name' +-`npoints +-`var1

Linear derivative between two points in a memory field.
The memory field must previously be defined by e.g. command func intpl_r, func cr_mem, func fifo_mem, or func fifo_mem2. If the independent variable `var' is less than x<sub>1</sub>, the derivative will be set to (y<sub>2</sub>-y<sub>1</sub>) / (x<sub>2</sub>-x<sub>1</sub>). If the independent variable `var' is greater than x_n, the derivative will be set to (y_n-y_n-1) / (x_n-x_n-1).

  func create_d      `f_name' `r_name' +-`var
  func create_dinit  `f_name' `r_name' +-`var

Creates a linear interpolated variable.
The interpolation points are read from a memory field defined in the main memory. The memory field must previously be defined by e.g. command func intpl_r, func cr_mem, func fifo_mem, or func fifo_mem2. If the input variable `var' is outside the interval x₁ to x_n, the output data will be extrapolated from the two outer points.

  func create_l      `f_name' `r_name' +-`var
  func create_linit  `f_name' `r_name' +-`var

Creates a variable interpolated with splines of third order.
The interpolation points are read from a memory field defined in the main memory. The memory field must previously be defined by e.g. command func intpl_r, func cr_mem, func fifo_mem, or func fifo_mem2. Outside of the interval x₁ to x_n `create_spline` will make a linear extrapolation.

  func create_spline      `f_name' `r_name' +-`var
  func create_splineinit  `f_name' `r_name' +-`var

Creates a variable linearly interpolated from a super memory field.
The super memory field must previously be defined in command func intpl2_r. If the input variables xvar and yvar is outside the interval x₁ to x_n and y₁ to y_n, the output data will be extrapolated from the outer points.

  func create2_l     `f_name' `r2_name' +-`xvar +-`yvar

Creates an interpolated variable from a 3-dimensional field.
The 3-dimensional field must previously be defined by e.g. command "func intpl_r3". The independent variables `var_x', `var_y' and `var_z' should be variables also defined in the main memory. On interpolation, the program seeks 8 points from the 3-dimensional field, which set up a hexahedron around the point of interpolation. To enable the command `func crehexl` to interpolate in the correct way, the following is required: The input order of the points in x-, y- and z- direction must always be in ascending sequence. The sides of the hexahedron shall be rectangular. If the interpolation point lies outside the 3-dimensional field as given in `func intpl_r3`, the value will be limited to the row of the field.

  func crehex1       `f_name' `r_name' `var_x' `var_y' `var_z'
  func crehex1_init  `f_name' `r_name' `var_x' `var_y' `var_z'

Decreases a variable's value with var.

  func decr  `f_name' +-`var

Derivation of a variable.
Creates the derivative of the variable `var' and stores the output data in f_name. The derivative is numerically calculated from the difference between the value in the present time step and the value in the previous time step, divided by the time step. This means that the derivative becomes essentially a half time step old value.

  func deriv  `f_name' var

Discretization of a variable with desired time steps.

  func discrete  `f_name' +-`in_var +-`t_discr

The discrete variable f_name will be given a stepped format appearance as it is only updated when the time passes an even multiple of t_discr. The function can be used for simulating a computer which only reads the state of a variable at certain time steps. The value of t_discr should be larger than tstep which controls the time step of the integrator.

Creates a FIFO-memory field in the main memory.
Command "func fifo_mem" will create same type of memory field as e.g. in "func intpl_r". The FIFO-memory will obtain its values from variable var at desired discrete time steps tout.
The input data to fifo_mem is read as follows:

  func fifo_mem   `f_name' +-`var (+-`)npmax (+-`)tout

Example:
From this memory field the user can create time delayed variables by interpolate in the FIFO-memory with command func create_l or func create_spline.

 func const     tdelay=  0.5                                       # Define required time delay
 func fifo_mem  bacc_mem bog_11.ay `(tdelay+0.1)/timeout` timeout  # Create FIFO-memory, npmax must be greater than tdelay/timeout
 func operp     tintpl=  time - tdelay                             # Create a variable for interpolating in bacc_mem
 func create_l  bog_11.ay.td   bacc_mem  tintpl                    # Create the time delayed variable bog_11.ay.td

Creates a FIFO-memory field in the main memory.
Command "func fifo_mem2" is very similar to "func fifo_mem". The difference between fifo_mem and fifo_mem2 is that in fifo_mem2 the user has the possibility to choose the x-variable.
The input data to fifo_mem2 is read as follows:

  func fifo_mem2  `f_name' +-`var (+-`)npmax (+-`)tout `tvariable'

Creates a FIFO-memory field in the main memory.
Command "func fifo_mem3" is very similar to "func fifo_mem2". The difference between fifo_mem2 and fifo_mem3 is that in fifo_mem3 the user has the possibility to give an initial value to the memory field.
The input data to fifo_mem3 is read as follows:

  func fifo_mem3  `f_name' +-`var (+-`)npmax (+-`)tout `tvariable' (+-`)init_val

Returns the greatest integer less than or equal to var.

  func floor `f_name' +-`var

Calculation of wheel and rail wear indexes.

  func fl_wear_w  wheel_no  mu_cp1 mu_cp2 mu_cp3

Output variables created in the main memory:

Where: $1= The number/name of the wheel. Example: 111r, 111l, 112r,,, etc.

Variable cpa_$1.Fnu is sometimes denoted Tγ.

The variables cp1_$1.FMnu, cp2_$1.FMnu and cpa_$1.FMnu corresponds to the dissipated energy in the contact surface.

The unit for all output variables are in [J/m] (energy per meter travelled distance).

Material loss

Pearce and Sherratt, Vehicle Dynamics Unit, British Rail Research, Derby (U.K), made in 1991 an investigation in how wheel material loss is correlated to Tγ (in function fl_wear_w denoted as cpa_$1.Fnu). The investigation showed the following relationsship:

Where: D= Is the wheel diameter in [mm].

Material loss according to Pearce and Sherratt, can be modeled with the following code:

##
##      Wear according to Pearce & Sherratt
##      ==========================================================
  func intpl_r  Mtrl_loss_PS= 0 0  100 25/(ro*2000)  199 25/(ro*2000)  200 84/(ro*2000)  300 203/(ro*2000)

  func create_l cpa_111l.wearPS= Mtrl_loss_PS cpa_111l.Fnu
  func create_l cpa_112l.wearPS= Mtrl_loss_PS cpa_112l.Fnu
  func create_l cpa_121l.wearPS= Mtrl_loss_PS cpa_121l.Fnu
  func create_l cpa_122l.wearPS= Mtrl_loss_PS cpa_122l.Fnu

The wear rate according to Pearce & Sherratt will be expressed in the unit [mm²/km]

For a more accurate estimation of wheel/rail wear, please look at func wr_coupl_pra3 where the wear is calculated as volume per time.

Calculation of three different wear assessments.

Please use the newer command fl_wear_w, unless you want to estimate wear as Yα (Y-force times angle of attack). where the wear is calculated as volume per unit time.

  func fl_weare1  car_no, axle_no

Output variables created in the main memory:

Where: $2= The number/name of the wheel. Example: 111r, 111l, 112r, , , etc.

Variable wYa_$2 is sometimes denoted Yα.

Variable wFny_$2 is sometimes denoted Tγ.

The variables uFMny_$2, vFMny_$2 and wFMny_$2 corresponds to the dissipated energy in the contact areas between wheel and rail.

The unit for all output variables are in [J/m] (energy per meter travelled distance).

Material loss

Pearce and Sherratt, Vehicle Dynamics Unit, British Rail Research, Derby (U.K), made in 1991 an investigation in how wheel material loss is correlated to Tγ (in function fl_weare1 denoted as wFny_$2). The investigation showed the following relationsship:

Where: D= Is the wheel diameter in [mm].

Material loss according to Pearce and Sherratt, can be modeled with the following code:

##
##      Wear according to Pearce & Sherratt
##      ==========================================================
  func intpl_r  Mtrl_loss_PS= 0 0  100 25/(ro*2000)  199 25/(ro*2000)  200 84/(ro*2000)  300 203/(ro*2000)

  func create_l cpa_111l.wearPS= Mtrl_loss_PS wFny_111l
  func create_l cpa_112l.wearPS= Mtrl_loss_PS wFny_112l
  func create_l cpa_121l.wearPS= Mtrl_loss_PS wFny_121l
  func create_l cpa_122l.wearPS= Mtrl_loss_PS wFny_122l

The wear rate according to Pearce & Sherratt will be expressed in the unit [mm²/km]

The wear on wheels and rails can be estimated in different ways. The most accurate method is to use the wheel/rail coupling wr_coupl_pra3

Defines a function whose properties is defined in an own supplied subroutine FUSER#
(# is a number between 0 and 9)

  func fuser#  `f_name' +-`arg1 +-`arg2 +-`arg3 ,,,etc.

To compile an own version of the calculation program, take the following steps:

• Install the following development packages:

  sudo apt-get install g++
  sudo apt-get install gfortran gfortran-4.7 libgfortran3 libgfortran-4.7-dev
  sudo apt-get install gfortran-doc gfortran-4.7-doc
  sudo apt-get install libreadline-dev
  sudo apt-get install libncurses5-dev
  sudo apt-get install libmotif-dev x11proto-print-dev
  sudo apt-get install libxt-dev
  sudo apt-get install libxp-dev
  sudo apt-get install libxpm-dev
  sudo apt-get install libxext-dev
  sudo apt-get install libxmu-dev libxmu-headers
  sudo apt-get install libgl1-mesa-dev
  sudo apt-get install libglu1-mesa-dev
  sudo apt-get install libxft-dev
  sudo apt-get install libxaw7-dev
  

• Make a backup copy of file $gensys/bin/gensys_calc.exe
• Move your fuser-subroutine to directory $gensys/code/calc/calc
• Give the UNIX-command make

The following FORTRAN routine can be used as a template when writing own subroutines:

*fuser0
c
      subroutine fuser0 (outvar, nargs, iadr)
c     --------------------------------------------------------------------------
      use calclib_decl_mod, only:
     &     mvar,                      ! Number of declared variables
     &     nvar,                      ! Number of read/created variables
     &     var,                       ! Main memory variables
     &     name,                      ! Main memory variable names
     &     ityp                       ! Type of variable
c     --------------------------------------------------------------------------
      implicit real(8) (a-h,o-z)
c     --------------------------------------------------------------------------
      real(8), intent(OUT) :: outvar  ! Output variable
      integer, intent( IN) :: nargs   ! Number of arguments
      integer, intent( IN) :: iadr    ! Address in memory where the arguments are located
c     --------------------------------------------------------------------------
c
c      time commons
      common /g_time/   time,   ! Current time
     &                  timold, ! The time in the last call
     &                  tdiff   ! Difference tdiff= time - timold
c
c      error commons
      common /ierfil/ ierfil    ! File code to write the error messages to
      common /ierror/ ierror    ! Indicator, if greater than 0(zero) the calculation will stop
c
      character(*), parameter :: subr= 'fuser0'
c     --------------------------------------------------------------------------

c
c      Pick up arguments from memory
c      -------------------------------
      call routine (ityp(iadr+ 0), var(iadr+ 0), arg_0, subr,istat)
      call routine (ityp(iadr+ 1), var(iadr+ 1), arg_1, subr,istat)
      call routine (ityp(iadr+ 2), var(iadr+ 2), arg_2, subr,istat)

c
c      Make calculations
c      ------------------------------------
      outvar= val1 + val2 + val3
c
c
 1000 return
      end

If output consists of more than one variable, the following trick can be used:

In your input data file, define a number of variables with command func const.

 func const arg_0= 0.             # Create variables
 func const arg_1= 0.             # Use "func const", so their values
 func const arg_2= 0.             # not will change by the function itself

Use these variables in the argument list to command func const.

func fuser0 fuser0_outp= arg_0   # Pick up the created variables
                         arg_1   # and overwrite their contents
                         arg_2 
                         . . .   other arguents

To overwrite the contents in a memory cell. Use a subroutine similar to the following file:

*fuser0
c
      subroutine fuser0 (outvar, nargs, iadr)
c     --------------------------------------------------------------------------
      use calclib_decl_mod, only:
     &     mvar,                      ! Number of declared variables
     &     nvar,                      ! Number of read/created variables
     &     var,                       ! Main memory variables
     &     name,                      ! Main memory variable names
     &     ityp                       ! Type of variable
c     --------------------------------------------------------------------------
      implicit real(8) (a-h,o-z)
c     --------------------------------------------------------------------------
      real(8), intent(OUT) :: outvar  ! Output variable
      integer, intent( IN) :: nargs   ! Number of arguments
      integer, intent( IN) :: iadr    ! Address in memory where the arguments are located
c     --------------------------------------------------------------------------
c
c      time commons
      common /g_time/   time,   ! Current time
     &                  timold, ! The time in the last call
     &                  tdiff   ! Difference tdiff= time - timold
c
c      error commons
      common /ierfil/ ierfil    ! File code to write the error messages to
      common /ierror/ ierror    ! Indicator, if greater than 0(zero) the calculation will stop
c
      character(*), parameter :: subr= 'fuser0'
c     --------------------------------------------------------------------------

c
c      Pick up arguments from memory via their addresses
c      -------------------------------------------------
      val0= var(nint(var(iadr+ 0)))
      val1= var(nint(var(iadr+ 1)))
      val2= var(nint(var(iadr+ 2)))

c
c      Make calculations
c      ------------------------------------
      outvar= val0 + val1 + val2
      if (time.ge.1.d0) val0= 1.d0
      if (time.ge.2.d0) val1= 2.d0
      if (time.ge.3.d0) val2= 3.d0

c
c	Export the results
c	------------------------------------
      var(nint(var(iadr+ 0)))= val0     ! Overwrite the values
      var(nint(var(iadr+ 1)))= val1     ! of the variables
      var(nint(var(iadr+ 2)))= val2
c
c
 1000 return
      end

Filters a variable with a high pass filter of the first order.
The initial value for the output variable f_name is equal to the initial value for variable y_name.

  func hpass1  `f_name' `y_name' +-`Fgr

Filters a variable with a high pass filter of the first order.
The initial value for the output variable f_name is always 0(zero) regardless of the initial value in variable y_name.

  func hpass1_0  `f_name' `y_name' +-`Fgr

Filters a variable with a high pass filter of the second order.
The initial value for the output variable f_name is equal to the initial value in variable y_name.

  func hpass2  `f_name' `y_name' +-`Fgr +-`set

Filters a variable with a high pass filter of the second order.
The initial value for the output variable f_name is always 0(zero) regardless of the initial value for variable y_name.

  func hpass2_0  `f_name' `y_name' +-`Fgr +-`set

Increases a variable's value with var.

  func incr  `f_name' +-`var

Truncation.
Returns var with the fractional portion of its magnitude truncated and its sign preserved.

  func int   `f_name' +-`var

Integration of a variable.
Creates the integral of the variable `var' and stores the result in f_name. The integral f_name will be integrated by the same integrator as in command tsim_param, which means that the integrated value in f_name will not be updated when the execution passes this statement. Instead f_name will be given its value when the calculation of a new time step begins.

  func integ  `f_name' +-`var

Creates a linear interpolated variable.
The points of interpolation are given in this directive. The independent variable is read from an existing variable in the main memory. The input data reading into field `intpl_l` is ended by giving a new main command according to Input data main-commands. Outside the interval x₁ - x_n `intpl_l` will make linear extrapolation from the outer points.

  func intpl_l  `f_name' `var' (+-`)x1,(+-`)y1 (+-`)x2,(+-`)y2 (+-`)x3 ...

Storing a memory field.
Directive `intpl_r` stores value-pairs in main memory for later use. E.g. interpolation with func create_l, func create_spline or controlling coordinate systems in lsys e_abs_bend. In the field f_name, every individual value is given an unique name up to number 99, which makes it possible for the user to alter an individual value during the course of the calculation by using a func-command to overwrite the values in field f_name.

  func intpl_r  f_name (+-`)x1,(+-`)y1
                       (+-`)x2,(+-`)y2
                       (+-`)x3,(+-`)y3
                       (+-`)x4 ....

Storing a 3-dimensional data field.
In directive `intpl_r3` the data is stored in a way suitable for interpolation by command func crehex1. Input data is read in one coordinate direction at a time, first all the points' x-coordinates, then all the points' y-coordinates, all the points' z-coordinates and finally all the points' values. The coordinate points and the points values are read in columns.

  func intpl_r3  f_name, np_x, np_y, np_z,
                 xp(1,1,1),    xp(2,1,1),  ...  xp(np_x,1,1)
                 xp(1,2,1),    xp(2,2,1),  ...  xp(np_x,2,1)
                   .            .                .
                   .            .                .
                 xp(1,np_y,1), xp(2,np_y,1), ... xp(np_x,np_y,1)
                 xp(1,1,2),    xp(2,1,2),    ... xp(np_x,1,2)
                   .         .             .
                   .         .             .
                 xp(1,np_y,np_z), xp(2,np_y,np_z), ... xp(np_x,np_y,np_z)


                 yp(1,1,1), yp(2,1,1), ...
                   .         .             .       yp(np_x,np_y,np_z)

                 zp(1,1,1), zp(2,1,1), ...
                   .         .             .       zp(np_x,np_y,np_z)

                 Up(1,1,1), Up(2,1,1), ...
                   .         .             .       Up(np_x,np_y,np_z)

Interpolation with spline of third order.
In the intervals x₁ - x₂ and x_n-1 - x_n the third order spline function will change into parables, outside the interval x₁ - x_n `intpl_s` will make linear extrapolation from the outer points. The interpolation points are given in this directive. The independent variable is taken from an existing variable `var'. Input data reading into `func intpl_s` will be interrupted by a new main command according to Input data main-commands.

 func intpl_s  `f_name' `var' (+-`)x1,(+-`)y1 (+-`)x2,(+-`)y2 (+-`)x3 ...

Modifies track irregularities. That previously has been defined via command func intpl_track_irr2 or func intpl_track_irr3.

 func intpl_track_irr_mod1 t_irr= (+-`)xstart (+-`)xstop `formula`

Where:

Argument t_irr can be given the following values:

For more information about track irregularities and their definition, please see the description of file extention *.trac

Examples:

1. Add a cosinus shaped dip in vertical direction on both rails.
   The pulse shall start at X-coordinate 15 [m] and end at X-coordinate 25 [m].
   The length of the pulse is 10 [m] long.
   The amplitude of the dip is 5[mm]
   

    func intpl_track_irr_mod1 t_irr2z= 15 25 ` 5 * 0.5*(1-cos(2*pi/10*(t_irr2x-15)))`
   

2. Add a cosinus shaped dip in vertical direction on only right rail.
   The pulse shall start at X-coordinate 15 [m] and end at X-coordinate 25 [m].
   The length of the pulse is 10 [m] long.
   The amplitude of the dip is 10 [mm]
   

    func intpl_track_irr_mod1 t_irr2z= 15 25 ` 5 * 0.5*(1-cos(2*pi/10*(t_irr2x-15)))`
    func intpl_track_irr_mod1 t_irr2c= 15 25 `10 * 0.5*(1-cos(2*pi/10*(t_irr2x-15)))`
   

3. Add a cosinus shaped lateral irregularity on only right rail.
   The pulse shall start at X-coordinate 10 [m] and end at X-coordinate 20 [m].
   The length of the pulse is 10 [m] long.
   The amplitude of the lateral irregularity is 10[mm]
   

    func intpl_track_irr_mod1 t_irr2y= 10 20 ` 5 * 0.5*(1-cos(2*pi/10*(t_irr2x-10)))`
    func intpl_track_irr_mod1 t_irr2g= 10 20 `10 * 0.5*(1-cos(2*pi/10*(t_irr2x-10)))`
   

Reads a track file written in trac- or trax-format into a separate memory.
Track files written in trax_wdesign-format can also be read. However the three last columns in the trax_wdesign-file will be skipped.
Lines starting with a #-character will not be read. Command intpl_track_irr2 will be reading the track data file into four data fields apart from the main memory of the program. The reason for doing this is that the program will execute more efficient if not all the information regarding track irregularities also is stored in the main memory. This command will not generate any fields in the main memory.

 func intpl_track_irr2  (+-`)xstart (+-`)xstop `file' (+-`)gauge_ends

Command `intpl_track_irr2` starts reading the file at x=xstart and stop reading when x=xstop, x is the first column of the file. At both ends of the track irregularity file command intpl_track_irr2 appends a smooth entrance and exit to the irregularities. This is done by four extra data points in the beginning and end of the data file. This smoothing process takes place over a distance of 10 [m]. In order to ensure that the vehicle will start on an ideal track, the starting position of the first axle of the first vehicle must be placed 10 [m] before the starting coordinate of the track. Lateral-, vertical- and cant- errors will be 0(zero) 10 [m] before and 10 [m] after the track. The gauge will be equal to gauge_ends 10 [m] before and 10 [m] after the track.
If the text string Ideal_track is given instead of a file name, command intpl_track_irr2 will create an ideal track without track irregularities.

Reads a track file written in trax_wdesign-format including designed track curvature.
Lines starting with a #-character will not be read. Command intpl_track_irr3 will be reading the track data file into four data fields apart from the main memory of the program. The reason for doing this is that the program will execute more efficient if not all the information regarding track irregularities also is stored in the main memory. This command will not generate any fields in the main memory.

 func intpl_track_irr3  (+-`)xstart (+-`)xstop `file' (+-`)gauge_ends
                         ro_trac_design  f_trac_design  z_trac_design

Command intpl_track_irr3 starts reading file from x=xstart until x=xstop, x is the first column of the file. At both ends of the track irregularity file command intpl_track_irr3 appends a smooth entrance and exit to the irregularities. This is done by four extra data points in the beginning and end of the data file. This smoothing process takes place over a distance of 10 [m].
In order to ensure that the vehicle will start on an ideal track, the starting position of the first axle of the first vehicle must be placed 10 [m] before xstart. Lateral-, vertical- and cant- errors will be 0(zero) 10 [m] before and 10 [m] after the track. The gauge will be equal to gauge_ends 10 [m] before and 10 [m] after the track.

In the input data parameters ro_trac_design f_trac_design z_trac_design the user can give names to the memory data fields which is used for controlling the designed track alignment. The data points for ro_trac_design, f_trac_design and z_trac_design before xstart will be given a ramp down to 0.(zero), this ramp has a length of 100 [m]. If the simulation shall start on tangent track the first axle of the train-set must be placed 100 [m] before xstart.
After xstop the memory fields ro_trac_design, f_trac_design and z_trac_design will not have any ramp. The designed curvature will continue with the same values as for x=xstop.

Stores memory fields into a super memory field.
The input memory fields can be defined in func intpl_r, func cr_mem, func fifo_mem, or func fifo_mem2.
The user can interpolate in this super memory field with the create2_l-command.

  func intpl2_r  f_name (+-`)x1, field1
                        (+-`)x2, field2
                        (+-`)x3, field3
                        (+-`)x4  ....

Inversion of a variable.
Inverts the variable `var', and stores the output data in f_name. If the variable `var' is less than 1.e-30, f_name is set to 1.e30.

  func inv       `f_name' +-`var
  func inv_init  `f_name' +-`var

Collects a number of wheel/rail-geometry functions and writes them in intpl2_r-format.
This function is especially designed for the creation of wheel/rail-geometry functions which varies along the track. How to use the function please look at the example given in analyse_r_vehicle.html.

  func kpf_variable_1  id_no, Xcoord_1, kpf_func_1,
                              Xcoord_2, kpf_func_2,
                              Xcoord_3, etc.

If kpf_func_1 is the same as kpf_func_2, the wheel/rail-geometry function will be constant over the track section Xcoord_1 – Xcoord_2.

Maximum number of characters in name of wheel/rail-geometry function is 9.

Sets the lower limit of a variable.
If the value in f_name is less than var, the value of f_name will be set to var.

  func l_lim       `f_name' +-`var
  func l_lim_init  `f_name' +-`var

Filters a variable with a low pass filter of the first order.
The initial value for the output variable f_name is equal to the initial value for variable y_name.

  func lpass1  `f_name' `y_name' +-`Fgr

Filters a variable with a low pass filter of the first order.
The initial value for the output variable f_name is always 0(zero) regardless of the initial value in variable y_name.

  func lpass1_0  `f_name' `y_name' +-`Fgr

Filters a variable with a low pass filter of the second order.
The initial value for the output variable f_name is equal to the initial value in variable y_name.

  func lpass2  `f_name' `y_name' +-`Fgr +-`set

Filters a variable with a low pass filter of the second order.
The initial value for the output variable f_name is always 0(zero) regardless of the initial value for variable y_name.

  func lpass2_0  `f_name' `y_name' +-`Fgr +-`set

A second order low pass filter similar to lpass2.
Filter lpass2q is not accurate as lpass2, but it is much faster because the integration does not take place in the integrator defined in tsim_param. Instead filter lpass2q has an own integrator.

A second order low pass filter similar to lpass2_0.
Filter lpass2q_0 is not accurate as lpass2_0, but it is much faster because the integration does not take place in the integrator defined in tsim_param. Instead filter lpass2q_0 has an own integrator.

The maximum value of two or more variables.

  func max       `f_name'  +-`var1, +-`var2, +-`var3,,, etc
  func max_init  `f_name'  +-`var1, +-`var2, +-`var3,,, etc

Calculates the mean value of a memory field.
The memory field must previously be defined by e.g. command func intpl_r, func cr_mem, func fifo_mem, or func fifo_mem2.

  func mean_r       `x_mean' `y_mean' `field'
  func mean_r_init  `x_mean' `y_mean' `field'

Calculates the mean value of a memory field.
The memory field must previously be defined by e.g. command func intpl_r, func cr_mem, func fifo_mem, or func fifo_mem2. Command mean_r2 has two more arguments compared to mean_r above. In the two extra arguments the user has the possibility to select a range where the evaluation of the mean value shall take place.

  func mean_r2       `x_mean' `y_mean' `field' +-`x_start +-`x_stop
  func mean_r2_init  `x_mean' `y_mean' `field' +-`x_start +-`x_stop

The minimum value of two or more variables.

  func min       `f_name'  +-`var1, +-`var2, +-`var3,,, etc
  func min_init  `f_name'  +-`var1, +-`var2, +-`var3,,, etc

Picks up the min-value in a memory field.
The memory field must previously be defined by e.g. command func intpl_r, func cr_mem, func fifo_mem, or func fifo_mem2.

  func min_r       `x_min' `y_min' `field'
  func min_r_init  `x_min' `y_min' `field'

Picks up the min-value in a memory field.
The memory field must previously be defined by e.g. command func intpl_r, func cr_mem, func fifo_mem, or func fifo_mem2. Command min_r2 has two more arguments compared to min_r above. In the two extra arguments the user has the possibility to select a range where the evaluation of the min value shall take place.

  func min_r2       `x_min' `y_min' `field' +-`x_start +-`x_stop
  func min_r2_init  `x_min' `y_min' `field' +-`x_start +-`x_stop

Calculates the remainder on dividing var1 by var2.
The output is calculated according to:   f_name= var1 - int(var1/var2)*var2
Where int(x)= integer part of x.
The result of mod is undefined if var2=0.

  func mod       `f_name' +-`var1 +-`var2
  func mod_init  `f_name' +-`var1 +-`var2

Nearest integer.
Returns var with the fractional portion of its magnitude eliminated by rounding to the nearest whole number and with its sign preserved.

  func nint   `f_name' +-`var

Creates a variable which is based on several algebraic operations in sequence.
The variables included can be variables or data constants. On execution of the statement, priority is given to multiplication and division over addition and subtraction. Should the user require the operations to be executed in a different order, this can be done with the use of parentheses. The number of parenthesis levels is limited to max. 101 levels. Reading of input data into 'func operp', will continue until a new main command according to Input data main-commands has been read. The command "func operp" has the abbreviation "fo", which the user can use to reduce the text mass in the input data file. Similarly, the command "func operp_init" can be abbreviated to "foi".

  func operp       `f_name' +-`var1 `oper1` +-`var2 `oper2` ...
  func operp_init  `f_name' +-`var1 `oper1` +-`var2 `oper2` ...

Nota Bene! A delimiter must be used between every `var and `oper`. A delimiter is a space, tab, or a comma. The number of parenthesis levels is limited to max. 101 levels.

Calculates the position of a point in a mass.
The point's coordinates refer to origin in the lsys coordinate system, to which the mass belong. The coordinates of the point is stored in the following three variables: f_name.x, f_name.y and f_name.z.

  func pos_rlsys1  `f_name' `mass' +-`Rp(1:3)

Calculates the position of a point in a mass.
The position of the point refers to a local coordinate system defined in argument `lsys'. However, the local coordinate system linked to the body 'mass' and 'lsys' must both be linked to the same Euler system. The coordinates of the point is stored in the following three variables: f_name.x, f_name.y and f_name.z.

  func pos_rlsys2  `f_name' `mass' `lsys' +-`Rp(1:3)

Is very similar to func pos_rlsys2. In addition to func pos_rlsys2 this command handles coordinate systems that belong to other Euler coordinate systems. Information about input and output data, please read under func pos_rlsys2

Creation of a variable.
The variable f_name is only given its value at the input reading phase of the calculation. If any other command changes its value, it will not be restored by this function.

The value of the variable is automatically choosen in order to minimize the derivatives of all equations in the model. The main purpose of this function is to automatically calculate vertical prestess forces in springs.

  func preload_init  `f_name'

Prints the value of a variable to ASCII-file.
The value is printed at every time step. The command can be useful in e.g. error detection if an error does not appear in the initial phase, but appears after a number of time steps. In order to limit the amount of printing, the command "func print_all" can be placed within if_then statements, enabling the printing to begin when a condition has been fulfilled.

  func print_all  `f_name' filecode

Prints the value of a variable to ASCII-file.
The value is only printed during the initial phase of the calculation.

  func print_init  `f_name' filecode

Prints the value of a variable to standard output, when running program QUASI.
The value is printed at time=tstart but after program QUASI has found a quasistatical solution.

  func print_quasi `f_name' filecode

Prints the value of a variable to standard output.
The value is printed at every time step. The command can be useful in e.g. error detection if an error does not appear in the initial phase, but appears after a number of time steps. In order to limit the amount of printing, the command "func print06_all" can be placed within if_then statements, enabling the printing to begin when a condition has been fulfilled.

  func print06_all  `f_name'

Prints the value of a variable to standard output.
The value is only printed during the initial phase of the calculation.

  func print06_init  `f_name'

Prints the value of a variable to standard output, when running program QUASI.
The value is printed at time=tstart but after program QUASI has found a quasistatical solution.

  func print06_quasi `f_name'

Prints a text string to standard output.
The text string is printed at every time step.

  func print06_char_all  text

Prints a text string to standard output.
The text string is only printed during the initial phase of the calculation.

  func print06_char_init  text

Calculation of a fatigue indexes for rolling contact environments.
The fatigue indexes are calculated according to the theories presented in the paper "An engineering model for prediction of rolling contact fatigue of railway wheels" written by Anders Ekberg, Elena Kabo, and Hans Andersson, October 29, 2001.
In the paper "An engineering model for prediction of rolling contact fatigue of railway wheels", three fatigue indexes are suggested: FPs="Surface fatigue index", FPb="Subsurface fatigue index" and FPd="Deep defects fatigue index". See the theory manual
In addition to the theories given in the paper, RCF index FPs and FPb are attenuated if the energy dissipation is high in the contact areas. In order to use this function please first calculate the energy dissipation in the contact surfaces with command func fl_wear_w. The two arguments Tgamma_bp1 and Tgamma_bp2 defines how RCF index FPs and FPb are attenuated.

  func rolling_fatigue_3 f_name  wheel
       Yield_stress_shear    Dang_Van_param     Residual_stress
       Tgamma_bp1 Tgamma_bp2 Contact_force_llim
       Tgam_cp1   Tgam_cp2   Tgam_cp3

As mentioned above Wear can be estimated in many different ways. E.g. Energy Dissipation, Tgamma(similar to Energy Dissipation but with no consideration to spin moment), Total Creepage or according to Archard's Law, The values given in Wear_bp1, Wear_bp2, Wear_cp1, Wear_cp2 and Wear_cp3, must all be given in the same unit. The effect on the RCF-indexes f_name.FPs1, f_name.FPs2 and f_name.FPs3 follows the following graph:

If Wear is less than Wear_bp1 means that the wear is negligible which implies that f_name.FPs#= f_name.FIs#. If Wear is greater than Wear_bp2 means that the wear rate is larger than the crack growth, which implies that f_name.FPs# will be less or equal to 0. If Wear is between Wear_bp1 and Wear_bp2 means that the RCF index f_name.FPs# is gradually attenuated.

Transfers the sign of one number to another.
Creates a new variable which is based on two inputs "var1" and "var2". The result is the value of "var1" with the sign of "var2". If "var1" is 0, the result is neither positive or negative. If "var2" is 0, the result is positive.

  func sign2       `f_name' +-`var1 +-`var2
  func sign2_init  `f_name' +-`var1 +-`var2

Call a shared object created by Simulink.
Where the value of "#" is any number between 1-9. The name of the shared object shall be simulink_control#.so and it shall be located at project level. I.e. the level from where the programs in Gensys are launched.

  func simulink_control#  +-`TimeStep_Simulink
                noutput   +-`output(1:noutput)
                ninput    +-`input (1:ninput)

Scalar multiplication of two memory fields.
Command smul_vect_vect multiplies the Y-vectors in the two memory fields field1 and field2. The result is stored in variable f_name.

  func smul_vect_vect       `f_name' +-`field1 +-`field2
  func smul_vect_vect_init  `f_name' +-`field1 +-`field2

Calculates the square root.
If the variable var is less than 0, the absolute value of var will be used as argument in the square root calculation.

  func sqrt       `f_name' +-`var
  func sqrt_init  `f_name' +-`var

When this statement is passed the program will stop its execution, with exit status 0.
If the statement is placed in an if_then - endif - group, the user can let any variable control the stop-criteria for the calculation.

  func stop

When this statement is passed the program will stop its execution, with exit status 1.
Stops the calculation when the statement is passed.
If the statement is placed in an if_then - endif - group, the user can let any variable control the stop-criteria for the calculation.

  func stop_error

Sends a command to the UNIX-system.
The output of the command must be a real or integer value.
The value is only evaluated during the input data reading phase. Later during the simulation command "func system_init" will leave the value of f_name untouched.

  func system_init f_name "UNIX-command"

E.g.:

To find the end of a track file (plus 10[m] for the ramp that the commands func intpl_track_irr2 and func intpl_track_irr3 are adding to the track irregularities).

Function for creating track irregularity variables.
In the coupling coupl creep_lookuptable_1 track irregularities are read from variables. These variables must be created by interpolation in the track irregularity fields. Function tral_interp_spline do the spline interpolation and the output are four variables ready to give as input to the coupling coupl creep_lookuptable_1.

If the track irregularity memory fields has been created manually they must have the names: lat_trac, spv_trac, vert_trac and fi_trac. If the track irregularity memory fields has been created by using the commands func intpl_track_irr2 or func intpl_track_irr3, command tral_interp_spline will find the memory fields automatically.

  func tral_interp_spline #axl

Sets the upper limit of a variable.
If the value in f_name exceeds var, the value of f_name will be set to var.

  func u_lim       `f_name' +-`var
  func u_lim_init  `f_name' +-`var

Update a value in the mass matrix.
In order to activate this function the user must first give command `update_mass_matrix`.

  func  update_mass `mass' `dire` +-`weight

Convenience function which connects a wheelset to a vehicle following track-piece. The function is very similar to wr_coupl_pe3. In addition to wr_coupl_pe3, function wr_coupl_pe0 handles speeds down to zero velocity, by gradually switching to Coulomb friction.

When using this wheel-rail coupling the wheelsets must have degrees of freedom in pitch rotation.

Function wr_coupl_pe0 share the same set of input data as wr_coupl_pe3. For an explanation of the input data parameters please go to wr_coupl_pe3.

Connects wheels or a wheelset to the track.
In function wr_coupl_pe3 the rails are modeled as massless masses. The stiffness normal to the wheel/rail contact surface is defined in variable knwr. The rails are connected to the track via springs and dampers: kyrt, cyrt, kzrt and czrt. Three different contact surfaces can be in contact simultaneously. The calculations of creep forces are made in a lookup table calculated by Fasim.
In order to further reduce the amount of input data in the users input data file this function can be called via the substructure wr_coupl_pe3.ins or wr_coupl_pe3_whe.ins.

  func wr_coupl_pe3
#
  $1                                         # Name/number of the wheelset
  lsa_$1                                     # Name of the linear local coordinate system
#
  lat_trac vert_trac spv_trac fi_trac        # Track irregularities memory fields
  YMtrac   ZMtrac    GMtrac   CMtrac         # Multiplication factors for track irregularities
  gauge_average                              # Average gauge of spv_trac
  gauge_dev_$1                               # Modify average gauge for a different conicity
  pknwr                                      # Type of contact normal to the contact surface
#
  whe_$1r                                    # Body wheel right side
  whe_$1l                                    # Body wheel left side
  trc_$1                                     # Body track right side
  trc_$1                                     # Body track left side
  ro_$1r                                     # Nominal wheel radius right wheel
  kyrt_$1r                                   # Lateral stiffness rail - track right wheel
  kzrt_$1r                                   # Vertical stiffness rail - track right wheel
  kzrt.F0_$1r                                # Vertical prestress force rail - track right wheel
  cyrt_$1r                                   # Lateral damping rail - track right wheel
  czrt_$1r                                   # Vertical damping rail - track right wheel
  bo_$1r                                     # Lateral semi-distance to nominal running circle  right wheel
  ro_$1l                                     # Nominal wheel radius left wheel
  kyrt_$1l                                   # Lateral stiffness rail - track left wheel
  kzrt_$1l                                   # Vertical stiffness rail - track left wheel
  kzrt.F0_$1l                                # Vertical prestress force rail - track left wheel
  cyrt_$1l                                   # Lateral damping rail - track left wheel
  czrt_$1l                                   # Vertical damping rail - track left wheel
  bo_$1l                                     # Lateral semi-distance to nominal running circle left wheel
#
  cp1_$1r                                    # Name of contact point #1 right side
  trc_$1  cp1_$1r.ksi cp1_$1r.bo cp1_$1r.za  # Body track
  whe_$1r cp1_$1r.xa  cp1_$1r.bo cp1_$1r.za  # Body wheel/wheelset
  mu_$1r1                                    # Coefficient of friction
  cp1_$1r.E  cp1_$1r.nu                      # Modulus of elasticity and Poisson's ratio
  cp1_$1r.factx cp1_$1r.facty cp1_$1r.facts  # Creepage reduction due to contaminated rail surface
  cp1_$1r.knwr.F0  cp1_$1r.knwr              # Prestress force and stiffness normal to the surface
#
  cp1_$1l                                    # Name of contact point #1 left side
  trc_$1  cp1_$1l.ksi cp1_$1l.bo cp1_$1l.za  # Body track
  whe_$1l cp1_$1l.xa  cp1_$1l.bo cp1_$1l.za  # Body wheel/wheelset
  mu_$1l1                                    # Coefficient of friction
  cp1_$1l.E  cp1_$1l.nu                      # Modulus of elasticity and Poisson's ratio
  cp1_$1l.factx cp1_$1l.facty cp1_$1l.facts  # Creepage reduction due to contaminated rail surface
  cp1_$1l.knwr.F0  cp1_$1l.knwr              # Prestress force and stiffness normal to the surface
#
  cp2_$1r                                    # Name of contact point #2 right side
  trc_$1  cp2_$1r.ksi cp2_$1r.bo cp2_$1r.za  # Body track
  whe_$1r cp2_$1r.xa  cp2_$1r.bo cp2_$1r.za  # Body wheel/wheelset
  mu_$1r2                                    # Coefficient of friction
  cp2_$1r.E  cp2_$1r.nu                      # Modulus of elasticity and Poisson's ratio
  cp2_$1r.factx cp2_$1r.facty cp2_$1r.facts  # Creepage reduction due to contaminated rail surface
  cp2_$1r.knwr.F0  cp2_$1r.knwr              # Prestress force and stiffness normal to the surface
#
  cp2_$1l                                    # Name of contact point #2 left side
  trc_$1  cp2_$1l.ksi cp2_$1l.bo cp2_$1l.za  # Body track
  whe_$1l cp2_$1l.xa  cp2_$1l.bo cp2_$1l.za  # Body wheel/wheelset
  mu_$1l2                                    # Coefficient of friction
  cp2_$1l.E  cp2_$1l.nu                      # Modulus of elasticity and Poisson's ratio
  cp2_$1l.factx cp2_$1l.facty cp2_$1l.facts  # Creepage reduction due to contaminated rail surface
  cp2_$1l.knwr.F0  cp2_$1l.knwr              # Prestress force and stiffness normal to the surface
#
  cp3_$1r                                    # Name of contact point #3 right side
  trc_$1  cp3_$1r.ksi cp3_$1r.bo cp3_$1r.za  # Body track
  whe_$1r cp3_$1r.xa  cp3_$1r.bo cp3_$1r.za  # Body wheel/wheelset
  mu_$1r3                                    # Coefficient of friction
  cp3_$1r.E  cp3_$1r.nu                      # Modulus of elasticity and Poisson's ratio
  cp3_$1r.factx cp3_$1r.facty cp3_$1r.facts  # Creepage reduction due to contaminated rail surface
  cp3_$1r.knwr.F0  cp3_$1r.knwr              # Prestress force and stiffness normal to the surface
#
  cp3_$1l                                    # Name of contact point #3 left side
  trc_$1  cp3_$1l.ksi cp3_$1l.bo cp3_$1l.za  # Body track
  whe_$1l cp3_$1l.xa  cp3_$1l.bo cp3_$1l.za  # Body wheel/wheelset
  mu_$1l3                                    # Coefficient of friction
  cp3_$1l.E  cp3_$1l.nu                      # Modulus of elasticity and Poisson's ratio
  cp3_$1l.factx cp3_$1l.facty cp3_$1l.facts  # Creepage reduction due to contaminated rail surface
  cp3_$1l.knwr.F0  cp3_$1l.knwr              # Prestress force and stiffness normal to the surface

If one of the follwing variables exists in main memory, they will also be used as input data. If the variable not can be found in input data its default value will be used.

no_warning func const rails_$1_free= 1
constr fix_free_1  ral_$1l.y= 0.
constr fix_free_1  ral_$1r.y= 0.
constr fix_free_1  ral_$1l.z= 0.
constr fix_free_1  ral_$1r.z= 0.

Connects a wheelset to the track.
The function is very similar to wr_coupl_pe3, but having only two simultanious contact areas. In addition to wr_coupl_pe3, function wr_coupl_pe4 handles varying rail profiles along the track.

In function wr_coupl_pe4 the rails are modeled as massless masses. The stiffness normal to the wheel/rail contact surface is defined in variable knwr. The rails are connected to the track via springs and dampers: kyrt, cyrt, kzrt and czrt. Two different contact surfaces can be in contact simultaneously. The calculations of creep forces are made in a lookup table calculated by Fasim.

  func wr_coupl_pe4   $1
#
  cp1_$1r                               # Name of contact point #1 right side
  trc_$1                                # Name of body track
  cp1_$1r.ksi cp1_$1r.bo cp1_$1r.za     # Attachment point body track
  axl_$1                                # Name of body wheelset
  cp1_$1r.xa  cp1_$1r.bo cp1_$1r.za     # Attachment point body wheelset
  Not_used                              # Redundant input data variable
  cp1_$1r.fzwr                          # Normal contact force 
  cp1_$1r.gam                           # Angle of contact point in roll direction.
  cp1_$1r.nux cp1_$1r.nuy cp1_$1r.spin  # Creepages in contact point
  cp1_$1r.irx cp1_$1r.iry               # Long. and lat. curvatures in contact point
  mu_$1r1                               # Coefficient of friction
  { mulf_$1r1 | mu_$1r1/0.6 }           # Creepage reduction due to contaminated rail surface   
  { mulf_$1r1 | mu_$1r1/0.6 }           # In longitudinal, lateral and                          
  { mulf_$1r1 | mu_$1r1/0.6 }           # spin direction                                        
  cp1_$1r.E cp1_$1r.nu cp1_$1r.dire     # Modulus of elasticity and Poisson's ratio
#
  cp1_$1l                               # Name of contact point #1 left side
  trc_$1                                # Name of body track
  cp1_$1l.ksi cp1_$1l.bo  cp1_$1l.za    # Attachment point body track
  axl_$1                                # Name of body wheelset
  cp1_$1l.xa  cp1_$1l.bo  cp1_$1l.za    # Attachment point body wheelset
  Not_used                              # Redundant input data variable
  cp1_$1l.fzwr                          # Normal contact force 
  cp1_$1l.gam                           # Angle of contact point in roll direction.
  cp1_$1l.nux cp1_$1l.nuy cp1_$1l.spin  # Creepages in contact point
  cp1_$1l.irx  cp1_$1l.iry              # Long. and lat. curvatures in contact point
  mu_$1l1                               # Coefficient of friction
  { mulf_$1l1 | mu_$1l1/0.6 }           # Creepage reduction due to contaminated rail surface   
  { mulf_$1l1 | mu_$1l1/0.6 }           # In longitudinal, lateral and                          
  { mulf_$1l1 | mu_$1l1/0.6 }           # spin direction                                        
  cp1_$1l.E cp1_$1l.nu cp1_$1l.dire     # Modulus of elasticity and Poisson's ratio
#
  cp2_$1r                               # Name of contact point #2 right side
  trc_$1                                # Name of body track
  cp2_$1r.ksi cp2_$1r.bo cp2_$1r.za     # Attachment point body track
  axl_$1                                # Name of body wheelset
  cp2_$1r.xa  cp2_$1r.bo cp2_$1r.za     # Attachment point body wheelset
  Not_used                              # Redundant input data variable
  cp2_$1r.fzwr                          # Normal contact force 
  cp2_$1r.gam                           # Angle of contact point in roll direction.
  cp2_$1r.nux cp2_$1r.nuy cp2_$1r.spin  # Creepages in contact point
  cp2_$1r.irx cp2_$1r.iry               # Long. and lat. curvatures in contact point
  mu_$1r2                               # Coefficient of friction
  { mulf_$1r2 | mu_$1r2/0.6 }           # Creepage reduction due to contaminated rail surface  
  { mulf_$1r2 | mu_$1r2/0.6 }           # In longitudinal, lateral and                         
  { mulf_$1r2 | mu_$1r2/0.6 }           # spin direction                                       
  cp2_$1r.E cp2_$1r.nu cp2_$1r.dire     # Modulus of elasticity and Poisson's ratio
#
  cp2_$1l                               # Name of contact point #2 left side
  trc_$1                                # Name of body track
  cp2_$1l.ksi cp2_$1l.bo  cp2_$1l.za    # Attachment point body track
  axl_$1                                # Name of body wheelset
  cp2_$1l.xa  cp2_$1l.bo  cp2_$1l.za    # Attachment point body wheelset
  Not_used                              # Redundant input data variable
  cp2_$1l.fzwr                          # Normal contact force 
  cp2_$1l.gam                           # Angle of contact point in roll direction.
  cp2_$1l.nux cp2_$1l.nuy cp2_$1l.spin  # Creepages in contact point
  cp2_$1l.irx  cp2_$1l.iry              # Long. and lat. curvatures in contact point
  mu_$1l2                               # Coefficient of friction
  { mulf_$1l2 | mu_$1l2/0.6 }           # Creepage reduction due to contaminated rail surface   
  { mulf_$1l2 | mu_$1l2/0.6 }           # In longitudinal, lateral and                          
  { mulf_$1l2 | mu_$1l2/0.6 }           # spin direction                                        
  cp2_$1l.E cp2_$1l.nu cp2_$1l.dire     # Modulus of elasticity and Poisson's ratio

Function wr_coupl_pe4 also require that the follwing variables exists in main memory:

If one or more of the follwing variables exists in main memory, they will also be used as input data. If the variable not can be found in input data its default value will be used.

no_warning func const rails_$1_free= 1
constr fix_free_1  ral_$1l.y= 0.
constr fix_free_1  ral_$1r.y= 0.
constr fix_free_1  ral_$1l.z= 0.
constr fix_free_1  ral_$1r.z= 0.

Connects a wheelset to the track.
On top of the track ballast two massless rails are created. The rails are connected to the track ballast with springs and dampers: kyrt, kzrt, cyrt and czrt. Up to 3 concurrent contact patches between wheels and rails are taking into consideration. The normal problem (contact forces) are solved in stiffnesses perpendicular to the contact surfaces: knwr. The tangential problem (creep forces) are calculated by prof J.J. Kalkers simplified method routine Fasim.

  func wr_coupl_pr3
#
  $1                                         # Name/number of the wheelset
  lsa_$1                                     # Name of the linear local coordinate system
#
  lat_trac  vert_trac  spv_trac  fi_trac     # Track irregularities memory fields
  YMtrac    ZMtrac     GMtrac    CMtrac      # Multiplication factors for track irregularities
  gauge_average                              # Average gauge of spv_trac
  gauge_dev_$1                               # Modify average gauge for a different conicity
  pknwr                                      # Type of contact normal to the contact surface
#
  whe_$1r                                    # Body wheel right side
  whe_$1l                                    # Body wheel left side
  trc_$1                                     # Body track right side
  trc_$1                                     # Body track left side
#
#                                            # Right wheel:
  ro_$1r                                     # Nominal wheel radius
  kyrt_$1r                                   # Lateral stiffness rail - track
  kzrt_$1r                                   # Vertical stiffness rail - track
  kzrtF0_$1r                                 # Vertical prestress force rail - track
  cyrt_$1r                                   # Lateral damping rail - track
  czrt_$1r                                   # Vertical damping rail - track
  bo_$1r                                     # Lateral semi-distance to nominal running circle
#
#                                            # Left wheel:
  ro_$1l                                     # Nominal wheel radius
  kyrt_$1l                                   # Lateral stiffness rail - track
  kzrt_$1l                                   # Vertical stiffness rail - track
  kzrtF0_$1l                                 # Vertical prestress force rail - track
  cyrt_$1l                                   # Lateral damping rail - track
  czrt_$1l                                   # Vertical damping rail - track
  bo_$1l                                     # Lateral semi-distance to nominal running circle
#
  cp1_$1r                                    # Name of contact point #1 right side
  trc_$1  cp1_$1r.ksi cp1_$1r.bo cp1_$1r.za  # Contact on track
  whe_$1r cp1_$1r.xa  cp1_$1r.bo cp1_$1r.za  # Contact on wheel/wheelset
  cp1_$1r.m  cp1_$1r.n                       # Size of gitter in contact point
  mu_$1r1                                    # Coefficient of friction in stick zone
  G_$1r1     nu_$1r1                         # Modulus of rigidity G and Poisson's ratio nu
  mu_slip$1r1                                # Coefficient of friction in slip zone
 { mulf_$1r1 | mu_$1r1/0.6 }                 # Creepage reduction due to contaminated rail surface
 { mulf_$1r1 | mu_$1r1/0.6 }                 # In longitudinal, lateral and
 { mulf_$1r1 | mu_$1r1/0.6 }                 # spin direction
  knwrF0_$1r1   knwr_$1r1                    # Prestress force and stiffness normal to the surface
#
  cp1_$1l                                    # Name of contact point #1 left side
  trc_$1  cp1_$1l.ksi cp1_$1l.bo cp1_$1l.za  # Contact on track
  axl_$1  cp1_$1l.ksi cp1_$1l.bo cp1_$1l.za  # Contact on wheel/wheelset
  cp1_$1l.m  cp1_$1l.n                       # Size of gitter in contact point
  mu_$1l1                                    # Coefficient of friction in stick zone
  G_$1l1     nu_$1l1                         # Modulus of rigidity G and Poisson's ratio nu
  mu_slip$1l1                                # Coefficient of friction in slip zone
 { mulf_$1l1 | mu_$1l1/0.6 }                 # Creepage reduction due to contaminated rail surface   
 { mulf_$1l1 | mu_$1l1/0.6 }                 # In longitudinal, lateral and                          
 { mulf_$1l1 | mu_$1l1/0.6 }                 # spin direction                                        
  knwrF0_$1l1   knwr_$1l1                    # Prestress force and stiffness normal to the surface
#
#
  cp2_$1r                                    # Name of contact point #2 right side
  trc_$1  cp2_$1r.ksi cp2_$1r.bo cp2_$1r.za  # Contact on track
  axl_$1  cp2_$1r.xa  cp2_$1r.bo cp2_$1r.za  # Contact on wheel/wheelset
  cp2_$1r.m  cp2_$1r.n                       # Size of gitter in contact point
  mu_$1r2                                    # Coefficient of friction in stick zone
  G_$1r2     nu_$1r2                         # Modulus of rigidity G and Poisson's ratio nu
  mu_slip$1r2                                # Coefficient of friction in slip zone
 { mulf_$1r2 | mu_$1r2/0.6 }                 # Creepage reduction due to contaminated rail surface
 { mulf_$1r2 | mu_$1r2/0.6 }                 # In longitudinal, lateral and
 { mulf_$1r2 | mu_$1r2/0.6 }                 # spin direction
  0.            knwr_$1r2                    # Prestress force and stiffness normal to the surface
#
  cp2_$1l                                    # Name of contact point #2 left side
  trc_$1  cp2_$1l.ksi cp2_$1l.bo cp2_$1l.za  # Contact on track
  axl_$1  cp2_$1l.ksi cp2_$1l.bo cp2_$1l.za  # Contact on wheel/wheelset
  cp2_$1l.m  cp2_$1l.n                       # Size of gitter in contact point
  mu_$1l2                                    # Coefficient of friction in stick zone
  G_$1l2     nu_$1l2                         # Modulus of rigidity G and Poisson's ratio nu
  mu_slip$1l2                                # Coefficient of friction in slip zone
 { mulf_$1l2 | mu_$1l2/0.6 }                 # Creepage reduction due to contaminated rail surface
 { mulf_$1l2 | mu_$1l2/0.6 }                 # In longitudinal, lateral and
 { mulf_$1l2 | mu_$1l2/0.6 }                 # spin direction
  0.            knwr_$1l2                    # Prestress force and stiffness normal to the surface
#
#
  cp3_$1r                                    # Name of contact point #3 right side
  trc_$1  cp3_$1r.ksi cp3_$1r.bo cp3_$1r.za  # Contact on track
  axl_$1  cp3_$1r.xa  cp3_$1r.bo cp3_$1r.za  # Contact on wheel/wheelset
  cp3_$1r.m  cp3_$1r.n                       # Size of gitter in contact point
  mu_$1r3                                    # Coefficient of friction in stick zone
  G_$1r3     nu_$1r3                         # Modulus of rigidity G and Poisson's ratio nu
  mu_slip$1r3                                # Coefficient of friction in slip zone
 { mulf_$1r3 | mu_$1r3/0.6 }                 # Creepage reduction due to contaminated rail surface
 { mulf_$1r3 | mu_$1r3/0.6 }                 # In longitudinal, lateral and
 { mulf_$1r3 | mu_$1r3/0.6 }                 # spin direction
  0.            knwr_$1r3                    # Prestress force and stiffness normal to the surface
#
  cp3_$1l                                    # Name of contact point #3 left side
  trc_$1  cp3_$1l.ksi cp3_$1l.bo cp3_$1l.za  # Contact on track
  axl_$1  cp3_$1l.ksi cp3_$1l.bo cp3_$1l.za  # Contact on wheel/wheelset
  cp2_$1l.m  cp2_$1l.n                       # Size of gitter in contact point
  mu_$1l3                                    # Coefficient of friction in stick zone
  G_$1l3     nu_$1l3                         # Modulus of rigidity G and Poisson's ratio nu
  mu_slip$1l3                                # Coefficient of friction in slip zone
 { mulf_$1l3 | mu_$1l3/0.6 }                 # Creepage reduction due to contaminated rail surface   
 { mulf_$1l3 | mu_$1l3/0.6 }                 # In longitudinal, lateral and                          
 { mulf_$1l3 | mu_$1l3/0.6 }                 # spin direction                                        
  0.            knwr_$1l3                    # Prestress force and stiffness normal to the surface

G=   E   
   2(1+ν)

If one of the follwing variables exists in main memory, they will also be used as input data. If the variable not can be found in input data its default value will be used.

no_warning func const rails_$1_free= 1
constr fix_free_1  ral_$1l.y= 0.
constr fix_free_1  ral_$1r.y= 0.
constr fix_free_1  ral_$1l.z= 0.
constr fix_free_1  ral_$1r.z= 0.

The wheel/rail-coupling that calculates the contact patch forces for this function.

Connects a wheelset to the rails similar to func wr_coupl_pr3.
Evaluation of wear is made according to Archard's wear law, which is applied to each element in the contact zone(s).

Archard's wear law:

 W= k N·v
       H 

  Where: W= Volume wear per second [m3/s]
         k= Wear coefficient [-]
         N= Normal force [N]
         v= Sliding speed [m/s]
         H= The hardness of the softer material in Vickers [N/m2] 

Input data:

  func wr_coupl_pra3
#
  $1                                         # Name/number of the wheelset
  lsa_$1                                     # Name of the linear local coordinate system
#
  lat_trac  vert_trac  spv_trac  fi_trac     # Track irregularities memory fields
  YMtrac    ZMtrac     GMtrac    CMtrac      # Multiplication factors for track irregularities
  gauge_average                              # Average gauge of spv_trac
  gauge_dev_$1                               # Modify average gauge for a different conicity
  pknwr                                      # Type of contact normal to the contact surface
#
  whe_$1r                                    # Body wheel right side
  whe_$1l                                    # Body wheel left side
  trc_$1                                     # Body track right side
  trc_$1                                     # Body track left side
#
#                                            # Right wheel:
  ro_$1r                                     # Nominal radius
  kyrt_$1r                                   # Lateral stiffness rail - track
  kzrt_$1r                                   # Vertical stiffness rail - track
  kzrtF0_$1r                                 # Vertical prestress force rail - track
  cyrt_$1r                                   # Lateral damping rail - track
  czrt_$1r                                   # Vertical damping rail - track
  bo_$1r                                     # Lateral semi-distance to nominal running circle, right side
#
#                                            # Left wheel:
  ro_$1l                                     # Nominal radius
  ro_$1l                                     # Nominal wheel radius left wheel
  kyrt_$1l                                   # Lateral stiffness rail - track
  kzrt_$1l                                   # Vertical stiffness rail - track
  kzrtF0_$1l                                 # Vertical prestress force rail - track
  cyrt_$1l                                   # Lateral damping rail - track
  czrt_$1l                                   # Vertical damping rail - track
  bo_$1l                                     # Lateral semi-distance to nominal running circle, left side
#
#                                            # Archard's Wear Chart
  H                                          # Hardness in Vickers [N/m2]
  V1  V2  V3                                 # Speeds separating different regions of the wear chart
  p1  p2                                     # Pressures separating different regions of the wear chart
  k11 k12 k13 k14                            #
  k21 k22 k23 k24                            # Wear coefficients for the different wear regions
  k31 k32 k33 k34                            #
#
  cp1_$1r                                    # Name of contact point #1 right side
  trc_$1  cp1_$1r.ksi cp1_$1r.bo cp1_$1r.za  # Contact on track
  whe_$1r cp1_$1r.xa  cp1_$1r.bo cp1_$1r.za  # Contact on wheel/wheelset
  cp1_$1r.m  cp1_$1r.n                       # Size of gitter in contact point
  mu_$1r1                                    # Coefficient of friction in stick zone
  G_$1r1     nu_$1r1                         # Modulus of rigidity G and Poisson's ratio nu
  mu_slip$1r1                                # Coefficient of friction in slip zone
 { mulf_$1r1 | mu_$1r1/0.6 }                 # Creepage reduction due to contaminated rail surface
 { mulf_$1r1 | mu_$1r1/0.6 }                 # In longitudinal, lateral and
 { mulf_$1r1 | mu_$1r1/0.6 }                 # spin direction
  knwrF0_$1r1   knwr_$1r1                    # Prestress force and stiffness normal to the surface
#
  cp1_$1l                                    # Name of contact point #1 left side
  trc_$1  cp1_$1l.ksi cp1_$1l.bo cp1_$1l.za  # Contact on track
  axl_$1  cp1_$1l.ksi cp1_$1l.bo cp1_$1l.za  # Contact on wheel/wheelset
  cp1_$1l.m  cp1_$1l.n                       # Size of gitter in contact point
  mu_$1l1                                    # Coefficient of friction in stick zone
  G_$1l1     nu_$1l1                         # Modulus of rigidity G and Poisson's ratio nu
  mu_slip$1l1                                # Coefficient of friction in slip zone
 { mulf_$1l1 | mu_$1l1/0.6 }                 # Creepage reduction due to contaminated rail surface   
 { mulf_$1l1 | mu_$1l1/0.6 }                 # In longitudinal, lateral and                          
 { mulf_$1l1 | mu_$1l1/0.6 }                 # spin direction                                        
  knwrF0_$1l1   knwr_$1l1                    # Prestress force and stiffness normal to the surface
#
#
  cp2_$1r                                    # Name of contact point #2 right side
  trc_$1  cp2_$1r.ksi cp2_$1r.bo cp2_$1r.za  # Contact on track
  axl_$1  cp2_$1r.xa  cp2_$1r.bo cp2_$1r.za  # Contact on wheel/wheelset
  cp2_$1r.m  cp2_$1r.n                       # Size of gitter in contact point
  mu_$1r2                                    # Coefficient of friction in stick zone
  G_$1r2     nu_$1r2                         # Modulus of rigidity G and Poisson's ratio nu
  mu_slip$1r2                                # Coefficient of friction in slip zone
 { mulf_$1r2 | mu_$1r2/0.6 }                 # Creepage reduction due to contaminated rail surface
 { mulf_$1r2 | mu_$1r2/0.6 }                 # In longitudinal, lateral and
 { mulf_$1r2 | mu_$1r2/0.6 }                 # spin direction
  0.            knwr_$1r2                    # Prestress force and stiffness normal to the surface
#
  cp2_$1l                                    # Name of contact point #2 left side
  trc_$1  cp2_$1l.ksi cp2_$1l.bo cp2_$1l.za  # Contact on track
  axl_$1  cp2_$1l.ksi cp2_$1l.bo cp2_$1l.za  # Contact on wheel/wheelset
  cp2_$1l.m  cp2_$1l.n                       # Size of gitter in contact point
  mu_$1l2                                    # Coefficient of friction in stick zone
  G_$1l2     nu_$1l2                         # Modulus of rigidity G and Poisson's ratio nu
  mu_slip$1l2                                # Coefficient of friction in slip zone
 { mulf_$1l2 | mu_$1l2/0.6 }                 # Creepage reduction due to contaminated rail surface
 { mulf_$1l2 | mu_$1l2/0.6 }                 # In longitudinal, lateral and
 { mulf_$1l2 | mu_$1l2/0.6 }                 # spin direction
  0.            knwr_$1l2                    # Prestress force and stiffness normal to the surface
#
#
  cp3_$1r                                    # Name of contact point #3 right side
  trc_$1  cp3_$1r.ksi cp3_$1r.bo cp3_$1r.za  # Contact on track
  axl_$1  cp3_$1r.xa  cp3_$1r.bo cp3_$1r.za  # Contact on wheel/wheelset
  cp3_$1r.m  cp3_$1r.n                       # Size of gitter in contact point
  mu_$1r3                                    # Coefficient of friction in stick zone
  G_$1r3     nu_$1r3                         # Modulus of rigidity G and Poisson's ratio nu
  mu_slip$1r3                                # Coefficient of friction in slip zone
 { mulf_$1r3 | mu_$1r3/0.6 }                 # Creepage reduction due to contaminated rail surface
 { mulf_$1r3 | mu_$1r3/0.6 }                 # In longitudinal, lateral and
 { mulf_$1r3 | mu_$1r3/0.6 }                 # spin direction
  0.            knwr_$1r3                    # Prestress force and stiffness normal to the surface
#
  cp3_$1l                                    # Name of contact point #3 left side
  trc_$1  cp3_$1l.ksi cp3_$1l.bo cp3_$1l.za  # Contact on track
  axl_$1  cp3_$1l.ksi cp3_$1l.bo cp3_$1l.za  # Contact on wheel/wheelset
  cp2_$1l.m  cp2_$1l.n                       # Size of gitter in contact point
  mu_$1l3                                    # Coefficient of friction in stick zone
  G_$1l3     nu_$1l3                         # Modulus of rigidity G and Poisson's ratio nu
  mu_slip$1l3                                # Coefficient of friction in slip zone
 { mulf_$1l3 | mu_$1l3/0.6 }                 # Creepage reduction due to contaminated rail surface   
 { mulf_$1l3 | mu_$1l3/0.6 }                 # In longitudinal, lateral and                          
 { mulf_$1l3 | mu_$1l3/0.6 }                 # spin direction                                        
  0.            knwr_$1l3                    # Prestress force and stiffness normal to the surface

Input data to function wr_coupl_pra3 is very similar to wr_coupl_pr3 The only difference is that in wr_coupl_pra3 the user have the possibility to define a wear chart. The user must supply the following values:

Output variables:

Output data variables created by wr_coupl_pra3 are the same as the data created by wr_coupl_pr3. In addition to wr_coupl_pr3 also the following variables are created:

Output file:
After finishing an execution in program tsim, command func wr_coupl_pra3 will create a file named ["id/" $IDENT "_pra3.m" ]. The file will contain the wear distribution over the surface of the wheel. The wear distribution is expressed in the unit [m³/s].

Connects a wheelset to the rails similar to func wr_coupl_pr3.
Evaluation of wear is made according to a supplied wear rate function, which is applied to each element in the contact zone(s).

The wear rate function shall be defined via a so called memory field.
Example:

  func intpl_r WearRate=
                    0.                   0.              # Wear rate in m^3/(m*m^2)           
                   10.4e6               55.e-3/8000
                   77.2e6               55.e-3/8000                               
               1e6+77.2e6  (61.9e-9*1e6+55.e-3)/8000                              

Input data:

  func wr_coupl_prs3
#
  $1                                         # Name/number of the wheelset
  lsa_$1                                     # Name of the linear local coordinate system
#
  lat_trac  vert_trac  spv_trac  fi_trac     # Track irregularities memory fields
  YMtrac    ZMtrac     GMtrac    CMtrac      # Multiplication factors for track irregularities
  gauge_average                              # Average gauge of spv_trac
  gauge_dev_$1                               # Modify average gauge for a different conicity
  pknwr                                      # Type of contact normal to the contact surface
#
  whe_$1r                                    # Body wheel right side
  whe_$1l                                    # Body wheel left side
  trc_$1                                     # Body track right side
  trc_$1                                     # Body track left side
#
#                                            # Right wheel:
  ro_$1r                                     # Nominal wheel radius
  kyrt_$1r                                   # Lateral stiffness rail - track
  kzrt_$1r                                   # Vertical stiffness rail - track
  kzrtF0_$1r                                 # Vertical prestress force rail - track
  cyrt_$1r                                   # Lateral damping rail - track
  czrt_$1r                                   # Vertical damping rail - track
  bo_$1r                                     # Lateral semi-distance to nominal running circle
#
#                                            # Left wheel:
  ro_$1l                                     # Nominal wheel radius
  ro_$1l                                     # Nominal wheel radius left wheel
  kyrt_$1l                                   # Lateral stiffness rail - track
  kzrt_$1l                                   # Vertical stiffness rail - track
  kzrtF0_$1l                                 # Vertical prestress force rail - track
  cyrt_$1l                                   # Lateral damping rail - track
  czrt_$1l                                   # Vertical damping rail - track
  bo_$1l                                     # Lateral semi-distance to nominal running circle
#
  WearRate                                   # Memory field defined via e.g. func intpl_r
#
  cp1_$1r                                    # Name of contact point #1 right side
  trc_$1  cp1_$1r.ksi cp1_$1r.bo cp1_$1r.za  # Contact on track
  whe_$1r cp1_$1r.xa  cp1_$1r.bo cp1_$1r.za  # Contact on wheel/wheelset
  cp1_$1r.m  cp1_$1r.n                       # Size of gitter in contact point
  mu_$1r1                                    # Coefficient of friction in stick zone
  G_$1r1     nu_$1r1                         # Modulus of rigidity G and Poisson's ratio nu
  mu_slip$1r1                                # Coefficient of friction in slip zone
 { mulf_$1r1 | mu_$1r1/0.6 }                 # Creepage reduction due to contaminated rail surface
 { mulf_$1r1 | mu_$1r1/0.6 }                 # In longitudinal, lateral and
 { mulf_$1r1 | mu_$1r1/0.6 }                 # spin direction
  knwrF0_$1r1   knwr_$1r1                    # Prestress force and stiffness normal to the surface
#
  cp1_$1l                                    # Name of contact point #1 left side
  trc_$1  cp1_$1l.ksi cp1_$1l.bo cp1_$1l.za  # Contact on track
  axl_$1  cp1_$1l.ksi cp1_$1l.bo cp1_$1l.za  # Contact on wheel/wheelset
  cp1_$1l.m  cp1_$1l.n                       # Size of gitter in contact point
  mu_$1l1                                    # Coefficient of friction in stick zone
  G_$1l1     nu_$1l1                         # Modulus of rigidity G and Poisson's ratio nu
  mu_slip$1l1                                # Coefficient of friction in slip zone
 { mulf_$1l1 | mu_$1l1/0.6 }                 # Creepage reduction due to contaminated rail surface   
 { mulf_$1l1 | mu_$1l1/0.6 }                 # In longitudinal, lateral and                          
 { mulf_$1l1 | mu_$1l1/0.6 }                 # spin direction                                        
  knwrF0_$1l1   knwr_$1l1                    # Prestress force and stiffness normal to the surface
#
#
  cp2_$1r                                    # Name of contact point #2 right side
  trc_$1  cp2_$1r.ksi cp2_$1r.bo cp2_$1r.za  # Contact on track
  axl_$1  cp2_$1r.xa  cp2_$1r.bo cp2_$1r.za  # Contact on wheel/wheelset
  cp2_$1r.m  cp2_$1r.n                       # Size of gitter in contact point
  mu_$1r2                                    # Coefficient of friction in stick zone
  G_$1r2     nu_$1r2                         # Modulus of rigidity G and Poisson's ratio nu
  mu_slip$1r2                                # Coefficient of friction in slip zone
 { mulf_$1r2 | mu_$1r2/0.6 }                 # Creepage reduction due to contaminated rail surface
 { mulf_$1r2 | mu_$1r2/0.6 }                 # In longitudinal, lateral and
 { mulf_$1r2 | mu_$1r2/0.6 }                 # spin direction
  0.            knwr_$1r2                    # Prestress force and stiffness normal to the surface
#
  cp2_$1l                                    # Name of contact point #2 left side
  trc_$1  cp2_$1l.ksi cp2_$1l.bo cp2_$1l.za  # Contact on track
  axl_$1  cp2_$1l.ksi cp2_$1l.bo cp2_$1l.za  # Contact on wheel/wheelset
  cp2_$1l.m  cp2_$1l.n                       # Size of gitter in contact point
  mu_$1l2                                    # Coefficient of friction in stick zone
  G_$1l2     nu_$1l2                         # Modulus of rigidity G and Poisson's ratio nu
  mu_slip$1l2                                # Coefficient of friction in slip zone
 { mulf_$1l2 | mu_$1l2/0.6 }                 # Creepage reduction due to contaminated rail surface
 { mulf_$1l2 | mu_$1l2/0.6 }                 # In longitudinal, lateral and
 { mulf_$1l2 | mu_$1l2/0.6 }                 # spin direction
  0.            knwr_$1l2                    # Prestress force and stiffness normal to the surface
#
#
  cp3_$1r                                    # Name of contact point #3 right side
  trc_$1  cp3_$1r.ksi cp3_$1r.bo cp3_$1r.za  # Contact on track
  axl_$1  cp3_$1r.xa  cp3_$1r.bo cp3_$1r.za  # Contact on wheel/wheelset
  cp3_$1r.m  cp3_$1r.n                       # Size of gitter in contact point
  mu_$1r3                                    # Coefficient of friction in stick zone
  G_$1r3     nu_$1r3                         # Modulus of rigidity G and Poisson's ratio nu
  mu_slip$1r3                                # Coefficient of friction in slip zone
 { mulf_$1r3 | mu_$1r3/0.6 }                 # Creepage reduction due to contaminated rail surface
 { mulf_$1r3 | mu_$1r3/0.6 }                 # In longitudinal, lateral and
 { mulf_$1r3 | mu_$1r3/0.6 }                 # spin direction
  0.            knwr_$1r3                    # Prestress force and stiffness normal to the surface
#
  cp3_$1l                                    # Name of contact point #3 left side
  trc_$1  cp3_$1l.ksi cp3_$1l.bo cp3_$1l.za  # Contact on track
  axl_$1  cp3_$1l.ksi cp3_$1l.bo cp3_$1l.za  # Contact on wheel/wheelset
  cp2_$1l.m  cp2_$1l.n                       # Size of gitter in contact point
  mu_$1l3                                    # Coefficient of friction in stick zone
  G_$1l3     nu_$1l3                         # Modulus of rigidity G and Poisson's ratio nu
  mu_slip$1l3                                # Coefficient of friction in slip zone
 { mulf_$1l3 | mu_$1l3/0.6 }                 # Creepage reduction due to contaminated rail surface   
 { mulf_$1l3 | mu_$1l3/0.6 }                 # In longitudinal, lateral and                          
 { mulf_$1l3 | mu_$1l3/0.6 }                 # spin direction                                        
  0.            knwr_$1l3                    # Prestress force and stiffness normal to the surface

Input data to function wr_coupl_prs3 is very similar to wr_coupl_pr3 the only difference is WearRate.
Input to the WearRate function is Tγ/A. Where "T" is the tangential force on every "brush", and γ is the sliding speed divided with the reference speed of the wheel in every "brush". "A" equals the area of each "brush" (dx*dy). The WearRate function is evaluated for all "brushes" in contact and the sum of all wear from all "brushes" is stored in variable cpx_.wear

Output variables:

Output data variables created by wr_coupl_prs3 are the same as for wr_coupl_pr3.
In addition to wr_coupl_pr3 also the following variables are created: