Home    Search    Up    Reference Manuals    Return    Calc Menu    Input Data Menu



`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.

`abs`, `abs_init` Calculates the absolute value of a variable.
`accp_bodyf` Calculates accelerations in a body-fixed system using the total force acting on the mass.
`accp_bodyf0` Calculates accelerations like func accp_bodyf but without static acceleration values.
`accp_bodyfix` Calculates accelerations in a body-fixed system by derivating the speed of the mass.
`acos`, `acos_init` The arc-cosinus function.
`ad_acc_flex3` Addition of acceleration from modal shapes.
`add`, `add_init` Addition of two variables.
`add_vect_scal`, `add_vect_scal_init` Adds a memory field with the value of a variable.
`add_vect_vect`, `add_vect_vect_init` Adds two memory fields.
`asin`, `asin_init` The arc-sinus function.
`atan`, `atan_init` The arc-tangent function.
`atan2`,`atan2_init` Arc-tangent function with two argument.
`cabs`, `cabs_init` Calculates the complex absolute value of two variables.
`char` Creates a character constant in the memory.
`char_concat2` Concatenates two character variables or strings.
`command` Send a command to the system.
`const` Creates a constant in the memory.
`const_block` Creates several constants in the memory.
`copy`, `copy_init` Copies a variable to a new variable.
`cos`, `cos_init` The cosinus function.
`cr_mem` Creates a memory field consisting of a X-vector and a Y-vector.
`create_d`, `create_dinit` Calculates the derivative between points in a field.
`create_l`, `create_linit` Creates a linear interpolated variable.
`create_spline`, `create_splineinit` Creates a spline interpolated variable.
`create2_l` Creates a variable linearly interpolated from a super memory field.
`crehex1`, `crehex1_init` Creates an interpolated variable out of a 3-dimensional field.
`decr`, `decr_init` Reduces a variable's value with another value.
`deriv` Calculates the derivative of a variable.
`discrete` Discretization of a variable with desired time steps.
`div`, `div_init` Divides two variables with each other.
`div_vect_scal`, `div_vect_scal_init` Divides a memory field with the value of a variable.
`fifo_mem` Creates a fifo memory field with time as x-variable.
`fifo_mem2` As fifo_mem, but the x-variable can be chosen by the user.
`fifo_mem3` As fifo_mem2, but with initial value.
`floor` Returns the greatest integer less than or equal to the argument.
`fl_wear_w` Calculation of energy dissipation in the contact surfaces between wheel and rail.
`fl_weare1` Calculation of different wear assessments.
`fuser#` Defines a function whose properties is defined in an own supplied subroutine FUSER# (# is a number between 0 and 9).
`hpass1` 1st ord. high pass filter, start value from input variable.
`hpass1_0` 1st ord. high pass filter, zero in start value.
`hpass2` 2nd ord. high pass filter, start value from input variable.
`hpass2_0` 2nd ord. high pass filter, zero in start value.
`incr`, `incr_init` Increases a variable's value with another value.
`int` Truncation to a whole number.
`integ` Integrates a variable.
`intpl_l` Linear interpolates a variable from several numbers.
`intpl_r` Stores pairs of numbers in a memory field, to be used by other functions.
`intpl_r3` Stores 3-dimensional memory fields, to be used by other functions.
`intpl_s` Spline interpolates a variable from several numbers.
`intpl_track_irr2` Reads a track file written in trac- or trax-format into a separate memory.
`intpl_track_irr3` Reads a track file written in trax-format including designed track curvature.
`intpl2_r` Stores memory fields into a super memory field.
`inv`, `inv_init` Inversion of a variable.
`kpf_variable_1` Collects a number of wheel/rail-geometry functions and writes them in intpl2_r-format
`l_lim`,`l_lim_init` Sets the lower limit of a variable.
`lpass1` 1st ord. low pass filter, start value from input variable.
`lpass1_0` 1st ord. low pass filter, zero in start value.
`lpass2` 2nd ord. low pass filter, start value from input variable.
`lpass2_0` 2nd ord. low pass filter, zero in start value.
`lpass2q` Fast 2nd ord. low pass filter, start value from input variable.
`lpass2q_0` Fast 2nd ord. low pass filter, zero in start value.
`max`, `max_init` The maximum value of two or more variables.
`mean_r`, `mean_r_init` Calculate the average of a memory field.
`mean_r2`, `mean_r2_init` Calculate the average of a memory field, with range selection.
`min`, `min_init` The minimum value of two or more variables.
`min_r`, `min_r_init` Picks up the min-value in a field.
`min_r2`, `min_r2_init` Picks up the min-value in a field, with range selection.
`mod`, `mod_init` Calculates the remainder.
`mul`, `mul_init` Multiply two variables with each other.
`mul_vect_scal`, `mul_vect_scal_init` Multiplies a memory field with the value of a variable.
`nint` Nearest integer.
`operp`, `operp_init` Execute algebraic operations on priority basis.
`pos_rlsys1` Calculate the position of a point on a mass.
`pos_rlsys2` Similar to pos_rlsys1 but the position is expressed in another lsys.
`pos_rlsys3` Similar to pos_rlsys2 but also handles lsys belonging to another esys.
`power`, `power_init` The power function.
`preload_init` Create a constant variable.
`print_all` Print the value of the variable to file at every time step.
`print_init` Print the value of the variable to file at time= tstart.
`print_quasi` Print the value of the variable to file when program QUASI has found the quasistatical solution.
`print06_all` Print the value of the variable at every time step.
`print06_char_all` Print the value of a character string at every time step.
`print06_char_init` Print the value of a character string at time= tstart.
`print06_init` Print the value of the variable at time=tstart.
`print06_quasi` Print the value of the variable when program QUASI has found the quasistatical solution.
`rolling_fatigue_3` Calculation of RCF-indexes, with smooth consideration taken to wear rate.
`sign2`, `sign2_init` Transfers the sign of one number to another.
`simulink_control#` Call a shared object created by Simulink.
`sin`, `sin_init` The sinus function.
`smul_vect_vect` Scalar multiplication of two memory fields.
`sqrt`, `sqrt_init` The square root function.
`stop` Stops the calculation with exit status 0.
`stop_error` Stops the calculation with exit status 1.
`sub`, `sub_init` Subtracts two variables from each other.
`sub_vect_scal, `sub_vect_scal_init` Subtracts a memory field with the value of a variable.
`sub_vect_vect, `sub_vect_vect_init` Subtracts two memory fields from each other.
`tan`, `tan_init` The tangent function.
`tral_interp_spline` Function for creating track irregularity variables.
`u_lim`, `u_lim_init` Sets the upper limit of a variable.
`update_mass` Update a value in the mass matrix.
`wr_coupl_pe0` Similar to wr_coupl_pe3, but handles vehicle speeds down to zero velocity.
`wr_coupl_pe3` Convenience function which connects a wheelset to a vehicle following track-piece. Creep forces are calculated in a lookup table.
`wr_coupl_pe4` Similar to wr_coupl_pe3 but handles varying rail profiles along the track.
`wr_coupl_pr3` Connects a wheelset to the rails; Massless rails; Creep forces calculated in Fasim.
`wr_coupl_pra3` Similar to wr_coupl_pr3. Wear is calculated according to Archard's law.
`wr_coupl_prs3` Similar to wr_coupl_pra3 but wear is calculated according to a supplied wear rate function.


Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `abs` or `abs_init`

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


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

f_name = Name of the newly created variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written.
var = Name of the input data variable.


Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `accp_bodyf`

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)

f_name = Base name for the acceleration variables.
mass = Mass in which the acceleration variables will be calculated.
Rp = Coordinates on the body where the acceleration will be calculated. X-, Y-, Z-coordinates are given in relation to the body's local coordinate system lsys.

