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.
| `accp_bodyf` | Calculates accelerations in a body-fixed system using the total force acting on the mass. |
| `accp_bodyfix` | Calculates accelerations in a body-fixed system by derivating the speed of the mass. |
| `ad_acc_flex3` | Addition of acceleration from modal shapes. |
| `abs`, `abs_init` | Calculates the absolute value of a variable. |
| `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. |
| `acos`, `acos_init` | The arc-cosinus function. |
| `asin`, `asin_init` | The arc-sinus function. |
| `atan`, `atan_init` | The arc-tangent function. |
| `cabs`, `cabs_init` | Calculates the complex absolute value of two variables. |
| `char` | Creates a character constant in the memory. |
| `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. |
| `create2_l` | Creates a variable linearly interpolated from a super memory field. |
| `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. |
| `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. |
| `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 . |
| `integ` | Integrates a variable. |
| `intpl_l` | Linear interpolates a variable from several numbers. |
| `intpl2_r` | Stores memory fields into a super memory field. |
| `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. |
| `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 attached to a body. |
| `pos_rlsys2` | As pos_rlsys1 but in another lsys. |
| `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. |
| `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. |
| `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. |
| `wr_coupl_pe1` | Connects a wheelset to the rails; Massless rails; Creep forces are calculated in a lookup table. |
| `wr_coupl_pe2` | Similar to wr_coupl_pe1 but the rail profiles can vary along the track. |
| `wr_coupl_pe3` | Connects wheels to the rails; Massless rails; Creep forces are calculated in a lookup table. |
| `wr_coupl_pr1` | Connects a wheelset to the rails; Massless rails; Creep forces calculated in Fasim. |
| `wr_coupl_pra1` | Connects a wheelset to the rails; Massless rails; Creep forces calculated in Fasim; Wear according to Archard's law. |
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 handles only mass type m_rigid_6 without constraints.
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. |
| 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. |
| 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. |
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.
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. |
| 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. |
| 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. |
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, |
| 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 |
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`.
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. |
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 |
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. |
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 |
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. |
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. |
| f_name | = | Name of the input variable or constant. |
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 newly created character 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. N.B. only possible during the input data reading phase. |
| 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. |
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.
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. |
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 | = | |
| f_name | = | The value which the variable f_name_? will be given. |
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. |
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. |
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. |
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. |
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. |
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. |
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. |
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. |
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. |
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 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
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. |
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. |
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.
For a more accurate estimation of wheel/rail wear, please look at: wr_coupl_pra1.ins or wr_coupl_nra1.ins where the wear is calculated as volume per time.
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 Sheratt, Vehicle Dynamics Unit, British Rail Research, Derby (U.K), made in 1991 an investigation in how wheel material loss is correlated to Tγ (in function fl_wear_w denoted as cpa_$1.Fnu). The investigation showed the following relationsship:
Where: D= Is the wheel diameter in [mm].
Material loss according to Pearce and Sheratt, 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
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).
The wear on wheels and rails can be estimated in different ways.
The most accurate method is to use the wheel/rail coupling substructure
wr_coupl_pra1.ins or
wr_coupl_nra1.ins
where the actual wear is calculated as volume per unit time.
However the calculation of wear in
wr_coupl_pra1.ins or
wr_coupl_pra1.ins
is a bit unpractical when analysing long track sections,
because it is a bit time consuming.
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 Sheratt, Vehicle Dynamics Unit, British Rail Research, Derby (U.K), made in 1991 an investigation in how wheel material loss is correlated to Tγ (in function fl_weare1 denoted as wFny_$2). The investigation showed the following relationsship:
Where: D= Is the wheel diameter in [mm].
Material loss according to Pearce and Sheratt, 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
Reference Manuals
Calc menu
Input Data Menu
Func MenuDefines 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. |
The following FORTRAN routine can be used as a template for writing own subroutines:
*fuser0
c
subroutine fuser0 (outvar, nargs, iadr)
implicit real*8 (a-h,o-z)
c
c ------------------------------------------------------------------
c0 User supplied function #0
c ------------------------------------------------------------------
c1 outvar<= Output variable
c1 nargs => Number of arguments
c1 iadr => Address in memory where the arguments are located
c ------------------------------------------------------------------
c
c
c Pick up arguments from memory
c -------------------------------
val1 = var(idnint(var(iadr)))
val2 = var(idnint(var(iadr+1)))
val3 = var(idnint(var(iadr+2)))
c
c
c Make calculations
c ------------------------------------
outvar= val1 + val2 + val3
c
c
1000 return
end
Reference Manuals
Calc menu
Input Data Menu
Func Menu 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]. |
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]. |
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. |
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. |
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. |
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. |
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. |
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. |
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 |
| 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. |
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 |
| 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. |
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. |
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. |
Reads a track file written in
trac- or
trax-format
into a separate memory.
Track files written in
trax_wdesign-format can also be read.
However the three last columns in the trax_wdesign-file will be skipped.
Lines starting with a #-character will not be read.
Command intpl_track_irr2 will be reading the track data file into
four data fields apart from the main memory of the program.
The reason for doing this is that the program will execute more efficient if not all
the information regarding track irregularities also is stored in the main memory.
This command will not generate any fields in the main memory.
func intpl_track_irr2 (+-`)xstart (+-`)xstop `file' (+-`)gauge_ends
Command `intpl_track_irr2` starts reading the file at x=xstart and
stop reading when x=xstop, x is the first column of the file.
At both ends of the track irregularity file command intpl_track_irr2
appends a smooth entrance and exit to the irregularities.
This is done by four extra data points in the beginning and end
of the data file.
This smoothing process takes place over a distance of 10 [m].
In order to ensure that the vehicle will start on an ideal track,
the starting position of the first axle of the first vehicle must be
placed 10 [m] before the starting coordinate of the track.
Lateral-, vertical- and cant- errors will be 0(zero) 10 [m]
before and 10 [m] after the track.
The gauge will be equal to gauge_ends 10 [m] before
and 10 [m] after the track.
If the text string Ideal_track is given instead of a file name, command
intpl_track_irr2 will create an ideal track without track irregularities.
Reads a track file written in
trax_wdesign-format
including designed track curvature.
Lines starting with a #-character will not be read.
Command intpl_track_irr3 will be reading the track data file into
four data fields apart from the main memory of the program.
The reason for doing this is that the program will execute more efficient if not all
the information regarding track irregularities also is stored in the main memory.
This command will not generate any fields in the main memory.
func intpl_track_irr3 (+-`)xstart (+-`)xstop `file' (+-`)gauge_ends
ro_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.
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. |
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 equal to kpf_func_2 the wheel/rail-geometry function will be constant over the track section Xcoord_1--Xcoord_2. If kpf_func_1 differs from kpf_func_2 the wheel/rail-geometry function will linearly change from kpf_func_1 to kpf_func_2 in the track section Xcoord_1--Xcoord_2.
N.B. When a varying wheel/rail-geometry is used, all used profiles must be of type multi point contact. I.e. the input data parameter ALWAYS_WRITE_CPF in the preprocessor KPF must be set equal to yes, for all used profiles.
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. |
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]. |
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]. |
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. |
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. |
A second order low pass filter similar to lpass2.
Filter lpass2q is not accurate as lpass2,
but it is much faster because the integration does not take place in
the integrator defined in tsim_param.
Instead filter lpass2q has an own integrator.
A second order low pass filter similar to lpass2_0.
Filter lpass2q_0 is not accurate as lpass2_0,
but it is much faster because the integration does not take place in
the integrator defined in tsim_param.
Instead filter lpass2q_0 has an own integrator.
The maximum value of two or more variables.
func max `f_name' +-`var1, +-`var2, +-`var3,,, etc func max_init `f_name' +-`var1, +-`var2, +-`var3,,, etc
| 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 |
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. |
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. |
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 |
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. |
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. |
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. |
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. |
Creates a variable calculated in program octave.
Program octave evaluates expressions similar to program matlab,
and is embedded in gensys as a shared object.
All variables created in the coupl-,
func- and mass-commands
are also known for the shared octave program.
The values of the variables are only defined at time= 0.
If octave needs updated values during the simulation,
these variables must be defined via the func octave_copy-command.
func octave `f_name' m-file
| 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. |
| m-file | = | The file holding the octave-commands. The extension .m shall not be included in the file name. The output generated by the m-file must be given the name "OutputGensysFuncOctave". Number of characters in the m-file must not be more than 24. |
Creates a variable calculated in program octave.
Program octave evaluates expressions similar to program matlab,
and is embedded in gensys as a shared object.
All variables created in the coupl-,
func- and mass-commands
are also known for the shared octave program.
The values of the variables are only defined at time= 0.
If octave needs updated values during the simulation,
these variables must be defined via the func octave_copy-command.
func octave `f_name' m-file
| 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. |
| m-file | = | The file holding the octave-commands. The extension .m shall not be included in the file name. The output generated by the m-file must be given the name "OutputGensysFuncOctave". Number of characters in the m-file must not be more than 24. |
Copy variables to octave continuously or at specific time steps.
All variables created in the coupl-,
func- and mass-commands
are also known for the shared octave program.
The values of the variables are only defined at time= 0.
In order to do calculations simultaneously in program octave for output via the func octave-command,
it can be necessary to transfer updated values to the shared octave program.
This can be done in command func octave_copy.
func octave_copy var tstep
| var | = | Variable to be sent to the shared octave program. |
| tstep | = | Time step defining how often variable `var' shall be updated. If tstep equals 0.(zero), variable `var' will be updated every time step. |
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 |
| '+' | = | 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. |
| abs( ) | = | Calculates the absolute value of 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 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. |
| 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. |
| 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. |
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. |
| 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. |
| 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'. |
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. |
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. |
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. |
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. |
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. |
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. |
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. |
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. |
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. |
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 page
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. |
| 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 |
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. |
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. |
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. |
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
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. |
| 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. |
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. |
Connects a wheelset to the track.
In function wr_coupl_pe1 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.
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_pe1.ins
func wr_coupl_pe1 $2 $1
#
cpt_$2r trc_$2 cpt_$2r.ksi cpt_$2r.bo cpt_$2r.za
axl_$2 cpt_$2r.xa cpt_$2r.bo cpt_$2r.za
Not_used cpt_$2r.fzwr
cpt_$2r.gam cpt_$2r.nuxm cpt_$2r.nuym cpt_$2r.spim
cpt_$2r.irx cpt_$2r.iry cpt_$2r.mu
cpt_$2r.E cpt_$2r.nu cpt_$2r.dire
#
cpt_$2l trc_$2 cpt_$2l.ksi cpt_$2l.bo cpt_$2l.za
axl_$2 cpt_$2l.xa cpt_$2l.bo cpt_$2l.za
Not_used cpt_$2l.fzwr
cpt_$2l.gam cpt_$2l.nuxm cpt_$2l.nuym cpt_$2l.spim
cpt_$2l.irx cpt_$2l.iry cpt_$2l.mu
cpt_$2l.E cpt_$2l.nu cpt_$2l.dire
#
cpf_$2r trc_$2 cpf_$2r.ksi cpf_$2r.bo cpf_$2r.za
axl_$2 cpf_$2r.xa cpf_$2r.bo cpf_$2r.za
Not_used cpf_$2r.fzwr
cpf_$2r.gam cpf_$2r.nuxm cpf_$2r.nuym cpf_$2r.spim
cpf_$2r.irx cpf_$2r.iry cpf_$2r.mu
cpf_$2r.E cpf_$2r.nu cpf_$2r.dire
#
cpf_$2l trc_$2 cpf_$2l.ksi cpf_$2l.bo cpf_$2l.zt
axl_$2 cpf_$2l.xa cpf_$2l.bo cpf_$2l.za
Not_used cpf_$2l.fzwr
cpf_$2l.gam cpf_$2l.nuxm cpf_$2l.nuym cpf_$2l.spim
cpf_$2l.irx cpf_$2l.iry cpf_$2l.mu
cpf_$2l.E cpf_$2l.nu cpf_$2l.dire
| $2 | = | Number of the axle to be evaluated. |
| $1 | = | Number of the vehicle. |
| cpt_$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 |
| cpt_$2r.ksi | = | Longitudinal coordinate on trc_$2 of the contact point. The variable is defined and calculated by func wr_coupl_pe1, before the call to coupling cpt_$2r is made. |
| cpt_$2r.xa | = | Longitudinal coordinate on axl_$2 of the contact point, should be equal to 0. |
| cpt_$2r.bo | = | Lateral coordinate of the contact point. The variable is defined and calculated by func wr_coupl_pe1, before the call to coupling cpt_$2r is made. |
| cpt_$2r.za | = | Vertical coordinate of the contact point, normally equal to 0. |
| cpt_$2r.fzwr | = | Normal contact force multiplied by cos(gam). The variable is defined and calculated by func wr_coupl_pe1, before the call to coupling cpt_$2r is made. |
| cpt_$2r.gam | = | Angle of contact point in roll direction. The variable is defined and calculated by func wr_coupl_pe1, before the call to coupling cpt_$2r is made. |
| cpt_$2r.nuxm | = | Longitudinal creepage in the contact point reduced with factor mulfact_nux (see below). The variable is defined and calculated by func wr_coupl_pe1, before the call to coupling cpt_$2r is made. |
| cpt_$2r.nuym | = | Lateral creepage in the contact point reduced with factor mulfact_nuy (see below). The variable is defined and calculated by func wr_coupl_pe1, before the call to coupling cpt_$2r is made. |
| cpt_$2r.spim | = | Spin creepage in the contact point reduced with factor mulfact_spin (see below). The variable is defined and calculated by func wr_coupl_pe1, before the call to coupling cpt_$2r is made. |
| cpt_$2r.irx | = | Longitudinal curvature difference between wheel and rail. The variable is defined and calculated by func wr_coupl_pe1, before the call to coupling cpt_$2r is made. |
| cpt_$2r.iry | = | Lateral curvature difference between wheel and rail. The variable is defined and calculated by func wr_coupl_pe1, before the call to coupling cpt_$2r is made. |
| cpt_$2r.mu | = | Coefficient of friction in contact point |
| cpt_$2r.E | = | Modulus of elasticity |
| cpt_$2r.nu | = | Poisson's ratio |
| cpt_$2r.dire | = | Direction of action, must be set equal to "z". |
| cpt_$2l | = | Name of first contact point on left wheel |
| . . . . | = | Same type of input data as for contact point cpt_$2r above |
| cpf_$2r | = | Name of second contact point on right wheel |
| . . . . | = | Same type of input data as for contact point cpt_$2r above |
| cpf_$2l | = | Name of second contact point on left wheel |
| . . . . | = | Same type of input data as for contact point cpt_$2r above |
Function wr_coupl_pe1 also require that the follwing variables exists in main memory:
| Vo | = | Initial longitudinal speed of vehicle |
| ro_$2r, ro_$2l | = | Nominal rolling radius of right and left wheel respectively. |
| knwr_$2r, knwr_$2l | = | Stiffness perpendicular to the contact surface contact point #1 (tread). Recommended values see knwr_p.runf |
| knfr_$2r, knfr_$2l | = | Stiffness perpendicular to the contact surface contact point #2 (flange). Recommended values see knwr_p.runf |
| kyrt_$2r, kyrt_$2l | = | Lateral stiffness between right rail and track. Recommended values see knwr_p.runf |
| kzrt_$2r, kzrt_$2l | = | Vertical stiffness between right rail and track. Recommended values see knwr_p.runf |
| cyrt_$2r, cyrt_$2l | = | Lateral damping between right rail and track. Recommended values see knwr_p.runf |
| czrt_$2r, czrt_$2l | = | 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_$2 | = | 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_$2 | = | Name of coordinate system for the wheelset |
| axl_$2 | = | Name of body wheelset |
| trc_$2 | = | 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_$2r, knwr.F0_$2l | = | Pre-stress force in contact stiffness knwr | 0. |
| kzrt.F0_$2r, kzrt.F0_$2l | = | Pre-stress force in stiffness kzrt | 0. |
| mulfact_nux_cpt_$2 | = | Longitudinal creep relaxation factor contact point 1 wheel $2 | 1. |
| mulfact_nuy_cpt_$2 | = | Lateral creep relaxation factor contact point 1 wheel $2 | 1. |
| mulfact_spin_cpt_$2 | = | Spin creep relaxation factor contact point 1 wheel $2 | 1. |
| mulfact_nux_cpf_$2 | = | Longitudinal creep relaxation factor contact point 2 wheel $2 | 1. |
| mulfact_nuy_cpf_$2 | = | Lateral creep relaxation factor contact point 2 wheel $2 | 1. |
| mulfact_spin_cpf_$2 | = | Spin creep relaxation factor contact point 2 wheel $2 | 1. |
| mulfact_nux_cptr | = | Longitudinal creep relaxation factor contact point 1 all right wheels | 1. |
| mulfact_nuy_cptr | = | Lateral creep relaxation factor contact point 1 all right wheels | 1. |
| mulfact_spin_cptr | = | Spin creep relaxation factor contact point 1 all right wheels | 1. |
| mulfact_nux_cpfr | = | Longitudinal creep relaxation factor contact point 2 all right wheels | 1. |
| mulfact_nuy_cpfr | = | Lateral creep relaxation factor contact point 2 all right wheels | 1. |
| mulfact_spin_cpfr | = | Spin creep relaxation factor contact point 2 all right wheels | 1. |
| mulfact_nux_cptl | = | Longitudinal creep relaxation factor contact point 1 all left wheels | 1. |
| mulfact_nuy_cptl | = | Lateral creep relaxation factor contact point 1 all left wheels | 1. |
| mulfact_spin_cptl | = | Spin creep relaxation factor contact point 1 all left wheels | 1. |
| mulfact_nux_cpfl | = | Longitudinal creep relaxation factor contact point 2 all left wheels | 1. |
| mulfact_nuy_cpfl | = | Lateral creep relaxation factor contact point 2 all left wheels | 1. |
| mulfact_spin_cpfl | = | Spin creep relaxation factor contact point 2 all left wheels | 1. |
| 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_pe1, 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_pe1, 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_pe1, 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_pe1, 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_pe1, 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_pe1, 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_pe1, before the call to coupling cpx_ is made. |
| 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 |
| cpx_.fzwr | = | Normal contact force multiplied by cos(gam). The variable is defined and calculated by func wr_coupl_pe1, 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$2.y | = | Lateral track irregularities, track center line |
| tral$2r.y | = | Lateral track irregularities, right rail |
| tral$2l.y | = | Lateral track irregularities, left rail |
| tral$2r.z | = | Vertical track irregularities, right rail |
| tral$2l.z | = | Vertical track irregularities, left rail |
| tral$2r.vy | = | Lateral speed track irregularities, right rail |
| tral$2l.vy | = | Lateral speed track irregularities, left rail |
| tral$2r.vz | = | Vertical speed track irregularities, right rail |
| tral$2l.vz | = | Vertical speed track irregularities, left rail |
| tral$2.f | = | Track irregularities in roll direction |
| tral$2r.k | = | Pitch irregularities right rail |
| tral$2l.k | = | Pitch irregularities left rail |
| tral$2r.p | = | Yaw irregularities right rail |
| tral$2l.p | = | Yaw irregularities left rail |
| ral_$2r.y | = | Lateral position of the massless rail-head right |
| ral_$2l.y | = | Lateral position of the massless rail-head left |
| ral_$2r.vy | = | Lateral speed of the massless rail-head right |
| ral_$2l.vy | = | Lateral speed of the massless rail-head left |
| ral_$2r.z | = | Vertical position of the massless rail-head right |
| ral_$2l.z | = | Vertical position of the massless rail-head left |
| ral_$2r.vz | = | Vertical speed of the massless rail-head right |
| ral_$2l.vz | = | Vertical speed of the massless rail-head left |
Connects a wheelset to the track.
In function wr_coupl_pe2 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.
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_pe2.ins
func wr_coupl_pe2 $2 $1
#
cpt_$2r # Name of contact point #1 right side
trc_$2 # Name of body track
cpt_$2r.ksi cpt_$2r.bo cpt_$2r.za # Attachment point body track
axl_$2 # Name of body wheelset
cpt_$2r.xa cpt_$2r.bo cpt_$2r.za # Attachment point body wheelset
Not_used # Redundant input data variable
cpt_$2r.fzwr # Normal contact force multiplied by cos(gam)
cpt_$2r.gam # Angle of contact point in roll direction.
cpt_$2r.nux cpt_$2r.nuy cpt_$2r.spin # Creepages in contact point
cpt_$2r.irx cpt_$2r.iry # Long. and lat. curvatures in contact point
cpt_$2r.mu # Coefficient of friction
mulfact_nux_cpt$1r mulfact_nuy_cpt$1r # Creepage reduction due to contaminated
mulfact_spin_cpt$1r # rail surface
cpt_$2r.E cpt_$2r.nu cpt_$2r.dire # Modulus of elasticity and Poisson's ratio
#
cpt_$2l # Name of contact point #1 left side
trc_$2 # Name of body track
cpt_$2l.ksi cpt_$2l.bo cpt_$2l.za # Attachment point body track
axl_$2 # Name of body wheelset
cpt_$2l.xa cpt_$2l.bo cpt_$2l.za # Attachment point body wheelset
Not_used # Redundant input data variable
cpt_$2l.fzwr # Normal contact force multiplied by cos(gam)
cpt_$2l.gam # Angle of contact point in roll direction.
cpt_$2l.nux cpt_$2l.nuy cpt_$2l.spin # Creepages in contact point
cpt_$2l.irx cpt_$2l.iry # Long. and lat. curvatures in contact point
cpt_$2l.mu # Coefficient of friction
mulfact_nux_cpt$1l mulfact_nuy_cpt$1l # Creepage reduction due to contaminated
mulfact_spin_cpt$1l # rail surface
cpt_$2l.E cpt_$2l.nu cpt_$2l.dire # Modulus of elasticity and Poisson's ratio
#
cpf_$2r # Name of contact point #2 right side
trc_$2 # Name of body track
cpf_$2r.ksi cpf_$2r.bo cpf_$2r.za # Attachment point body track
axl_$2 # Name of body wheelset
cpf_$2r.xa cpf_$2r.bo cpf_$2r.za # Attachment point body wheelset
Not_used # Redundant input data variable
cpf_$2r.fzwr # Normal contact force multiplied by cos(gam)
cpf_$2r.gam # Angle of contact point in roll direction.
cpf_$2r.nux cpf_$2r.nuy cpf_$2r.spin # Creepages in contact point
cpf_$2r.irx cpf_$2r.iry # Long. and lat. curvatures in contact point
cpf_$2r.mu # Coefficient of friction
mulfact_nux_cpf$1r mulfact_nuy_cpf$1r # Creepage reduction due to contaminated
mulfact_spin_cpf$1r # rail surface
cpf_$2r.E cpf_$2r.nu cpf_$2r.dire # Modulus of elasticity and Poisson's ratio
#
cpf_$2l # Name of contact point #2 left side
trc_$2 # Name of body track
cpf_$2l.ksi cpf_$2l.bo cpf_$2l.za # Attachment point body track
axl_$2 # Name of body wheelset
cpf_$2l.xa cpf_$2l.bo cpf_$2l.za # Attachment point body wheelset
Not_used # Redundant input data variable
cpf_$2l.fzwr # Normal contact force multiplied by cos(gam)
cpf_$2l.gam # Angle of contact point in roll direction.
cpf_$2l.nux cpf_$2l.nuy cpf_$2l.spin # Creepages in contact point
cpf_$2l.irx cpf_$2l.iry # Long. and lat. curvatures in contact point
cpf_$2l.mu # Coefficient of friction
mulfact_nux_cpf$1l mulfact_nuy_cpf$1l # Creepage reduction due to contaminated
mulfact_spin_cpf$1l # rail surface
cpf_$2l.E cpf_$2l.nu cpf_$2l.dire # Modulus of elasticity and Poisson's ratio
| $2 | = | Number of the axle to be evaluated. |
| $1 | = | Number of the vehicle. |
| cpt_$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 |
| cpt_$2r.ksi | = | Longitudinal coordinate on trc_$2 of the contact point. The variable is defined and calculated by func wr_coupl_pe2, before the call to coupling cpt_$2r is made. |
| cpt_$2r.xa | = | Longitudinal coordinate on axl_$2 of the contact point, should be equal to 0. |
| cpt_$2r.bo | = | Lateral coordinate of the contact point. The variable is defined and calculated by func wr_coupl_pe2, before the call to coupling cpt_$2r is made. |
| cpt_$2r.za | = | Vertical coordinate of the contact point, normally equal to 0. |
| cpt_$2r.fzwr | = | Normal force multiplied by cos(gam). The variable is defined and calculated by func wr_coupl_pe2, before the call to coupling cpt_$2r is made. |
| cpt_$2r.gam | = | Angle of contact point in roll direction. The variable is defined and calculated by func wr_coupl_pe2, before the call to coupling cpt_$2r is made. |
| cpt_$2r.nux | = | Longitudinal creepage in the contact point. The variable is defined and calculated by func wr_coupl_pe2, before the call to coupling cpt_$2r is made. |
| cpt_$2r.nuy | = | Lateral creepage in the contact point. The variable is defined and calculated by func wr_coupl_pe2, before the call to coupling cpt_$2r is made. |
| cpt_$2r.spin | = | Spin creepage in the contact point. The variable is defined and calculated by func wr_coupl_pe2, before the call to coupling cpt_$2r is made. |
| cpt_$2r.irx | = | Longitudinal curvature difference between wheel and rail. The variable is defined and calculated by func wr_coupl_pe2, before the call to coupling cpt_$2r is made. |
| cpt_$2r.iry | = | Lateral curvature difference between wheel and rail. The variable is defined and calculated by func wr_coupl_pe2, before the call to coupling cpt_$2r is made. |
| cpt_$2r.mu | = | Coefficient of friction in contact point |
| cpt_$2r.E | = | Modulus of elasticity |
| cpt_$2r.nu | = | Poisson's ratio |
| cpt_$2r.dire | = | Direction of action, must be set equal to "z". |
| cpt_$2l | = | Name of first contact point on left wheel |
| . . . . | = | Same type of input data as for contact point cpt_$2r above |
| cpf_$2r | = | Name of second contact point on right wheel |
| . . . . | = | Same type of input data as for contact point cpt_$2r above |
| cpf_$2l | = | Name of second contact point on left wheel |
| . . . . | = | Same type of input data as for contact point cpt_$2r above |
Function wr_coupl_pe2 also require that the follwing variables exists in main memory:
| Vo | = | Initial longitudinal speed of vehicle |
| ro_$2r, ro_$2l | = | Nominal rolling radius of right and left wheel respectively. |
| knwr_$2r, knwr_$2l | = | Stiffness perpendicular to the contact surface contact point #1 (tread). Recommended values see knwr_p.runf |
| knfr_$2r, knfr_$2l | = | Stiffness perpendicular to the contact surface contact point #2 (flange). Recommended values see knwr_p.runf |
| kyrt_$2r, kyrt_$2l | = | Lateral stiffness between right rail and track. Recommended values see knwr_p.runf |
| kzrt_$2r, kzrt_$2l | = | Vertical stiffness between right rail and track. Recommended values see knwr_p.runf |
| cyrt_$2r, cyrt_$2l | = | Lateral damping between right rail and track. Recommended values see knwr_p.runf |
| czrt_$2r, czrt_$2l | = | 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_$2 | = | 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_$2 | = | Name of coordinate system for the wheelset |
| axl_$2 | = | Name of body wheelset |
| trc_$2 | = | 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_$2r, knwr.F0_$2l | = | Pre-stress force in contact stiffness knwr | 0. |
| kzrt.F0_$2r, kzrt.F0_$2l | = | Pre-stress force in stiffness kzrt | 0. |
| cp_X.ifield | = | Showing the number of current rail section |
| cp_X.rpos | = | The relative position between two rail sections |
Connects wheels or a wheelset to the track.
In function wr_coupl_pe3 the rails are modeled as massless masses.
The stiffness normal to the wheel/rail contact surface is defined in variable knwr.
The rails are connected to the track via springs and dampers:
kyrt, cyrt, kzrt and czrt.
Three different contact surfaces can be in contact simultaneously.
The calculations of creep forces are made in a lookup table calculated by Fasim.
In order to further reduce the amount of input data in the users input data file
this function can be called via the substructure wr_coupl_pe3.ins
or wr_coupl_pe3_whe.ins.
func wr_coupl_pe3
#
$1 # Name/number of the wheelset
lsa_$1 # Name of the linear local coordinate system
#
lat_trac vert_trac spv_trac fi_trac # Track irregularities memory fields
YMtrac ZMtrac GMtrac CMtrac # Multiplication factors for track irregularities
gauge_average # Average gauge of spv_trac
gauge_dev_$1 # Modify average gauge for a different conicity
pknwr # Type of contact normal to the contact surface
#
whe_$1r # Body wheel right side
whe_$1l # Body wheel left side
trc_$1 # Body track
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
cp1_$1r.mu # 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
cp1_$1l.mu # 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
cp2_$1r.mu # 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
cp2_$1l.mu # 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
cp3_$1r.mu # 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
cp3_$1l.mu # 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 |
| axl_$1 | = | Name of wheelset |
| trc_$1 | = | Name of track |
| 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 normal gauge equal to 0.75[m]) |
| kzrt.F0_$1l | = | Pre-stress force in stiffness kzrt_$1l |
| kyrt_$1l | = | Lateral stiffness between right rail and track. Recommended values see knwr_p.runf |
| kzrt_$1l | = | Vertical stiffness between right rail and track. Recommended values see knwr_p.runf |
| cyrt_$1l | = | Lateral damping between right rail and track. Recommended values see knwr_p.runf |
| czrt_$1l | = | Vertical damping between right rail and track. Recommended values see knwr_p.runf |
| cp1_$1r | = | Name of first contact point on right wheel |
| axl_$1 | = | Body #1 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. |
| trc_$1 | = | Body #2 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. |
| cp1_$1r.mu | = | Coefficient of friction in contact point |
| cp1_$1r.E | = | Modulus of elasticity |
| cp1_$1r.nu | = | Poisson's ratio |
| 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_$1l above |
| cp3_$1r | = | Name of third contact point on right wheel |
| . . . . | = | Same type of input data as for contact point cp1_$1r above |
| cp3_$1l | = | Name of third contact point on left wheel |
| . . . . | = | Same type of input data as for contact point cp1_$1l above |
| 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. |
| 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 |
Connects a wheelset to the rails.
Function wr_coupl_pr1 also creates two massless rails under each wheel of the wheelset,
two contact points on each wheel,
springs and dampers between rails and track.
The calculations of creep forces are made in strips by Fasim.
This function is called by substructure wr_coupl_pr1.ins.
func wr_coupl_pr1 $2 $1
#
cpt_$2r trc_$2 cpt_$2r.ksi cpt_$2r.bo cpt_$2r.za
axl_$2 cpt_$2r.xa cpt_$2r.bo cpt_$2r.za
cpt_$2r.Fn cpt_$2r.gam cpt_$2r.nuxm cpt_$2r.nuym cpt_$2r.spim
cpt_$2r.irx cpt_$2r.iry cpt_$2r.m cpt_$2r.n cpt_$2r.mu_adh
cpt_$2r.G cpt_$2r.nu cpt_$2r.mu_slip
#
cpt_$2l trc_$2 cpt_$2l.ksi cpt_$2l.bo cpt_$2l.za
axl_$2 cpt_$2l.xa cpt_$2l.bo cpt_$2l.za
cpt_$2l.Fn cpt_$2l.gam cpt_$2l.nuxm cpt_$2l.nuym cpt_$2l.spim
cpt_$2l.irx cpt_$2l.iry cpt_$2l.m cpt_$2l.n cpt_$2l.mu_adh
cpt_$2l.G cpt_$2l.nu cpt_$2l.mu_slip
#
cpf_$2r trc_$2 cpf_$2r.ksi cpf_$2r.bo cpf_$2r.za
axl_$2 cpf_$2r.xa cpf_$2r.bo cpf_$2r.za
cpf_$2r.Fn cpf_$2r.gam cpf_$2r.nuxm cpf_$2r.nuym cpf_$2r.spim
cpf_$2r.irx cpf_$2r.iry cpf_$2r.m cpf_$2r.n cpf_$2r.mu_adh
cpf_$2r.G cpf_$2r.nu cpf_$2r.mu_slip
#
cpf_$2l trc_$2 cpf_$2l.ksi cpf_$2l.bo cpf_$2l.za
axl_$2 cpf_$2l.xa cpf_$2l.bo cpf_$2l.za
cpf_$2l.Fn cpf_$2l.gam cpf_$2l.nuxm cpf_$2l.nuym cpf_$2l.spim
cpf_$2l.irx cpf_$2l.iry cpf_$2l.m cpf_$2l.n cpf_$2l.mu_adh
cpf_$2l.G cpf_$2l.nu cpf_$2l.mu_slip
| $2 | = | Number of the axle to be evaluated. |
| $1 | = | Number of the vehicle. |
| cpt_$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. |
| cpt_$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 cpt_$2r is made. |
| cpt_$2r.xa | = | Longitudinal coordinate on axl_$2 of the contact point, should be equal to 0. |
| cpt_$2r.bo | = | Lateral coordinate of contact point. |
| cpt_$2r.za | = | Vertical coordinate of contact point, normally equal to 0. |
| cpt_$2r.Fn | = | Normal force in the contact point. The variable is defined and calculated by func wr_coupl_pr1, before the call to coupling cpt_$2r is made. |
| cpt_$2r.gam | = | Angle of contact point in roll. The variable is defined and calculated by func wr_coupl_pr1, before the call to coupling cpt_$2r is made. |
| cpt_$2r.nuxm | = | Longitudinal creepage in the contact point reduced with factor mulfact_nux, due to contamination and asperities The variable is defined and calculated by func wr_coupl_pr1, before the call to coupling cpt_$2r is made. |
| cpt_$2r.nuym | = | Lateral creepage in the contact point reduced with factor mulfact_nuy, due to contamination and asperities The variable is defined and calculated by func wr_coupl_pr1, before the call to coupling cpt_$2r is made. |
| cpt_$2r.spim | = | Spin creepage in the contact point reduced with factor mulfact_spin, due to contamination and asperities The variable is defined and calculated by func wr_coupl_pr1, before the call to coupling cpt_$2r is made. |
| cpt_$2r.irx | = | Longitudinal curvature difference between wheel and rail The variable is defined and calculated by func wr_coupl_pr1, before the call to coupling cpt_$2r is made. |
| cpt_$2r.iry | = | Lateral curvature difference between wheel and rail The variable is defined and calculated by func wr_coupl_pr1, before the call to coupling cpt_$2r is made. |
| cpt_$2r.m | = | Number of cells in longitudinal direction in which the contact point shall be divided into |
| cpt_$2r.n | = | Number of cells in lateral direction in which the contact point shall be divided into |
| cpt_$2r.mu_adh | = | Coefficient of friction in the adhesion zone of the contact point |
| cpt_$2r.G | = | Modulus of rigidity |
| cpt_$2r.nu | = | Poisson's ratio |
| cpt_$2r.mu_slip | = | Coefficient of friction in the slip zone of the contact point |
| cpt_$2l | = | Name of first contact point on left wheel |
| . . . . | = | Same type of input data as for contact point cpt_$2r above |
| cpf_$2r | = | Name of second contact point on right wheel |
| . . . . | = | Same type of input data as for contact point cpt_$2r above |
| cpf_$2l | = | Name of second contact point on left wheel |
| . . . . | = | Same type of input data as for contact point cpt_$2r above |
| 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_.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. |
| 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 |
Connects a wheelset to the rails.
Function wr_coupl_pra1 also creates two massless rails under each wheel of the wheelset,
two contact points on each wheel,
springs and dampers between rails and track.
The calculations of creep forces are made in strips by Fasim.
Evaluation of wear in the strips are made according to Archard's law.
This function is called by substructure wr_coupl_pra1.ins.
func wr_coupl_pra1 $2 $1
H V1 V2 V3 p1 p2
k11 k12 k13 k14
k21 k22 k23 k24
k31 k32 k33 k34
#
cpt_$2r trc_$2 cpt_$2r.ksi cpt_$2r.bo cpt_$2r.za
axl_$2 cpt_$2r.xa cpt_$2r.bo cpt_$2r.za
cpt_$2r.Fn cpt_$2r.gam cpt_$2r.nuxm cpt_$2r.nuym cpt_$2r.spim
cpt_$2r.irx cpt_$2r.iry cpt_$2r.m cpt_$2r.n cpt_$2r.mu_adh
cpt_$2r.G cpt_$2r.nu cpt_$2r.mu_slip
#
cpt_$2l trc_$2 cpt_$2l.ksi cpt_$2l.bo cpt_$2l.za
axl_$2 cpt_$2l.xa cpt_$2l.bo cpt_$2l.za
cpt_$2l.Fn cpt_$2l.gam cpt_$2l.nuxm cpt_$2l.nuym cpt_$2l.spim
cpt_$2l.irx cpt_$2l.iry cpt_$2l.m cpt_$2l.n cpt_$2l.mu_adh
cpt_$2l.G cpt_$2l.nu cpt_$2l.mu_slip
#
cpf_$2r trc_$2 cpf_$2r.ksi cpf_$2r.bo cpf_$2r.za
axl_$2 cpf_$2r.xa cpf_$2r.bo cpf_$2r.za
cpf_$2r.Fn cpf_$2r.gam cpf_$2r.nuxm cpf_$2r.nuym cpf_$2r.spim
cpf_$2r.irx cpf_$2r.iry cpf_$2r.m cpf_$2r.n cpf_$2r.mu_adh
cpf_$2r.G cpf_$2r.nu cpf_$2r.mu_slip
#
cpf_$2l trc_$2 cpf_$2l.ksi cpf_$2l.bo cpf_$2l.za
axl_$2 cpf_$2l.xa cpf_$2l.bo cpf_$2l.za
cpf_$2l.Fn cpf_$2l.gam cpf_$2l.nuxm cpf_$2l.nuym cpf_$2l.spim
cpf_$2l.irx cpf_$2l.iry cpf_$2l.m cpf_$2l.n cpf_$2l.mu_adh
cpf_$2l.G cpf_$2l.nu cpf_$2l.mu_slip
| $2 | = | Number of the axle to be evaluated. |
| $1 | = | Number of the vehicle. |
| 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?? | = | Wear coefficients for the different wear regions |
| cpt_$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 |
| cpt_$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 cpt_$2r is made. |
| cpt_$2r.xa | = | Longitudinal coordinate on axl_$2 of the contact point, should be equal to 0. |
| cpt_$2r.bo | = | Lateral coordinate of contact point. |
| cpt_$2r.za | = | Vertical coordinate of contact point, normally equal to 0. |
| cpt_$2r.Fn | = | Normal force in the contact point. The variable is defined and calculated by func wr_coupl_pra1, before the call to coupling cpt_$2r is made. |
| cpt_$2r.gam | = | Angle of contact point in roll. The variable is defined and calculated by func wr_coupl_pra1, before the call to coupling cpt_$2r is made. |
| cpt_$2r.nuxm | = | Longitudinal creepage in the contact point reduced with factor mulfact_nux, due to contamination and asperities The variable is defined and calculated by func wr_coupl_pra1, before the call to coupling cpt_$2r is made. |
| cpt_$2r.nuym | = | Lateral creepage in the contact point reduced with factor mulfact_nuy, due to contamination and asperities The variable is defined and calculated by func wr_coupl_pra1, before the call to coupling cpt_$2r is made. |
| cpt_$2r.spim | = | Spin creepage in the contact point reduced with factor mulfact_spin, due to contamination and asperities The variable is defined and calculated by func wr_coupl_pra1, before the call to coupling cpt_$2r is made. |
| cpt_$2r.irx | = | Longitudinal curvature difference between wheel and rail The variable is defined and calculated by func wr_coupl_pra1, before the call to coupling cpt_$2r is made. |
| cpt_$2r.iry | = | Lateral curvature difference between wheel and rail The variable is defined and calculated by func wr_coupl_pra1, before the call to coupling cpt_$2r is made. |
| cpt_$2r.m | = | Number of cells in longitudinal direction in which the contact point shall be divided into |
| cpt_$2r.n | = | Number of cells in lateral direction in which the contact point shall be divided into |
| cpt_$2r.mu_adh | = | Coefficient of friction in the adhesion zone of the contact point |
| cpt_$2r.G | = | Modulus of rigidity |
| cpt_$2r.nu | = | Poisson's ratio |
| cpt_$2r.mu_slip | = | Coefficient of friction in the slip zone of the contact point |
| cpt_$2l | = | Name of first contact point on left wheel |
| . . . . | = | Same type of input data as for contact point cpt_$2r above |
| cpf_$2r | = | Name of second contact point on right wheel |
| . . . . | = | Same type of input data as for contact point cpt_$2r above |
| cpf_$2l | = | Name of second contact point on left wheel |
| . . . . | = | Same type of input data as for contact point cpt_$2r above |
| 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_pra1, before the call to coupling cpx_ is made. |
| cpt_$2r.iry | = | Lateral curvature difference between wheel and rail. The variable is defined and calculated by func wr_coupl_pra1, 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_pra1, 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_pra1, 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_pra1, 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_pra1, 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_pra1, before the call to coupling cpx_ is made. |
| 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_pra1, 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_.wArchH_# | = | Material wear [m3/s] in the softer material H Vickers; contact area cpx_; strip number # |
| cpx_.wArchH | = | Material wear over the whole contact surface; sum of all strips. |
| cpx_.wArchS_# | = | Material wear [m3/s] similar to cpx_.wArchH_#; but reduced with respect to contamination and lubrication in the contact surface. |
| cpx_.wArchS | = | Material wear over the whole contact surface; sum of all strips. |