Variables generated in the main output data field:

Input variables:
f_name.A = Acceleration coordinate in x-direction relative to lsys.
f_name.B = Acceleration coordinate in y-direction relative to lsys.
f_name.H = Acceleration coordinate in z-direction relative to lsys.

Output variables:
f_name.ax = Acceleration variable in the x-direction for the body. If variable f_name.ax already exists in the memory of the program, the old value of the variable will be overwritten.
f_name.ay = Acceleration variable in the y-direction for the body. If variable f_name.ay already exists in the memory of the program, the old value of the variable will be overwritten.
f_name.az = Acceleration variable in the z-direction for the body. If variable f_name.az already exists in the memory of the program, the old value of the variable will be overwritten.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `accp_bodyf0`

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.


Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `accp_bodyfix`

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)

f_name = Base name for the acceleration variables.
mass = Mass in which the acceleration variables will be calculated.
Rp = Coordinates on the body where the acceleration will be calculated. X-, Y-, Z-coordinates are given in relation to the body's local coordinate system lsys.

Variables generated in the main output data field:

Input variables:
f_name.A = Acceleration coordinate in x-direction relative to lsys.
f_name.B = Acceleration coordinate in y-direction relative to lsys.
f_name.H = Acceleration coordinate in z-direction relative to lsys.

Output variables:
f_name.ax = Acceleration variable in the x-direction for the body. If variable f_name.ax already exists in the memory of the program, the old value of the variable will be overwritten.
f_name.ay = Acceleration variable in the y-direction for the body. If variable f_name.ay already exists in the memory of the program, the old value of the variable will be overwritten.
f_name.az = Acceleration variable in the z-direction for the body. If variable f_name.az already exists in the memory of the program, the old value of the variable will be overwritten.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `ad_acc_flex3`

Add accelerations due to structural vibrations.
Command "func ad_acc_flex3" adds accelerations to the previously calculated body-fixed accelerations, due to structural vibrations. Before this command can be given, the rigid body accelerations must be defined, and calculated in command `func acc_bodyf` or `func acc_bodyfix`.


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

f_name = The rigid body accelerations, previously defined in `func accp_bodyf` or `func accp_bodyfix`.
m_name = The name of the body from which the accelerations originate.
nforms = The number of modal shapes which will be taken into consideration in the calculation of the accelerations. Nforms may not be greater than the number of calculated modal shapes n given in `mass m_flex_1`.
e_form(3,n) = The mass orthonormalized modal shapes which apply for this point, the coordinates of which are given in `func acc_bodyf` or `func acc_bodyfix`. The input data is given in the following order:

x1, y1, z1, The modal shape's x-,y- and z-component
x2, y2, z2, for modal shape 1 to n.
. . .
. . .
xn, yn, zn,

Variables generated in the main output data field:

Input variables:
f_name.x1 = The modal shape's x-component for modal shape 1
f_name.y1 = The modal shape's y-component for modal shape 1
f_name.z1 = The modal shape's z-component for modal shape 1
f_name.x2 = The modal shape's x-component for modal shape 2
f_name.y2 = The modal shape's y-component for modal shape 2
  . =   . . . . . . . . .
  . =   . . . . . . . . .
  . =   . . . . . . . . .
f_name.zn = The modal shape's x-component for modal shape 1

Output variables:

No output variables are created, this function transfers the acceleration variables that have been created in the command `func acc_bodyf` or `func acc_bodyfix`.


Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `add`, `cabs`, `sub`, `mul`, `div`, `power`,
`add_init`, `cabs_init`, `sub_init`, `mul_init`, `div_init` or `power_init`


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

 `add` = addition
 `cabs` = complex absolute value
 `sub` = subtraction
 `div` = division
 `power` = raises var1 to the value of var2

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

f_name = Name of the newly created variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
var1 = Name of the first input variable or constant.
var2 = Name of the second input variable or constant.


Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `add_vect_scal`, `sub_vect_scal`, `mul_vect_scal`, `div_vect_scal`, `add_vect_scal_init`, `sub_vect_scal_init`, `mul_vect_scal_init` or `div_vect_scal_init`

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

f_name = Name of the newly created memory field. If variable f_name already exists in memory, its values will be replaced by this command, and a warning message will be written on standard output.
field1 = Name of the memory field.
var2 = Name of the scalar which is an ordinary variable in the memory of the program


Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `add_vect_vect`, `sub_vect_vect`, `add_vect_vect_init` or `sub_vect_vect_init`

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

f_name = Name of the newly created memory field. If variable f_name already exists in memory, its values will be replaced by this command, and a warning message will be written on standard output.
field1 = Name of memory field number 1.
field2 = Name of memory field number 2.


Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `acos`, `asin`, `atan`, `cos`, `sin` or `tan`

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

f_name = Name of the newly created variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
var = Name of the input variable or constant.


Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `atan2` or `atan2_init`

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


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

f_name = Name of the newly created variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written.
nom = Nominator.
denom = Denominator.


Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `char`

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

f_name = Name of the created character variable. If variable f_name already exists in memory, its value will be replaced, and a warning message will be written to standard output.
fchar = The character string which the variable f_name is given. The character string may contain a maximum of 24 characters. The string may not contain the delimiters = , <space> or <tab>, as these will interrupt the string.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `char_concat2`

Concatenates two character variables or strings.


  func char_concat2  `f_name'= fchar1 fchar2

f_name = Name of the created character variable. If variable f_name already exists in memory, its value will be replaced, and a warning message will be written to standard output.
fchar1 = Character variable or string number 1. Character strings must be enclosed in double quotation marks.
fchar2 = Character variable or string number 2. Character strings must be enclosed in double quotation marks.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `command`

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.

f_name = Name of the newly created variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
command = The command to be sent to the system. The command can belong to the system or it can be written by the user. The command must be in the users PATH. If the command is located in current directory and current directory is not in the users PATH, this can be fixed by writing the characters ./ before the filename. The characters ./ indicates the search path to the program. Check also that the command-file has execute permission, if not please write: "chmod 755 command" in a xterm-window.
arg# = Arguments to be sent after the UNIX-command. If the argument is a variable defined in the GENSYS-model, program CALC will replace the character string arg# with its value calculated by program CALC. If the argument is a valid main command to program CALC, further input data reading will be interrupted.
If the argument is an unknown character string, program CALC will make an warning-printout in the beginning of the calculation. In the calculations later, program CALC will send the character string as it is without any substitutions.

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.


Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `const`

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

f_name = Name of the newly created variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
value = The value which the variable f_name will be given.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `const_block`

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

f_name = Name of the newly created variables. If variable f_name_? already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
value = The value which the variable f_name_? will be given.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `copy` or 'copy_init'

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

f_name = Name of the newly created variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
var = The value which the variable f_name will be given.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `cr_mem'

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

f_name = Name of the newly created memory field. If variable f_name already exists in memory, the calculation stops and an error will be written to the terminal.
npoints = Number of components of the X- and Y-vector.
var1 = The value which will fill the Y-vector.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `create_d` or `create_dinit`

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 x1, the derivative will be set to (y2-y1) / (x2-x1). If the independent variable `var' is greater than xn, the derivative will be set to (yn-yn-1) / (xn-xn-1).


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

f_name = Name of the newly created variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
r_name = Name of the memory field, of which the derivative is to be calculated. If `r_name' is not defined in the main memory, an error will be printed and the program execution will be stopped.
var = Name of the independent input variable, which determines the interval in which the calculation of the derivative will take place. If `var' is not defined in the main memory, an error will be printed and the program execution will be stopped.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `create_l` or `create_linit`

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 x1 to xn, 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

f_name = Name of the newly created variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
r_name = Name of the memory field, of which the interpolation shall take place. If `r_name' is not defined in the main memory, an error will be printed and the program execution will be stopped.
var = Name of the independent input variable, which determines the interval in which the calculation of the derivative will take place. If `var' is not defined in the main memory, an error will be printed and the program execution will be stopped.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `create_spline` or `create_splineinit`

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 x1 to xn `create_spline` will make a linear extrapolation.



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

f_name = Name of the newly created variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
r_name = Name of the memory field, of which the interpolation shall take place. If `r_name' is not defined in the main memory, an error will be printed and the program execution will be stopped.
var = Name of the independent input variable, which determines the interval in which the calculation of the derivative will take place. If `var' is not defined in the main memory, an error will be printed and the program execution will be stopped.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `create2_l`

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 x1 to xn and y1 to yn, the output data will be extrapolated from the outer points.


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

f_name = Name of the newly created variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
r2_name = Name of the super memory field, in which the interpolation shall take place.
xvar = Name of the first independent input variable, which selects the memory field in where the interpolation shall take place.
yvar = Name of the second independent input variable, which interpolates in the memory field selected by xvar.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `crehex1` or `crehex1_init`

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'

f_name = Name of the newly created variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
r_name = Name of the 3-dimensional field, of which the interpolation shall take place. If `r_name' is not defined in the main memory, an error will be printed and the program execution will be stopped.
var_x = Name of the independent x-variable, which governs the interpolation in the 3-dimensional field. If the variable var_x is not defined, the execution of the program will be interrupted.
var_y = Name of the independent y-variable, which governs the interpolation in the 3-dimensional field. If the variable var_y is not defined, the execution of the program will be interrupted.
var_z = Name of the independent z-variable, which governs the interpolation in the 3-dimensional field. If the variable var_z is not defined, the execution of the program will be interrupted.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `decr`

Decreases a variable's value with var.


  func decr  `f_name' +-`var

f_name = Name of the variable, of which the value will be decreased. The f_name must be defined, otherwise an error will occur.
var = Input variable or constant which will be subtracted from f_name.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `deriv`

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

f_name = Name of the newly created variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
var = Name of the input data variable. Must be of the type variable otherwise an error will occur.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `discrete`

Discretization of a variable with desired time steps.


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

f_name = Name of the new discretized variable. If f_name is already defined, the existing output data will be replaced by this command, and a warning message will be written on standard output.
in_var = Name of input data variable which will be made discreet.
t_discr = Steps of discretion.

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.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `fifo_mem`

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

f_name = Name of the FIFO-memory where the `var' will be stored. If the name is already defined, an error will occur.
var = Name of the variable which will be stored in the fifo memory. The variable must be defined, otherwise an error will occur.
npmax = The number of value pairs which can be stored in the memory field f_name.
tout = Time step between the occasions of storage in the fifo memory.

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  100 0.01     # create FIFO-memory, OBS npmax*tout greater than tdelay
 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


Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `fifo_mem2'

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'

f_name = Name of the FIFO-memory where the `var' will be stored. If the name is already defined, an error will occur.
var = Name of the variable which will be stored in the fifo memory. The variable must be defined, otherwise an error will occur.
npmax = The number of value pairs which can be stored in the memory field f_name.
tout = Time step between the occasions of storage in the fifo memory.
tvariable = Variable for the time axle. The variable must be defined otherwise an error will occur.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `fifo_mem3'

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

f_name = Name of the FIFO-memory where the `var' will be stored. If the name is already defined, an error will occur.
var = Name of the variable which will be stored in the fifo memory. The variable must be defined, otherwise an error will occur.
npmax = The number of value pairs which can be stored in the memory field f_name.
tout = Time step between the occasions of storage in the fifo memory.
tvariable = Variable for the time axle. The variable must be defined otherwise an error will occur.
init_val = Initial value which the memory field will be filled with before the simulation starts.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `floor`

Returns the greatest integer less than or equal to var.


  func floor `f_name' +-`var

f_name = Name of the newly created variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
var = Name of the input data variable.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `fl_wear_w'

Calculation of wheel and rail wear indexes.


  func fl_wear_w  wheel_no  mu_cp1 mu_cp2 mu_cp3

wheel_no = Number/name of the wheel to be evaluated. Example: 111r, 111l, 112r, , , etc.
mu_cp1 = Coefficient of friction on contact surface cp1, for calculation of spin moment.
mu_cp2 = Coefficient of friction on contact surface cp2, for calculation of spin moment.
mu_cp3 = Coefficient of friction on contact surface cp3, for calculation of spin moment.

Output variables created in the main memory:

cp1_$1.Fnu = Creep * creepforce, contact surface #1
cp2_$1.Fnu = Creep * creepforce, contact surface #2
cp3_$1.Fnu = Creep * creepforce, contact surface #3
cpa_$1.Fnu = Creep * creepforce, sum of all contact surfaces
cp1_$1.FMnu = Creep * creepforce + spin*spinmoment, contact surface #1
cp2_$1.FMnu = Creep * creepforce + spin*spinmoment, contact surface #2
cp3_$1.FMnu = Creep * creepforce + spin*spinmoment, contact surface #3
cpa_$1.FMnu = Creep * creepforce + spin*spinmoment, sum of all contact surfaces

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:

PearceSherratt.png

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 [mm2/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.


Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `fl_weare1'

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

car_no = Number/name of the vehicle. Example: 1, 2, 3, , etc.
axle_no = Number/name of the axle to be evaluated. Example: 111, 112, , , etc.

Output variables created in the main memory:

uYa_$2  =  Lateral guiding force * angle of attack  (tread contact cpt)
uFny_$2  =  Creep * creepforce   (tread contact cpt)
uFMny_$2  =  Creep*creepforce + spin*spinmoment   (tread contact cpt)

vYa_$2  =  Lateral guiding force * angle of attack   (flange contact cpf)
vFny_$2  =  Creep * creepforce   (flange contact cpf)
vFMny_$2  =  Creep*creepforce + spin*spinmoment   (flange contact cpf)

wYa_$2  =  Lateral guiding force * angle of attack   (tread and flange)
wFny_$2  =  Creep * creepforce   (tread and flange)
wFMny_$2  =  Creep*creepforce + spin*spinmoment   (tread and flange)

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:

PearceSherratt.png

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 [mm2/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

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `fuser#`

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.

f_name = Name of the output variable. If f_name is already defined, the existing output data will be replaced by this command, and a warning message will be written on standard output.
arg1 = Argument #1.
arg2 = Argument #2.
arg3 = Argument #3. etc.

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



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

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `hpass1`

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

f_name = Name of the filtered variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
y_name = The input variable which shall be filtered. Y_name must be defined otherwise an error will occur and the program will be terminated
Fgr = The cut-off frequency in [Hz].

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `hpass1_0`

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

f_name = Name of the filtered variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
y_name = The input variable which shall be filtered. Y_name must be defined otherwise an error will occur and the program will be terminated
Fgr = The cut-off frequency in [Hz].

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `hpass2`

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

f_name = Name of the filtered variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
y_name = The input variable which shall be filtered. Y_name must be defined otherwise an error will occur and the program will be terminated
Fgr = The cut-off frequency in [Hz].
set = Fraction of critical damping.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `hpass2_0`

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

f_name = Name of the filtered variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
y_name = The input variable which shall be filtered. Y_name must be defined otherwise an error will occur and the program will be terminated
Fgr = The cut-off frequency in [Hz].
set = Fraction of critical damping.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `incr`

Increases a variable's value with var.


  func incr  `f_name' +-`var

f_name = Name of the variable, of which the value will be increased. The f_name must be defined, otherwise an error will occur.
var = Input variable or constant which will be added to f_name.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `int`

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


  func int   `f_name' +-`var

f_name = Name of the newly created variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
var = Name of the input data variable.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `integ`

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

f_name = Name of the newly created variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
var = Name of the input data variable.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `intpl_l`

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 x1 - xn `intpl_l` will make linear extrapolation from the outer points.


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

f_name = Name of the newly created variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
var = Name of the input data variable. Must be of the type variable otherwise an error will occur.
x1,y1 = Point number 1
x2,y2 = Point number 2 etc.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `intpl_r`

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 ....

f_name = Name of the memory field memory.
x1,y1 = Value pair number 1
x2,y2 = Value pair number 2

Variables generated in the main output data field:
f_name.x1 = x-value point number 1
f_name.y1 = y-value point number 1
f_name.x2 = x-value point number 2
f_name.y2 = y-value point number 2
f_name.x3 = x-value point number 3 ... etc.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `intpl_r3`

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)

f_name = Name of the 3-dimensional field.
np_x = Number of points in the x-direction.
np_y = Number of points in the y-direction.
np_z = Number of points in the z-direction.
xp(1,1,1) - xp(np_x,np_y,np_z) = All the field's x-coordinates.
yp(1,1,1) - yp(np_x,np_y,np_z) = All the field's y-coordinates.
zp(1,1,1) - zp(np_x,np_y,np_z) = All the field's z-coordinates.
Up(1,1,1) - Up(np_x,np_y,np_z) = The field's values in the coordinates listed above.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `intpl_s`

Interpolation with spline of third order.
In the intervals x1 - x2 and xn-1 - xn the third order spline function will change into parables, outside the interval x1 - xn `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 ...

f_name = Name of the newly created variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
var = Name of the input data variable. Must be of the type variable otherwise an error will occur.
x1,y1 = Point number 1
x2,y2 = Point number 2 etc.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `intpl_track_irr2`

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.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `intpl_track_irr3`

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_design fi_design z_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_design fi_design z_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_design, fi_design and z_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_design, fi_design and z_design will not have any ramp. The designed curvature will continue with the same values as for x=xstop.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `intpl2_r`

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  ....

f_name = Name of the generated super memory field.
x1, field1 = X-value and memory field #1
x2, field2 = X-value and memory field #2

Variables generated in the main output data field:

f_name.x1 = X-value point number 1
f_name.y1 = Address to memory field #1
f_name.x2 = X-value point number 2
f_name.y2 = Address to memory field #2
f_name.x3 = X-value point number 3 ... etc.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `inv` or `inv_init`

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

f_name = Name of the newly created variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
var = Name of the input data variable or data constant.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `kpf_variable_1`

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.

id_no = Ident of this series.
If the ident number consists of three digits plus the letter "r" or "l", program CALC will consider the ident as being the name of a wheel.
If the ident consists of three digits, program CALC will consider the ident as being the number of an axle.
If the ident consists of only one digit, program CALC will consider the ident as being the number of a vehicle, and as a result giving all axles in that vehicle the same wheel/rail-geometry functions.
If the ident consists of a space " ", program CALC will consider the ident as being the name of the whole train-set.
When program CALC searches for the wheel/rail-geometry functions it primarily searches for profiles ending with the letters "r" or "l". I.e. the profiles in program KPF are defined in WRFILE, WLFILE, RRFILE and RLFILE. Secondly program CALC searches for wheel/rail-geometry functions having the same shape on the right and left side of the wheelset. I.e. the profiles in program KPF are defined in HFIL and RFIL.
Xcoord_1,kpf_func_1= First X-coordinate along the track, with corresponding wheel/rail-geometry function.
Xcoord_2,kpf_func_2= Second X-coordinate along the track, with corresponding wheel/rail-geometry function.

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.


Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `l_lim` or `l_lim_init`

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

f_name = Name of the variable which shall be limited. F_name must be defined, otherwise an error will occur.
var = Input variable or data constant which defines the lower limit.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `lpass1`

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

f_name = Name of the filtered variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
y_name = The input variable which shall be filtered. Y_name must be defined otherwise an error will occur and the program will be terminated
Fgr = The cut-off frequency in [Hz].

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `lpass1_0`

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

f_name = Name of the filtered variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
y_name = The input variable which shall be filtered. Y_name must be defined otherwise an error will occur and the program will be terminated
Fgr = The cut-off frequency in [Hz].

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `lpass2`

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

f_name = Name of the filtered variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
y_name = The input variable which shall be filtered. Y_name must be defined otherwise an error will occur and the program will be terminated
Fgr = The cut-off frequency in [Hz].
set = Fraction of critical damping.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `lpass2_0`

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

f_name = Name of the filtered variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
y_name = The input variable which shall be filtered. Y_name must be defined otherwise an error will occur and the program will be terminated
Fgr = The cut-off frequency in [Hz].
set = Fraction of critical damping.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `lpass2q`

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.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `lpass2q_0`

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.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `max`, `max_init`

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


f_name = Name of the newly created variable. If f_name already is defined, its old contents will be overwritten.
var1 = Constant or variable #1
var2 = Constant or variable #2
var3 = Constant or variable #3

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `mean_r`, `mean_r_init`

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'

x_mean = Name of the newly created variable. The value of the variable contains the mean value of the x-vector in `field'. If x-mean is already defined, it will be overwritten by this command, and a warning message will be written on standard output.
y_mean = Name of the newly created variable. The value of the variable contains the mean value of the y-vector in `field'. If y-mean is already defined, it will be overwritten by this command, and a warning message will be written on standard output.
field = Name of the memory field, from which the average value will be calculated.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `mean_r2`, `mean_r2_init`

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

x_mean = Name of the newly created variable. The value of the variable contains the mean value of the x-vector in `field'. If x-mean is already defined, it will be overwritten by this command, and a warning message will be written on standard output.
y_mean = Name of the newly created variable. The value of the variable contains the mean value of the y-vector in `field'. If y-mean is already defined, it will be overwritten by this command, and a warning message will be written on standard output.
field = Name of the memory field, from which the average value will be calculated.
x_start = Value in vector x_mean where the evaluation shall start.
x_stop = Value in vector x_mean where the evaluation shall stop.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `min`, `min_init`

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


f_name = Name of the newly created variable. If f_name already is defined, its old contents will be overwritten.
var1 = Constant or variable #1
var2 = Constant or variable #2
var3 = Constant or variable #3

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `min_r`, `min_r_init`

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'

x_min = Name of the newly created variable. The value of the variable contains the min value of the x-vector in `field'. If x-min is already defined, it will be overwritten by this command, and a warning message will be written on standard output.
y_min = Name of the newly created variable. The value of the variable contains the min value of the y-vector in `field'. If y-min is already defined, it will be overwritten by this command, and a warning message will be written on standard output.
field = Name of the memory field, from which the average value will be calculated.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `min_r2`, `min_r2_init`

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

x_min = Name of the newly created variable. The value of the variable contains the min value of the x-vector in `field'. If x-min is already defined, it will be overwritten by this command, and a warning message will be written on standard output.
y_min = Name of the newly created variable. The value of the variable contains the min value of the y-vector in `field'. If y-min is already defined, it will be overwritten by this command, and a warning message will be written on standard output.
field = Name of the memory field, from which the average value will be calculated.
x_start = Value in vector x_min where the evaluation shall start.
x_stop = Value in vector x_min where the evaluation shall stop.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `mod`, `mod_init`

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

f_name = Name of the newly created variable. If f_name already is defined, it will be overwritten by this command, and a warning message will be written on standard output.
var1 = Name of input variable or data constant #1.
var2 = Name of input variable or data constant #2.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `nint`

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

f_name = Name of the newly created variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
var = Name of the input data variable.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `operp`, `operp_init`

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` ...

f_name = Name of the newly created variable. If f_name already is defined, it will be overwritten by this command, and a warning message will be written on standard output.
var1 = Name of input variable or data constant 1.
oper1 = Operation number 1
var2 = Name of input variable or data constant 2.
oper2 = Operation number 2

The following symbols represent permitted operations:
'+'  = Plus sign for addition.
'-'  = Minus sign for subtraction.
'*'  = Asterisk or multiplication sign for multiplication.
'/'  = Slash or division symbol for division.
'('  = Left parenthesis marking the beginning of a parenthesis.
')'  = Right parenthesis marking the end of a parenthesis.

The following functions can also be used in operp:
abs( ) = Calculates the absolute value of the argument.
floor( ) = Returns the greatest integer less than or equal to the argument.
int( ) = Truncating the argument to integer form.
nint( ) = Rounds the argument to nearest integer.
sqrt( ) = Calculates the square root of the argument.
exp( ) = Calculates the exponential function of the argument.
log( ) = Calculates the natural logarithm of the argument.
log10( ) = Calculates the common logarithm of the argument.
sin( ) = Calculates the sine of the argument.
cos( ) = Calculates the cosine of the argument.
tan( ) = Calculates the tangent of the argument.
asin( ) = Calculates the arcsine of the argument.
acos( ) = Calculates the arc-cosine of the argument.
atan( ) = Calculates the arctangent of the argument.
sinh( ) = Calculates the hyperbolic sine of the argument.
cosh( ) = Calculates the hyperbolic cosine of the argument.
tanh( ) = Calculates the hyperbolic tangent of the argument.
pow2( ) = The argument is raised to the power of 2.
pow3( ) = The argument is raised to the power of 3.
pow4( ) = The argument is raised to the power of 4.

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.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `pos_rlsys1`

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)

f_name = Base name of the position variables.
mass = Mass, in which the position variables are calculated.
Rp = Coordinates of the body where the positions will be calculated. The x-, y-, z- coordinates are given relative to the body's local coordinate system lsys.

Variables generated in the main output data field:

Input variables:
f_name.A = The points' coordinate in x-direction rel. the body's lsys.
f_name.B = The points' coordinate in y-direction rel. the body's lsys.
f_name.H = The points' coordinate in z-direction rel. the body's lsys.

Output variables:
f_name.x = The longitudinal position of the point, relative to lsys of the body.
f_name.y = The lateral position of the point, relative to lsys of the body.
f_name.z = The vertical position of the point, relative to lsys of the body.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `pos_rlsys2`

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)

f_name = Base name of the position variables.
mass = Mass, in which the position variables are calculated.
lsys = Local coordinate system in which the position variables will be expressed.
Rp = Coordinates of the body where the positions will be calculated. The x-, y-, z- coordinates are given relative to the body's local coordinate system.

Variables generated in the main output data field:

Input variables:
f_name.A = The points' coordinate in x-direction rel. the body's local coordinate system.
f_name.B = The points' coordinate in y-direction rel. the body's local coordinate system.
f_name.H = The points' coordinate in z-direction rel. the body's local coordinate system.

Output variables:
f_name.x = The longitudinal position of the point, relative to `lsys'.
f_name.y = The lateral position of the point, relative to `lsys'.
f_name.z = The vertical position of the point, relative to `lsys'.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `pos_rlsys3`

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


Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `preload_init`

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'

f_name = Name of the newly created variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `print_all`

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

f_name = Name of the variable which will be printed. Printing will be done every time the program passes the statement. In program TSIM, the statement is passed through at every time step.
filecode = File code to which the printing shall be made. A valid file code is an integer number between 61 and 99.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `print_init`

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

f_name = Name of the variable which value is to be printed.
filecode = File code to which the printing shall be made. A valid file code is an integer number between 61 and 99.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `print_quasi`

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

f_name = Name of the variable which value is to be printed.
filecode = File code to which the printing shall be made. A valid file code is an integer number between 61 and 99.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `print06_all`

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'

f_name = Name of the variable which will be printed. Printing will be executed every time the program passes through the statement. In TSIM, the statement is passed through at every time step.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `print06_init`

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'

f_name = Name of the variable which value is to be printed.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `print06_quasi`

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'

f_name = Name of the variable which value is to be printed.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `print06_char_all`

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


  func print06_char_all  text

text = Text which is to be printed. The text string is read from the first non-blank character and to the end of the line. The text string may include max. 80 characters.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `print06_char_init`

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

text = Text which is to be printed. The text string is read from the first non-blank character and to the end of the line. The text string may include max. 80 characters.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `rolling_fatigue_3`

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 Energy_dissipation_lev1 and Energy_dissipation_lev2 defines how RCF index FPs and FPb are attenuated.


  func rolling_fatigue_3 f_name  wheel
       Yield_stress_in_shear   Dang_Van_mtrl_param     Residual_stress
       Energy_dissipation_lev1 Energy_dissipation_lev2 Contact_force_llim
       Energy_dissipation_cp1  Energy_dissipation_cp2  Energy_dissipation_cp3

f_name = Basename of the created variables. Output consists of three indexes: f_name.FPs, f_name.FPb and f_name.FPd.
wheel = Wheel to be examined. For example 111r.
Yield_stress_in_shear = The value of the yield stress in pure shear.
Dang_Van_mtrl_param = Material parameter in the Dang Van criterion.
Typical value: 0.32-0.40
Residual_stress = Hydrostatic part of the residual stress at a depth of approx. 5[mm].
Recommended value: 0 [N/m2].
Energy_dissipation_lev1 = Over a certain energy dissipation, the crack growth slows down, because we also have a wear rate on the surface of wheel and rail. Under this energy level RCF index FPs and FPb is unattenuated. Recommended value: 125 [J/m].
Energy_dissipation_lev2 = Over a certain energy dissipation, the wear rate is larger than crack growth. Above this energy level RCF index FPs and FPb is set equal to -1. Recommended value: 175 [J/m].
Contact_force_llim = Lower limit of normal force. Below this limit fatigue is not considered even if the contact surface is very small.
Recommended value: 10 % of the normal quasi static wheel load.
Energy_dissipation_cp1 = Variable containing energy dissipation contact area #1. Named cp1_$1.FMnu if calculated in func fl_wear_w.
Energy_dissipation_cp2 = Variable containing energy dissipation contact area #2. Named cp2_$1.FMnu if calculated in func fl_wear_w.
Energy_dissipation_cp3 = Variable containing energy dissipation contact area #3. Named cp3_$1.FMnu if calculated in func fl_wear_w.

Name of output variables:
f_name.FPs = Surface fatigue index
f_name.FPb = Subsurface fatigue index
f_name.FPd = Deep defects fatigue index
f_name.FPs1 = Surface fatigue index, contact point cp1.
f_name.FPs2 = Surface fatigue index, contact point cp2
f_name.FPs3 = Surface fatigue index, contact point cp3
f_name.FIs1 = Surface fatigue index with no considerations taken to wear, contact point cp1
f_name.FIs2 = Surface fatigue index with no considerations taken to wear, contact point cp2
f_name.FIs3 = Surface fatigue index with no considerations taken to wear, contact point cp3
f_name.FIb1 = Subsurface fatigue index with no considerations taken to wear, contact point cp1
f_name.FIb2 = Subsurface fatigue index with no considerations taken to wear, contact point cp2
f_name.FIb3 = Subsurface fatigue index with no considerations taken to wear, contact point cp3


Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `sign2`, `sign2_init`

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

f_name = Name of the newly created variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
var1 = Name of input variable containing the value.
var2 = Name of input variable containing the sign.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `simulink_control#`

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)

TimeStep_Simulink = Timestep in shared object defined by Simulink. Must be an even multiple of tstep
noutput = Number of new variables to be created.
(output from the shared object simulink_control#.so)
output(1:noutput) = Names of the newly created variables.
(if a variable already exists in memory its old value will be overwritten)
ninput = Number of input data variables to the shared object simulink_control#.so.
input(1:ninput) = Names of the input data variables.
Only the integrators e1, heun and runge_kutta can used together with simulink_control#
Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `smul_vect_vect` or `smul_vect_vect_init`

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

f_name = Name of the newly created variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
field1 = Name of the first input memory field.
field2 = Name of the second input memory field.
Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `sqrt`, `sqrt_init`

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

f_name = Name of the newly created variable. If variable f_name already exists in memory, its value will be replaced with this command, and a warning message will be written on standard output.
var = Name of input variable or input data constant.
Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `stop`

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


Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `stop_error`

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


Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `tral_interp_spline`

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.

Before command func tral_interp_spline can be used, the following variables must be defined:
YMtrac = Multiplication factor, lateral track errors.
ZMtrac = Multiplication factor, vertical track errors.
GMtrac = Multiplication factor, gauge track errors.
CMtrac = Multiplication factor, cant track errors.
gauge_average = The average gauge of the track.
N.B. gauge_average must be given in millimeters because the track irregularity files are in millimeters.
gauge_dev_#axl = Widening or narrowing the gauge read from the memory fields. Gauge_dev shall be given in the unit meter.
bo_#axl = The lateral distance from track center line to the nominal running circle of the wheel.

  func tral_interp_spline #axl

#axl = The number of the axle.

Created variables:
tral#axl_r.y = Lateral irregularity, right rail.
tral#axl_l.y = Lateral irregularity, left rail.
tral#axl_r.z = Vertical irregularity, right rail.
tral#axl_l.z = Vertical irregularity, left rail.
tral#axl_r.vy = Lateral irregularity velocity, right rail.
tral#axl_l.vy = Lateral irregularity velocity, left rail.
tral#axl_r.vz = Vertical irregularity velocity, right rail.
tral#axl_l.vz = Vertical irregularity velocity, left rail.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `u_lim`, `u_lim_init`

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

f_name = Name of the variable which shall be limited. F_name must be defined, otherwise an error will occur.
var = Input variable or input data which defines the upper limit.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `update_mass`

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
mass = Name of the mass to be updated.
dire = Entry in the mass matrix. To modify a value along the diagonal of the mass matrix, use "xx", "yy", "zz", "ff", "kk" or "pp".
weight = The updated value.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `wr_coupl_pe0`

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.




f_type = `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.

A figure of the created track model: analyse_wr_coupl_pe3.gif

  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

$1 = Name/Number of the wheelset to be connected to the track.
lat_trac = Lateral track irregularities
vert_trac = Vertical track irregularities
gauge_trac = Gauge track irregularities
fi_trac = Cant track irregularities
YMtrac = Multiplying factor for lateral track irregularities
ZMtrac = Multiplying factor for vertical track irregularities
GMtrac = Multiplying factor for gauge irregularities
CMtrac = Multiplying factor for cant irregularities
gauge_average = Average gauge of track data. How to use gauge_average please see example in analyse_r_vehicle.html
gauge_dev_$1 = Deviation of gauge width. How to use gauge_average please see example inanalyse_r_vehicle.html
pknwr = Controls how the contact stiffnesses shall be modeled:
0= Hertzian contact stiffness
1= Linear contact stiffness
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 rolling radius of right wheel
kyrt_$1r = Lateral stiffness between rail and track right side. Recommended values see knwr_p.runf
kzrt_$1r = Vertical stiffness between rail and track right side. Recommended values see knwr_p.runf
kzrt.F0_$1r = Pre-stress force in stiffness kzrt_$1r
cyrt_$1r = Lateral damping between rail and track right side. Recommended values see knwr_p.runf
czrt_$1r = Vertical damping between rail and track right side. Recommended values see knwr_p.runf
bo_$1r = Lateral semi-distance to the nominal running circle right side (For standard gauge equal to 0.75[m])
ro_$1l = Nominal rolling radius of left wheel
kyrt_$1l = Lateral stiffness between rail and track left side. Recommended values see knwr_p.runf
kzrt_$1l = Vertical stiffness between rail and track left side. Recommended values see knwr_p.runf
kzrt.F0_$1l = Pre-stress force in stiffness kzrt_$1l
cyrt_$1l = Lateral damping between rail and track left side. Recommended values see knwr_p.runf
czrt_$1l = Vertical damping between rail and track left side. Recommended values see knwr_p.runf
bo_$1l = Lateral semi-distance to the nominal running circle left side (For standard gauge equal to -.75[m])

cp1_$1r = Name of first contact point on right wheel
trc_$1 = Body #1 in the coupling, which shall be the name of the piece of mass under the axle
cp1_$1r.ksi = Longitudinal coordinate on trc_$1 of the contact point. The variable is defined and calculated by func wr_coupl_pe3, before the call to coupling cp1_$1r is made.
cp1_$1r.bo = Lateral coordinate of the contact point. The variable is defined and calculated by func wr_coupl_pe3, before the call to coupling cp1_$1r is made.
cp1_$1r.za = Vertical coordinate of the contact point, normally equal to 0.
axl_$1 = Body #2 in the coupling, which shall be the name of the axle
cp1_$1r.xa = Longitudinal coordinate on axl_$1 of the contact point, should be equal to 0.
cp1_$1r.bo = Lateral coordinate of the contact point. The variable is defined and calculated by func wr_coupl_pe3, before the call to coupling cp1_$1r is made.
cp1_$1r.za = Vertical coordinate of the contact point, normally equal to 0.
cp1_$1r.mu = Coefficient of friction in contact point
cp1_$1r.E = Modulus of elasticity
cp1_$1r.nu = Poisson's ratio
cp1_$1r.mulfx = Long. creep relaxation factor contact point 1 right side
cp1_$1r.mulfy = Lat. creep relaxation factor contact point 1 right side
cp1_$1r.mulfs = Spin creep relaxation factor contact point 1 right side
cp1_$1r.F0 = Prestress force, normal to the contact surface
cp1_$1r.knwr = Linear contact stiffness (if pknwr=1)

cp1_$1l = Name of first contact point on left wheel
. . . . = Same set of input data as for contact point cp1_$1r above
cp2_$1r = Name of second contact point on right wheel
. . . . = Same set of input data as for contact point cp1_$1r above
cp2_$1l = Name of second contact point on left wheel
. . . . = Same set of input data as for contact point cp1_$1r above
cp3_$1r = Name of third contact point on right wheel
. . . . = Same set of input data as for contact point cp1_$1r above
cp3_$1l = Name of third contact point on left wheel
. . . . = Same set of input data as for contact point cp1_$1r above

Created output variables:
(In order to reduce the size of the table, the names of the contact points cp1_$1r, cp1_$1l, cp2_$1r,,, etc. has been replaced with cpx_)
cpx_.dr = Deviation in wheel rolling radius due to wheel/rail geometry function
cpx_.gam = Roll angle of contact area
cpx_.z = Wheel lift due to wheel/rail geometry function
cpx_.irx = Longitudinal curvature difference between wheel and rail. The variable is defined and calculated by func wr_coupl_pe3, before the call to coupling cpx_ is made.
cpx_.iry = Lateral curvature difference between wheel and rail. The variable is defined and calculated by func wr_coupl_pe3, before the call to coupling cpx_ is made.
cpx_.nux = Longitudinal creepage in contact point cpx_
cpx_.nuy = Lateral creepage in contact point cpx_
cpx_.spin = Spin creepage in contact point cpx_
cpx_.nuxm = Longitudinal creepage in contact point cpx_ reduced by factor mulfact_nux, due to contamination and asperities. The variable is defined and calculated by func wr_coupl_pe3, before the call to coupling cpx_ is made.
cpx_.nuym = Lateral creepage in contact point cpx_ reduced by factor mulfact_nuy, due to contamination and asperities. The variable is defined and calculated by func wr_coupl_pe3, before the call to coupling cpx_ is made.
cpx_.spinm = Spin creepage in contact point cpx_ reduced by factor mulfact_spin, due to contamination and asperities. The variable is defined and calculated by func wr_coupl_pe3, before the call to coupling cpx_ is made.
cpx_.ksi = The longitudinal position of the contact point on the rail. The variable is defined and calculated by func wr_coupl_pe3, before the call to coupling cpx_ is made.
cpx_.posw = The position of the contact point on the wheel, relative to the nominal running circle
cpx_.posr = The position of the contact point on the rail, relative to the nominal running circle
cpx_.bo = The lateral position of the contact point. The variable is defined and calculated by func wr_coupl_pe3, before the call to coupling cpx_ is made.
cpx_.c = Geometrical average radii of the contact ellipse, calculated according to: c= √ a · b 
cpx_.a_b = Contact ellipse a/b-ratio.
kyrt$1r.F1y = Lateral force in stiffness kyrt under right rail
kyrt$1l.F1y = Lateral force in stiffness kyrt under left rail
cyrt$1r.F1y = Lateral force in damper cyrt under right rail
cyrt$1l.F1y = Lateral force in damper cyrt under left rail
kzrt$1r.F1z = Vertical force in stiffness kzrt under right rail
kzrt$1l.F1z = Vertical force in stiffness kzrt under left rail
czrt$1r.F1z = Vertical force in damper czrt under right rail
czrt$1l.F1z = Vertical force in damper czrt under left rail
cpx_.Fn = Normal contact force
cpx_.fzwr = Normal contact force multiplied by cos(gam). The variable is defined and calculated by func wr_coupl_pe3, before the call to coupling cpx_ is made.
cpx_.Fny = Lateral force, tangential to the contact surface
cpx_.Fx = Longitudinal force, positive on rail
cpx_.Fy = Horizontal lateral force, positive on rail
cpx_.Fz = Vertical force, positive on rail
tral$1.y = Lateral track irregularities, track center line
tral$1r.y = Lateral track irregularities, right rail
tral$1l.y = Lateral track irregularities, left rail
tral$1r.z = Vertical track irregularities, right rail
tral$1l.z = Vertical track irregularities, left rail
tral$1r.vy = Lateral speed track irregularities, right rail
tral$1l.vy = Lateral speed track irregularities, left rail
tral$1r.vz = Vertical speed track irregularities, right rail
tral$1l.vz = Vertical speed track irregularities, left rail
tral$1.f = Track irregularities in roll direction
tral$1r.k = Pitch irregularities right rail
tral$1l.k = Pitch irregularities left rail
tral$1r.p = Yaw irregularities right rail
tral$1l.p = Yaw irregularities left rail
ral_$1r.y = Lateral position of the massless rail-head right
ral_$1l.y = Lateral position of the massless rail-head left
ral_$1r.vy = Lateral speed of the massless rail-head right
ral_$1l.vy = Lateral speed of the massless rail-head left
ral_$1r.z = Vertical position of the massless rail-head right
ral_$1l.z = Vertical position of the massless rail-head left
ral_$1r.vz = Vertical speed of the massless rail-head right
ral_$1l.vz = Vertical speed of the massless rail-head left

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.

Variable Description Default value
rails_$1_free It is possible to set constraints to the massless rails created by func wr_coupl_pe3
Example:
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.
0

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `wr_coupl_pe4`

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.

A figure of the created track model:

  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

$1 = Number of the axle to be evaluated.
cp1_$1r = Name of first contact point on right wheel
trc_$1 = Body #1 in the coupling, which shall be the name of the piece of mass under the axle
axl_$1 = Body #2 in the coupling, which shall be the name of the axle
cp1_$1r.ksi = Longitudinal coordinate on trc_$1 of the contact point. The variable is defined and calculated by func wr_coupl_pe4, before the call to coupling cp1_$1r is made.
cp1_$1r.xa = Longitudinal coordinate on axl_$1 of the contact point, should be equal to 0.
cp1_$1r.bo = Lateral coordinate of the contact point. The variable is defined and calculated by func wr_coupl_pe4, before the call to coupling cp1_$1r is made.
cp1_$1r.za = Vertical coordinate of the contact point, normally equal to 0.
cp1_$1r.fzwr= Normal force multiplied by cos(gam). The variable is defined and calculated by func wr_coupl_pe4, before the call to coupling cp1_$1r is made.
cp1_$1r.gam = Angle of contact point in roll direction. The variable is defined and calculated by func wr_coupl_pe4, before the call to coupling cp1_$1r is made.
cp1_$1r.nux = Longitudinal creepage in the contact point. The variable is defined and calculated by func wr_coupl_pe4, before the call to coupling cp1_$1r is made.
cp1_$1r.nuy = Lateral creepage in the contact point. The variable is defined and calculated by func wr_coupl_pe4, before the call to coupling cp1_$1r is made.
cp1_$1r.spin= Spin creepage in the contact point. The variable is defined and calculated by func wr_coupl_pe4, before the call to coupling cp1_$1r is made.
cp1_$1r.irx = Longitudinal curvature difference between wheel and rail. The variable is defined and calculated by func wr_coupl_pe4, before the call to coupling cp1_$1r is made.
cp1_$1r.iry = Lateral curvature difference between wheel and rail. The variable is defined and calculated by func wr_coupl_pe4, before the call to coupling cp1_$1r is made.
mu_$1r1 = Coefficient of friction in contact point
cp1_$1r.E = Modulus of elasticity
cp1_$1r.nu = Poisson's ratio
cp1_$1r.dire= Direction of action, must be set equal to "z".
cp1_$1l = Name of first contact point on left wheel
. . . . = Same type of input data as for contact point cp1_$1r above
cp2_$1r = Name of second contact point on right wheel
. . . . = Same type of input data as for contact point cp1_$1r above
cp2_$1l = Name of second contact point on left wheel
. . . . = Same type of input data as for contact point cp1_$1r above

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

Vo = Initial longitudinal speed of vehicle
ro_$1r, ro_$1l = Nominal rolling radius of right and left wheel respectively.
knwr_$1r, knwr_$1l = Stiffness perpendicular to the contact surface contact point #1 (tread). Recommended values see knwr_p.runf
knfr_$1r, knfr_$1l = Stiffness perpendicular to the contact surface contact point #2 (flange). Recommended values see knwr_p.runf
kyrt_$1r, kyrt_$1l = Lateral stiffness between right rail and track. Recommended values see knwr_p.runf
kzrt_$1r, kzrt_$1l = Vertical stiffness between right rail and track. Recommended values see knwr_p.runf
cyrt_$1r, cyrt_$1l = Lateral damping between right rail and track. Recommended values see knwr_p.runf
czrt_$1r, czrt_$1l = Vertical damping between right rail and track. Recommended values see knwr_p.runf
gauge_average = Average gauge of track data. How to use gauge_average please see example in analyse_r_vehicle.html
gauge_dev_$1 = Deviation of gauge width. How to use gauge_average please see example in analyse_r_vehicle.html
YMtrac = Multiplying factor for lateral track irregularities
ZMtrac = Multiplying factor for vertical track irregularities
GMtrac = Multiplying factor for gauge irregularities
CMtrac = Multiplying factor for cant irregularities
lat_trac = Lateral track irregularities (positive direction= right)
vert_trac = Vertical track irregularities (positive direction= down)
gauge_trac = Gauge track irregularities (positive direction= wider gauge)
fi_trac = Cant track irregularities (positive direction= positive rotation around the X-axle)
lsa_$1 = Name of coordinate system for the wheelset
axl_$1 = Name of body wheelset
trc_$1 = Name of the track-piece under the wheelset

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.

Variable Description Default value
bo_ Lateral semi-distance to nominal rolling circle of the wheels 0.75
pknwr Controls how the contact stiffnesses shall be modeled:
(0= Hertzian contact stiffness)
(1= Linear contact stiffness)
1
knwr.F0_$1r, knwr.F0_$1l Pre-stress force in contact stiffness knwr 0.
kzrt.F0_$1r, kzrt.F0_$1l Pre-stress force in stiffness kzrt 0.
rails_$1_free It is possible to set constraints to the massless rails created by func wr_coupl_pe4
Example:
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.
0

Created output variables:
In addition to func wr_coupl_pe3 also the following variables will be created:
cp_XXX.ifield = Showing the number of current rail section
cp_XXX.rpos = The relative position between two rail sections
Where XXX is the number of the wheelset.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `wr_coupl_pr3`

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

$1 = Name/number of the wheelset.
lsa_$1 = Name of the linear local coordinate system.
cp1_$2r = Name of first contact point on right wheel.
trc_$2 = Body #1 in the coupling, which shall be the name of the piece of mass under the axle.
axl_$2 = Body #2 in the coupling, which shall be the name of the axle.
cp1_$2r.ksi = Longitudinal coordinate on trc_$2 of the contact point. The variable is defined and calculated by func wr_coupl_pr1, before the call to coupling cp1_$2r is made.
cp1_$2r.xa = Longitudinal coordinate on axl_$2 of the contact point, should be equal to 0.
cp1_$2r.bo = Lateral coordinate of contact point.
cp1_$2r.za = Vertical coordinate of contact point, normally equal to 0.
cp1_$2r.m = Number of cells in longitudinal direction in which the contact point shall be divided into
cp1_$2r.n = Number of cells in lateral direction in which the contact point shall be divided into
mu_$1r1 = Coefficient of friction in the adhesion zone of the contact point
G_$1r1 = Modulus of rigidity.
The following relation is valid:
G=   E   
   2(1+ν)
E= 2.05e11 and ν= 0.3 gives: G= 78846153846
nu_$1r1 = Poisson's ratio ν. Typical Value for steel ~0.3
mu_slip$1r1 = Coefficient of friction in the slip zone of the contact point
mulfactx_$1r1 = Creepage reduction factor in longitudinal direction due to asperities and contaminated contact surfaces
mulfacty_$1r1 = Creepage reduction factor in lateral direction due to asperities and contaminated contact surfaces
mulfactspin_$1r1= Creepage reduction factor in spin due to asperities and contaminated contact surfaces
knwrF0_$1r1 = Contact point prestress force.
The defomation in contact stiffness knwr is often very small because of its high stiffness. Therefore it is often easiest and best to set the prestess force in the contact point equal to 0(zero).
knwr_$1r1 = Contact point stiffness, normal to the contact surface.
The stiffness of knwr_ is normally very high, often much higher than other stiffnesses in track and vehicle.Therefore its value is not crucial for the result.Typical values for the stiffness is in the range 600e6-2400e6.
. . .   . . .
Etc.   For all three contact surface on both left and right hand side of the vehicle.


Output variables created:
(In order to reduce the size of the table, the names of the contact points cp1_$1r, cp1_$1l, cp2_$2r, cp2_$2l has been replaced with cpx_)
cpx_.dr = Deviation in wheel rolling radius due to wheel/rail geometry function
cpx_.gam = Roll angle of contact area
cpx_.z = Wheel lift due to wheel/rail geometry function
cpx_.irx = Longitudinal curvature difference between wheel and rail. The variable is defined and calculated by func wr_coupl_pr1, before the call to coupling cpx_ is made.
cpx_.iry = Lateral curvature difference between wheel and rail. The variable is defined and calculated by func wr_coupl_pr1, before the call to coupling cpx_ is made.
cpx_.Vref = Reference speed used when calculating creepages.
cpx_.nux = Longitudinal creepage in contact point cpx_.
cpx_.nuy = Lateral creepage in contact point cpx_.
cpx_.spin = Spin creepage in contact point cpx_.
cpx_.nuxm = Longitudinal creepage in contact point cpx_ reduced by factor mulfact_nux, due to contamination and asperities. The variable is defined and calculated by func wr_coupl_pr1, before the call to coupling cpx_ is made.
cpx_.nuym = Lateral creepage in contact point cpx_ reduced by factor mulfact_nux, due to contamination and asperities. The variable is defined and calculated by func wr_coupl_pr1, before the call to coupling cpx_ is made.
cpx_.spim = Spin creepage in contact point cpx_ reduced by factor mulfact_nux, due to contamination and asperities. The variable is defined and calculated by func wr_coupl_pr1, before the call to coupling cpx_ is made.
cpx_.ksi = The longitudinal position of the contact point on the rail. The variable is defined and calculated by func wr_coupl_pr1, before the call to coupling cpx_ is made.
cpx_.posw = The position of contact point cpx_, relative to the nominal running circle
cpx_.posr = The position of contact point cpx_, relative to the nominal running circle
cpx_.bo = The lateral position of the contact point. The variable is defined and calculated by func wr_coupl_pr1, before the call to coupling cpx_ is made.
cpx_.c = Geometrical average radii of the contact ellipse, calculated according to: c= √ a · b 
cpx_.a_b = Contact ellipse a/b-ratio.
kyrt$2r.F1y = Lateral force in stiffness kyrt under right rail
kyrt$2l.F1y = Lateral force in stiffness kyrt under left rail
cyrt$2r.F1y = Lateral force in damper cyrt under right rail
cyrt$2l.F1y = Lateral force in damper cyrt under left rail
kzrt$2r.F1z = Vertical force in stiffness kzrt under right rail
kzrt$2l.F1z = Vertical force in stiffness kzrt under left rail
czrt$2r.F1z = Vertical force in damper czrt under right rail
czrt$2l.F1z = Vertical force in damper czrt under left rail
cpx_.Fn = Normal contact force. The variable is defined and calculated by func wr_coupl_pr1, before the call to coupling cpx_ is made.
cpx_.Fny = Lateral force, tangential to the contact surface
cpx_.Fx = Longitudinal force, positive on rail
cpx_.Fy = Horizontal lateral force, positive on rail
cpx_.Fz = Vertical force, positive on rail
cpx_.Mspin = Spin torque moment, acting on body wheel

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.

Variable Description Default value
rails_$1_free It is possible to set constraints to the massless rails created by func wr_coupl_pr3
Example:
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.
0

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `wr_coupl_pra3`

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 "brush" 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:

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
k[1-3][1-4] = Wear coefficients for the different wear regions, see figure below
analyse_wr_coupl_pra3_wear_chart.gif

Example of a wear chart with some typical values:
analyse_wr_coupl_pra3_wear_chart_example.gif

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:

cpx_.aspeed = Average speed of all "brushes" in Archard's law.
cpx_.apress = Average contact pressure on all "brushes" in Archard's law.
cpx_.wear = Sum of wear from all "brushes" according to Archard's law.

Reference Manuals   Calc menu   Input Data Menu   Func Menu



f_type = `wr_coupl_prs3`

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 "brush" 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:

cpx_.aTgam_A = Average value of Tγ/A for all "brushes".
cpx_.wear = Sum of wear from all "brushes" according to the WearRate function.

Reference Manuals   Calc menu   Input Data Menu   Func Menu