Home
Reference Manuals
Return
Example of a rail road vehicle input data model
Table of contents
Main input data file
Head lines
Define variables used in the wheel-rail coupling substructure
Wheel-rail geometry functions
In line pre- and post- processing
Track irregularities
Designed track geometry
Speed
Modify track gauge
The standard insert file vhedat/std_inserts.ins
Analysis specific commands
Overwrite existing coupling properties
Check if_then-statements during input data reading
Save variables for post processing
Flange wear and RCF
The default vehicle property file
Start positions along the track
Change of vehicle data parameters
Vehicle model-file
Create local coordinate systems
Create masses
Calculation of creep and creep forces
Animate track irregularities
Regulate the longitudinal position of the vehicle
Acceleration points
Position points
Graphical representation of the bodies
Wear and RCF indexes
Storing results for animation in GPLOT
Storing results for post processing in MPLOT
Secondary springs
Anti-roll bars
Traction rods
Yaw dampers
Track model
Frequency response excitation
Structural flexibility
Initial values
Secant conicity
Stop conditions
Recommended names of masses and couplings
Miscellaneous
Vehicles for other gauges than 1435.
Main input data file
Head lines
Head lines are defined in:
##
##
## Headlines
## ==========================================================
head 2 "Railway vehicle with two bogies; 4 driven axles; $CalcType"
head 3 "Wheel/Rail= $ckpfr; Friction=$mu_; Speed=$vkmh"
head 4 "Curve Radius=$CurveRadius; Track irr.=$ctrack_irreg"
Maximum 10 head lines can be defined.
Every line is read until end-of-line.
Maximum 80 character per line.
Define variables used in the wheel-rail coupling substructure
##
## Define variables used in the wheel-rail coupling substructure
## =============================================================
func const vkmh= 160 # The initial speed of the vehicle in km/h
# func operp vkmh= 400 - 5 * time # Vary vkmh in order to calculate critical speed
func const bo_ = 0.75 # Lateral semi-distance between the nominal rolling circles of the wheels
func const mu_ = 0.50 # Coefficient of friction between wheel and rail
Variable vkmh
Variable vkmh sets the initial speed of the vehicle.
The unit of vkmh is in km/h.
Due to friction forces and damper forces,
the vehicle will drop its speed in the simulation (unless the track has a downward slope).
Therefore it is often needed to have a speed regulator, which keeps the speed up through long simulations.
Also in quasistatical analysis it is important to have a speed regulator which gives a longitudinal stiffness to the model.
Avoiding the vehicle to roll away along the track.
However variable vkmh is only a help variable for the user.
Later this variable will be translated into variable Vo which is the speed in m/s.
All input data to gensys shall be given in SI-units.
Variable vkmh can be defined as function of time.
By uncommenting line number 2 the speed will decrease by 5 km/h per second.
With this technique it is easy to calculate the critical speed of the vehicle.
Variable bo_
Variable bo_ defines the lateral semi-spacing to the nominal running circle.
For normal gauge 1435[mm] variable bo_ should be 0.75[m],
because the lateral distance between the gauge measuring point and the nominal running circles
on the rail is defined as 32.5[mm]. Which gives:
0.75= (1.435 + 2*0.0325) / 2
Variable mu_
Variable mu_ sets the coefficient of friction between wheel and rail.
The reason for ending variable mu_ with an underscore is that it is easy to define different
coefficient of friction on different contact points.
Gensys reads the coefficient of friction in different priority according to the following table:
| mu_ |
= |
The default value of the coefficient of friction which is valid if no other values with a higher priority has been given.
|
| mu_1 |
= |
The coefficient of friction for the first vehicle in the train-set
|
| mu_11 |
= |
The coefficient of friction for the first bogie in the first vehicle in the train-set
|
| mu_111 |
= |
The coefficient of friction for the first wheelset in the first bogie in the first vehicle in the train-set
|
| mu_111r |
= |
The coefficient of friction for the right wheel in the first wheelset in the first bogie in the first vehicle in the train-set
|
| mu_111r1 |
= |
The coefficient of friction for contact point cp1 on the right wheel in the first wheelset in the first bogie in the first vehicle in the train-set
|
The priority of the values increases down the table.
If you in the input data file define the following variables:
func const mu_111r1= 0.1 # Specific coefficient of friction for cp1 on wheel 111r
func const mu_1 = 0.2 # Specific coefficient of friction for the first vehicle
func const mu_ = 0.5 # Default coefficient of friction between wheel and rail
Contact point cp1 on the right wheel on the leading axle will be given a coefficient of friction equal to 0.1.
Other contact points on the first vehicle will be given a coefficient of friction equal to 0.2.
All other contact points will be given a coefficient of friction equal to 0.5.
Wheel-rail geometry functions
The geometry of wheel and rail must be defined in input data.
The pre processor KPF calculates wheel-rail geometry functions,
which can be used as input data to program CALC.
The input data can be written in many different ways,
here follows a number of common cases:
Same profiles on all vehicles
Different profiles for different vehicles
Different profiles for all wheels
Calculate the wheel-rail geometry functions in a pre-process command
Wheel-rail geometry functions which vary along the track
Defining input data for the animation of the wheel-rail contact are made in the commands:
s_var gpdat_wheel_info,
s_var gpdat_rail_info_right and
s_var gpdat_rail_info_left.
See example under Storing results for animation in GPLOT
Same profiles on all vehicles
If the train-set has the same wheel profiles on all vehicles,
the definition of the wheel-rail geometry functions can be as the following:
##
## Define wheel-rail geometry functions
## ====================================
insert file $genkpf/ENS1002t32.5_uic60i40..kpfr
in_substruct ENS1002t32.5_uic60i40 [ " " ] # All wheels in the vehicle
Different profiles for different vehicles
If the train-set has different wheel profiles on different vehicles,
the definition of the wheel-rail geometry functions should be as the following:
##
## Define wheel-rail geometry functions
## ====================================
insert file $genkpf/ENS1002t32.5_uic60i40.kpfr
insert file $genkpf/ENS1002t32.5_uic60i30.kpfr
insert file $genkpf/ENS1002t32.5_uic60i20.kpfr
in_substruct ENS1002t32.5_uic60i40 [ 1 ] # Vehicle #1
in_substruct ENS1002t32.5_uic60i30 [ 2 ] # Vehicle #2
in_substruct ENS1002t32.5_uic60i20 [ 3 ] # Vehicle #3
Different profiles for all wheels
If the train-set has different wheel-rail profiles on each wheel,
the definition of the wheel-rail geometry functions should be as the following:
##
## Define wheel-rail geometry functions
## ====================================
insert file kpfr/wheel1_rail1.kpfr
insert file kpfr/wheel2_rail1.kpfr
insert file kpfr/wheel1_rail2.kpfr
insert file kpfr/wheel2_rail2.kpfr
in_substruct kpf_wheel1_rail1 [ 111r ] # Axle 111 right side
in_substruct kpf_wheel1_rail2 [ 111l ] # Axle 111 left side
in_substruct kpf_wheel2_rail1 [ 112r ] # Axle 112 right side
in_substruct kpf_wheel2_rail2 [ 112l ] # Axle 112 left side
in_substruct kpf_wheel1_rail1 [ 121r ] # Axle 121 right side
in_substruct kpf_wheel1_rail2 [ 121l ] # Axle 121 left side
in_substruct kpf_wheel2_rail1 [ 122r ] # Axle 122 right side
in_substruct kpf_wheel2_rail2 [ 122l ] # Axle 122 left side
Calculate the wheel-rail geometry functions in a pre-process command
If the user wishes to calculate the wheel-rail geometry functions in-line with a pre-process command,
only giving the wheel- and rail- profile as input data,
the input data shall be written as the following:
pre_process= 'create_kpfr kpff/Master.kpff kpf/S1002.wheel kpf/uic60i40.rail create_kpfr'
insert file kpfr/create_kpfr.kpfr
in_substruct create_kpfr [ " " ]
The script create_kpfr is located in the directory $gensys/bin and is accessable via the users $PATH.
The first argument to script create_kpfr is the input data file for program KPF.
In this example the KPF input data file is named kpff/Master.kpff.
The second argument to script create_kpfr is the wheel profile.
The third argument to script create_kpfr is the rail profile.
The wheel and rail profiles are described in plain ASCII-files as defined in the
kpf-manual.
The fourth and last argument to script create_kpfr is the ident-name of the case.
In the second line the newly created wheel-rail substructure-file kpfr/create_kpfr.kpfr
is inserted in the CALC input data file, by the insert-command.
In the third and last line the substructure is given a name,
here only " " which means that all wheels in the vehicle shall have the same
wheel-rail geometry functions.
Wheel-rail geometry functions which vary along the track
If not the wheel-rail geometries are constant along the track,
the definition of the wheel-rail geometry functions can be
written in the following way:
##
## Define a wheel-rail geometry functions which varies along the track
## -------------------------------------------------------------------
insert file $genkpf/S1002t32.5_bv50i30.kpfr
insert file $genkpf/S1002t32.5_bv50i30_worn_r3.kpfr
insert file $genkpf/S1002t32.5_bv50i30_worn_l3.kpfr
in_substruct S1002t32.5_bv50i30 [ tang_track ]
in_substruct S1002t32.5_bv50i30_worn_r3 [ right_curve ]
in_substruct S1002t32.5_bv50i30_worn_l3 [ left_curve ]
func kpf_variable_1 " " -100.0 tang_track
0.0 tang_track
5.0 right_curve
300.0 right_curve
305.0 tang_track
320.0 tang_track
325.0 left_curve
620.0 left_curve
625.0 tang_track
1000.0 tang_track
In the example above the track consists of 17 sections with different wheel-rail geometries.
| Region |
wheel-rail geometry function |
|---|
| -100 - 0.0 |
tang_track |
| 0.0 - 5.0 |
Linear transition from tang_track to right_curve |
| 5.0 - 300 |
right_curve |
| 300 - 305 |
Linear transition from right_curve to tang_track |
| |
,,, etc. |
Wheel/rail-geometry files older than rel.0908 cannot be used.
Before calculations can start new kpfr-files must be generated.
Using a character variable
Defining character variable ckpfr for an easy selection of kpfr-file.
By using a character variable it is possible to write a if_then_char_init - elseif_then_char_init - endif-statement,
for the selection of the correct wheel/rail geometry file.
The value of variable ckpfr can also be used for output in the header lines.
##
## Define wheel-rail geometry functions
## ==========================================================
func char ckpfr= ENS1002t32.5_uic60i40
#
if_then_char_init ckpfr .eq. "ckona_fl"
func copy_init lambda0= 0.025 # Rail inclination 1/40
func copy_init lambda = 0.30 # Effective conicity
s_var scalar_0 lambda
func operp_init epsilon= 50.7 * ( lambda - lambda0 ) # Contact angle difference parameter
insert file $genkpf/kpf_ckona_fl.kpfr
in_substruct kpf_ckona [ " " lambda lambda0 epsilon ]
#
elseif_then_char_init ckpfr .eq. "rkona"
insert file $genkpf/kpf_rkona.kpfr
in_substruct kpf_rkona [ " " 0. ]
#
elseif_then_char_init ckpfr .eq. "ENS1002t32.5_uic60i40"
insert file $genkpf/ENS1002t32.5_uic60i40.kpfr
in_substruct ENS1002t32.5_uic60i40 [ " " ]
#
elseif_then_char_init ckpfr .eq. "ENS1002t32.5_uic60i30"
insert file $genkpf/ENS1002t32.5_uic60i30.kpfr
in_substruct ENS1002t32.5_uic60i30 [ " " ]
#
elseif_then_char_init ckpfr .eq. "ENS1002t32.5_uic60i20"
insert file $genkpf/ENS1002t32.5_uic60i20.kpfr
in_substruct ENS1002t32.5_uic60i20 [ " " ]
#
elseif_then_char_init ckpfr .eq. "SjNormalt33_uic60i40"
insert file $genkpf/SjNormalt33_uic60i40.kpfr
in_substruct SjNormalt33_uic60i40 [ " " ]
#
elseif_then_char_init ckpfr .eq. "SjNormalt33_uic60i20"
insert file $genkpf/SjNormalt33_uic60i20.kpfr
in_substruct SjNormalt33_uic60i20 [ " " ]
#
elseif_then_char_init ckpfr .eq. "Variable_W/R-geom"
insert file $genkpf/S1002t32.5_bv50i30.kpfr
insert file $genkpf/S1002t32.5_bv50i30_worn_r3.kpfr
insert file $genkpf/S1002t32.5_bv50i30_worn_l3.kpfr
in_substruct S1002t32.5_bv50i30 [ tang_track ]
in_substruct S1002t32.5_bv50i30_worn_r3 [ right_curve ]
in_substruct S1002t32.5_bv50i30_worn_l3 [ left_curve ]
func kpf_variable_1 " " -100.0 tang_track
0.0 tang_track
5.0 right_curve
300.0 right_curve
305.0 tang_track
320.0 tang_track
325.0 left_curve
620.0 left_curve
625.0 tang_track
1000.0 tang_track
#
else
func print06_char_init " "
func print06_char_init "***ERROR*** In Input Reading"
func print06_char_init " Unvalid value given for character variable ckpfr"
func stop
endif
In line pre- and post- processing
##
## Pre- & Post- Processing
## ==========================================================
if_then_char_init CalcType .eq. TSIM .or.
CalcType .eq. MODAL
# pre_process= 'sed "s!runf/Master.runf!$CURRENT_FILE!" npickf/flex_car.npickf > npickf/$IDENT.npickf'
# pre_process= 'npick npickf/$IDENT.npickf'
# pre_process= 'quasi $CURRENT_FILE'
# post_process= 'mplot mplotf/Tsim_All_BoBo.mplotf $IDENT'
# post_process= 'mplot mplotf/critSpeedGoalfunc.mplotf $IDENT'
# post_process= 'mgv diags/$IDENT.ps'
endif
Extract modal shapes from a flexible mass
The user can in input data specify pre- and post- processing commands.
The following line creates an input data file for NPICK,
copies file npickf/Master.npickf into npickf/$IDENT.npickf
and at the same time substitutes the character string runf/Master.runf
into $CURRENT_FILE:
pre_process= 'sed "s!runf/Master.runf!$CURRENT_FILE!" npickf/flex_car.npickf > npickf/$IDENT.npickf'
Launch the execution in program NPICK:
pre_process= 'npick npickf/$IDENT.npickf'
Calculate initial values
Set the initial values for all equations in the model.
This is necessary in the FRESP- and MODAL-program.
In program TSIM this is not necessary, but it can avoid initial vibrations.
pre_process= 'quasi $CURRENT_FILE'
Post processing the results in MPLOT
After the analysis in the CALC program, the user may wish to
calculate max. track-shift forces, max. flange climb ration,
different wear index, ride index,,, etc.
post_process= 'mplot mplotf/Tsim_Safe_OneIdent.mplotf $IDENT'
Track irregularities
The track alignment is described in two parts:
Designed track geometry and
Track irregularities.
The designed track geometry consists of the description of curvatures and cant.
Track irregularities are the deviations from the designed track geometry.
Often the Designed track geometry and Track irregularities are separated into two parts.
However there exists track recording vehicles that measures the both signals at the same time,
in this case command
func intpl_track_irr3
shall be used.
Example:
##
## Define track irregularities
## ==========================================================
func char ctrack_irreg= Ideal_track # Output in header lines
func const Track_Gauge= 1435.
#
if_then_char_init ctrack_irreg .eq. "Ideal_track" # {{
func const YMtrac= 1e-3 # From mm to m; Scale factor 1.00; Lateral irregularities
func const ZMtrac= 1e-3 # From mm to m; Scale factor 1.00; Vertical irregularities
func const GMtrac= 1e-3 # From mm to m; Scale factor 1.00; Gauge irregularities
func const CMtrac= 1e-3/(2*bo_) # From mm to rad; Scale factor 1.00; Cant irregularities
func const Xtrac_start= 0.
func const Xtrac_stop= 30000.
func intpl_track_irr2 Xtrac_start Xtrac_stop Ideal_track Track_Gauge
#
elseif_then_char_init ctrack_irreg .eq. "UIC518_wheel_unloading" # }{
func const YMtrac= 1e-3 # From mm to m; Scale factor 1.00; Lateral irregularities
func const ZMtrac= 1e-3 # From mm to m; Scale factor 1.00; Vertical irregularities
func const GMtrac= 1e-3 # From mm to m; Scale factor 1.00; Gauge irregularities
func const CMtrac= 1e-3/(2*bo_) # From mm to rad; Scale factor 1.00; Cant irregularities
func const Xtrac_start= 0.
func const Xtrac_stop= 3000.
func intpl_r lat_trac
-100.0 0.0
Xtrac_stop 0.0
func intpl_r vert_trac # vertical alignment in mm
-100.0 0.0
-10.0 0.0
-9.0 0.0
-8.0 0.0
0.0 0.0
66-6-.1 0.0
66-6-.00006 0.0 # Several points in order to avoid ringing in the spline interpolation
66-6-.00004 0.0
66-6-.00003 0.0
66-6-.00001 0.0
66-6 0.0
66-6+0.0003 0.0005
66-6+0.0006 0.001
66-6+0.006 0.01
66-0.006 9.99
66-0.0006 9.999
66-0.0003 9.9995
66 10.0 # 20 dip on high rail
66+0.0003 9.9995 # 6 m semi-span
66+0.0006 9.999
66+0.006 9.99
66+6-0.006 0.01
66+6-0.0006 0.001
66+6-0.0003 0.0005
66+6 0.0
66+6+.00001 0.0
66+6+.00003 0.0
66+6+.00004 0.0
66+6+.00006 0.0
Xtrac_stop 0.0
func intpl_r spv_trac # track gauge in mm
-100.0 1435.
Xtrac_stop 1435.
func intpl_r fi_trac # cant in mm
-100.0 0.0
-10.0 0.0
-9.0 0.0
-8.0 0.0
0.0 0.0
66-6-.1 0.0
66-6-.00006 0.0 # Several points in order to avoid ringing in the spline interpolation
66-6-.00004 0.0
66-6-.00003 0.0
66-6-.00001 0.0
66-6 0.0
66-6+0.0003 -0.001
66-6+0.0006 -0.002
66-6+0.006 -0.02
66-0.006 -19.98
66-0.0006 -19.998
66-0.0003 -19.999
66 -20.0 # 20 dip on high rail
66+0.0003 -19.999 # 6 m semi-span
66+0.0006 -19.998
66+0.006 -19.98
66+6-0.006 -0.02
66+6-0.0006 -0.002
66+6-0.0003 -0.001
66+6 0.0
66+6+.00001 0.0
66+6+.00003 0.0
66+6+.00004 0.0
66+6+.00006 0.0
Xtrac_stop 0.0
#
elseif_then_char_init ctrack_irreg .eq. "track_irr4" # }{
func const YMtrac 0.000650 # from mm to m, and factor 0.65
func const ZMtrac 0.000800 # from mm to m, and factor 0.80
func const GMtrac 0.001000 # from mm to m, and factor 0.65
func const CMtrac 0.000533 # from mm to rad, and factor 0.80
func const Xtrac_start= 0.
func const Xtrac_stop= 2003.
func intpl_track_irr2 Xtrac_start Xtrac_stop track/track_irr4.trax Track_Gauge
#
elseif_then_char_init ctrack_irreg .eq. "track_V120a" # }{
func const YMtrac= 1e-3 # From mm to m; Scale factor 1.00; Lateral irregularities
func const ZMtrac= 1e-3 # From mm to m; Scale factor 1.00; Vertical irregularities
func const GMtrac= 1e-3 # From mm to m; Scale factor 1.00; Gauge irregularities
func const CMtrac= 1e-3/(2*bo_) # From mm to rad; Scale factor 1.00; Cant irregularities
func const Xtrac_start= 1400.
func const Xtrac_stop= 3100.
func intpl_track_irr2 Xtrac_start Xtrac_stop track/track_V120a.trax Track_Gauge
#
elseif_then_char_init ctrack_irreg .eq. "track_V120b" # }{
func const YMtrac= 1e-3 # From mm to m; Scale factor 1.00; Lateral irregularities
func const ZMtrac= 1e-3 # From mm to m; Scale factor 1.00; Vertical irregularities
func const GMtrac= 1e-3 # From mm to m; Scale factor 1.00; Gauge irregularities
func const CMtrac= 1e-3/(2*bo_) # From mm to rad; Scale factor 1.00; Cant irregularities
func const Xtrac_start= 1050.
func const Xtrac_stop= 3000.
func intpl_track_irr2 Xtrac_start Xtrac_stop track/track_V120b.trax Track_Gauge
#
elseif_then_char_init ctrack_irreg .eq. "track_V160a" # }{
func const YMtrac= 1e-3 # From mm to m; Scale factor 1.00; Lateral irregularities
func const ZMtrac= 1e-3 # From mm to m; Scale factor 1.00; Vertical irregularities
func const GMtrac= 1e-3 # From mm to m; Scale factor 1.00; Gauge irregularities
func const CMtrac= 1e-3/(2*bo_) # From mm to rad; Scale factor 1.00; Cant irregularities
func const Xtrac_start= 700.
func const Xtrac_stop= 4200.
func intpl_track_irr2 Xtrac_start Xtrac_stop track/track_V160a.trac Track_Gauge
#
elseif_then_char_init ctrack_irreg .eq. "track_V200a" # }{
func const YMtrac= 1e-3 # From mm to m; Scale factor 1.00; Lateral irregularities
func const ZMtrac= 1e-3 # From mm to m; Scale factor 1.00; Vertical irregularities
func const GMtrac= 1e-3 # From mm to m; Scale factor 1.00; Gauge irregularities
func const CMtrac= 1e-3/(2*bo_) # From mm to rad; Scale factor 1.00; Cant irregularities
func const Xtrac_start= 0.
func const Xtrac_stop= 4997.
func intpl_track_irr2 Xtrac_start Xtrac_stop track/track_V200a.trac Track_Gauge
#
else
func print06_char_init " "
func print06_char_init "***ERROR*** In Input Reading"
func print06_char_init " Unvalid value given for character variable ctrack_irreg"
func stop
endif # }}
#
s_var scalar_0 Xtrac_start # Save start coordinate as a scalar for post processing
s_var scalar_0 Xtrac_stop # Save stop coordinate as a scalar for post processing
In the track irregularity files
trac, trax
and trax_wdesign
the errors are stored in [mm],
but all calculations in CALC are performed in SI-units,
therefore must the track irregularities be converted into [m].
The conversion into [m] is made by setting the constants, YMtrac,
ZMtrac and GMtrac equal to 0.001.
Variable CMtrac translates from [mm] to [rad],
therefore CMtrac is dependent on the gauge.
In order to automatically adjust for the current gauge used CMtrac has been defined as 1e-3/(2*bo_).
Designed track geometry
If track irregularities has been read with func intpl_track_irr3
this section must be omitted, otherwise the memory fields
ro_trac_design, f_trac_design and z_trac_design will defined twice
and an error will occur.
Example:
The following lines in the main input data file will define a S-shaped curve
with a curve radius of 600 [m] and a cant of 150[mm]:
##
## Define designed(nominal) track geometry
## ==========================================================
func const Curve_radius= 600 # Curve radius in [m]
func const Curve_cant= 0.150 # Cant of track in [m]
#
func intpl_r ro_trac_design -100.+Xtrac_start 0.
0.+Xtrac_start 0.
120.+Xtrac_start 1/Curve_radius # Right handed curve
160.+Xtrac_start 1/Curve_radius
280.+Xtrac_start 0.
320.+Xtrac_start 0.
440.+Xtrac_start -1/Curve_radius # Left handed curve
480.+Xtrac_start -1/Curve_radius
600.+Xtrac_start 0.
1000.+Xtrac_start 0.
func intpl_r f_trac_design -100.+Xtrac_start 0.
0.+Xtrac_start 0.
120.+Xtrac_start Curve_cant/(2*bo_)
160.+Xtrac_start Curve_cant/(2*bo_)
280.+Xtrac_start 0.
320.+Xtrac_start 0.
440.+Xtrac_start -Curve_cant/(2*bo_)
480.+Xtrac_start -Curve_cant/(2*bo_)
600.+Xtrac_start 0.
1000.+Xtrac_start 0.
func intpl_r z_trac_design -100.+Xtrac_start 0.
0.+Xtrac_start 0.
120.+Xtrac_start -abs(Curve_cant)/2.
160.+Xtrac_start -abs(Curve_cant)/2.
280.+Xtrac_start 0.
320.+Xtrac_start 0.
440.+Xtrac_start -abs(Curve_cant)/2.
480.+Xtrac_start -abs(Curve_cant)/2.
600.+Xtrac_start 0.
1000.+Xtrac_start 0.
s_var scalar_0 Curve_radius
s_var scalar_0 Curve_cant
Variable Xtrac_start has previously been defined under section track irregularity.
This is a practical way of connecting the
designed track geometry and
track irregularities to each other.
If the track only consists of tangent track.
Variable Curve_radius and Curve_cant can be set equal to:
func const Curve_radius= 1e99 # Curve radius in [m]
func const Curve_cant= 0.000 # Cant of track in [m]
or the memory fields can be written according to:
func intpl_r ro_trac_design -100. 0.
0. 0.
func intpl_r f_trac_design -100. 0.
0. 0.
func intpl_r z_trac_design -100. 0.
0. 0.
The three memory fields: ro_trac_design, f_trac_design and z_trac_design defined above,
will later be used for controlling the positions of
the coordinate systems which follows the vehicle.
N.B. The description of the designed track must start on tangent track
otherwise an error will occur.
Setting the speed of the vehicle
The speed of the vehicle can be defined in different ways:
Constant speed
Set speed according to a formula
Set speed according to cant deficiency
Read speed profile from an external file
Constant speed
Just create a variable named Vo.
Gensys do always use SI-units in input data, why variable Vo shall be expressed in m/s.
However the user can define another variable in order to express the speed in km/h or mph,
for output in header lines etc.
func const vkmh= 160 # The initial speed of the vehicle in km/h
func div Vo = vkmh 3.6 # Expressed in m/s
s_var sngl vkmh # Save variable speed for postprocessing
func const vmph= 100 # The initial speed of the vehicle in mph
func div Vo = vkmh 2.236936 # Expressed in m/s
s_var sngl vmph # Save variable speed for postprocessing
N.B. The vehicle must have a longitudinal constraint or have a longitudinal spring connected to the moving coordinate system.
Because of energy dissipation in dampers and wheel/rail-contant, the speed of the vehicle will always drop.
Something needs to push the vehicle forward otherwise it will not follow the coordinate system.
Set speed according to a formula
In order to calculate max non-linear speed the speed could start at a very high speed where the vehicle is unstable.
The speed could be linearly decreasing until the vehicle becomes stable:
func operp vkmh= 600 - 5 * time # Vary vkmh in order to calculate critical speed
func div Vo = vkmh 3.6 # Expressed in m/s
s_var sngl vkmh # Save variable speed for postprocessing
In this case it is advisory to apply a longitudinal force on all masses in negative X-direction.
Otherwise the vehicle will run faster than the coordinate system.
Set speed according to cant deficiency
func const Y_cp= 0.65*sign(CurveRadius) # lateral acc. in track plane
func const vkmh= 3.6*sqrt(CurveRadius*(Y_cp+CurveCant/(2*bo_)*9.81))
func u_lim vkmh= 160
func div Vo = vkmh 3.6
s_var sngl vkmh
Read speed profile from an external file
When measuring track forces and ride comfort on an actual vehicle
it can be difficult to keep a constant speed during the whole test.
In order to compare measurements and simulations
it is sometimes necessary to simulate with exactly the same speed profile as was used during the test.
The following input data code can be used:
func intpl_r Speed_field insert free_form '(a,a)' track/Speed.txt # Vo speed in m/s
lsys e_abs_bendrf esys_1 Speed_field Xtrac_start-(2+aba_11+acb_1)
ro_trac_design f_trac_design z_trac_design
4 4 4 4 4 4
func copy Vo= esys_1.vx
func mul vkmh= esys_1.vx 3.6
Modify track gauge
Track irregularity files written in
trac-,
trax- or
trax_wdesign-format includes
the measured gauge in absolute coordinates.
In some cases the vehicle designer wish to change the average gauge of a track,
in order to check the behavior of the vehicle in a tight or wide gauge.
For the above purposes the user has access to two key-variables gauge_average and gauge_dev_.
The variables gauge_average and gauge_dev_ operates on
column #4 from the track file in the following way:
tral$2.gauge= (column_4(axl_$2.pn) - gauge_average)*GMtrac + gauge_dev_
tral$2r.y= column_2(axl_$2.pn) + tral$2.gauge/2.
tral$2l.y= column_2(axl_$2.pn) - tral$2.gauge/2.
Where:
| axl_$2.pn | = | The longitudinal position of axle $2 (axl_$2.pn= lsa_$2.pn + axl_$2.x) |
| lsa_$2.pn | = | The longitudinal position of the local coordinate system for axle $2 |
| axl_$2.x | = | The longitudinal position of axle $2 relative to local coordinate system lsa_$2 |
| column_4(x) | = | The value of column #4 (gauge errors) interpolated at x in the track irregularity file
|
| GMtrac | = | Unit translation and multiplying factor described under Track Irregularities above
|
| column_2(x) | = | The value of column #2 (lateral errors) interpolated at x in the track irregularity file
|
Output from the equations above is:
| tral$2r.y | = | lateral error on top of right rail under axle number $2
|
| tral$2l.y | = | lateral error on top of left rail under axle number $2
|
Example #1
Set the preferred average value of the gauge, by defining the variable track_width.
##
## Automatically modify the gauge of the track
## ===========================================
func const track_width= 1435.
func mean_r2_init Xavg gauge_average spv_trac Xtrac_start Xtrac_stop
func print06_char_init ' '
func print06_init gauge_average
func operp_init gauge_dev_= 0.001 * ( track_width - 1435. )
In the example above the average value of the gauge is changed to the value
given in the variable track_width independently of what gauge
the track data file has.
Example #2
Modify the average value of the gauge manually.
##
## Set the variables gauge_average and gauge_dev_ manually
## ======================================================
func const gauge_average=1435. # Set the average gauge of the track
# func const gauge_dev_=-0.004 # 4 mm tighter track
func const gauge_dev_= 0.000 # Do not change the gauge of the track
# func const gauge_dev_= 0.004 # 4 mm wider track
If the variable gauge_dev_ is set equal to 0. no change will be done to the track gauge,
the calculation will be carried out with the same gauge as defined in the track-file.
If the user wish to widen the gauge of the track, he or she should give variable gauge_dev_
a positive value.
If the user wish to narrow the gauge of the track, he or she should give variable gauge_dev_
a negative value.
In the memory of program CALC the user has access to the following
variables regarding the track irregularities:
| tral$2r.y | = | Lateral track irregularity on top of right rail under axle number $2
|
| tral$2l.y | = | Lateral track irregularity on top of left rail under axle number $2
|
| tral$2r.z | = | Vertical track irregularity on top of right rail under axle number $2
|
| tral$2l.z | = | Vertical track irregularity on top of left rail under axle number $2
|
The standard insert file vhedat/std_inserts.ins
In order to reduce the amount of text in the main input data file,
a sub-file vhedat/std_inserts.ins can be inserted.
The commands given in file vhedat/std_inserts.ins are common for all railway vehicle models.
##
## Define substructures and commands which
## are common for all railway vehicle models.
## ==========================================================
insert file vhedat/std_inserts.ins
Analysis specific commands
GENSYS uses the same input data file for all types of analysis.
However a few input data are analysis specific.
These analysis specific commands has mainly been collected in the following four commands:
fresp_param, modal_param, quasi_param and tsim_param.
Input data parameters for program FRESP
Program FRESP calculates frequency response spectras.
The following line is only read by program FRESP:
fresp_param= Fourier_CG1 1.e-4 fstart= .3 fstop= 20. fstep= -1.06
The analysis in the program FRESP is linear,
Before the calculation starts the model will be linearized.
The linearization amplitude is given in the first argument in analysis Fourier_CG1.
In the example above the linearization amplitude is set to 1.e-4 which equals 0.1[mm].
The linearization of the model is made automatically.
Before the analysis in program FRESP starts,
it is recommended that initial values from program QUASI are calculated first,
and the initial values are feed into FRESP via the initval read_gpdat-command.
In order to ensure that all forces in the model are in equilibrium.
Command fexcit is also an input data command, but the command must
be given after the masses has been defined.
Therefore you will find the documentation about "fexcit" later in this
manual page.
Input data parameters for program MODAL
Program MODAL performs modal analysis,
finding all eigenvalues in the input data model.
The following line is only read by program MODAL:
modal_param= Schur_fact1 1.e-4
Before the analysis in program MODAL starts,
it is recommended that initial values from program QUASI are calculated first,
and the initial values are feed into MODAL via the initval read_gpdat-command.
In order to ensure that all forces in the model are in equilibrium.
Input data parameters for program QUASI
Program QUASI performs quasi statical analysis,
searching the position of all integrated variables
where all internal forces are balanced with respect to external
forces and acceleration fields.
The following line is only read by program QUASI:
quasi_param= Damped_Tens 1.e-4 .2 10 16.
QUASI automatically stores the position of the vehicle in the GPdat-file.
If the user is interested in storing forces, displacements, etc. on the MPdat-file
he or she must specify those variables in command
s_var scalar_0.
Input data parameters for program TSIM
Program TSIM performs time domain integration.
The following line is only read by program TSIM:
tsim_param= heun_u tstart= 0. tstop=10. tstep= 0.001 tout= 0.005
Overwrite existing coupling properties
Normally in all GENSYS four analysis program FRESP, MODAL, QUASI and TSIM,
it is not possible to redefine a property.
Because different properties requires different number of cells in the main memory.
However, by giving the command overwrite_property
in the beginning of the input data file,
changes the allocation of the properties in the main memory which makes it possible to
redefine a property.
##
## Permit overwriting of existing properties
## ===============================================================
overwrite_property
Check if_then-statements during input data reading
Normally in all GENSYS programs,
all statements in all if_then-endif-blocks are executed,
regardless if the if_then-condition is true or false
during the initial input reading phase.
Because all commands must be stored in the main memory in case the if_then-condition
later during the calculation is changed into a true state.
By giving this command in the beginning of the input data file all if_then-condition
will be tested before they are executed.
##
## Check if_then-statements during input data reading
## ===============================================================
check_if_then_at_0
Save variables for post processing
##
## Define substructure files, saving variables for postprocessing
## ==============================================================
insert file $gensys/calc/insert_files/save_car1.ins # Save variables for carbody
insert file $gensys/calc/insert_files/save_bol1.ins # Save variables for bolster beam
insert file $gensys/calc/insert_files/save_bog1.ins # Save variables for bogie
insert file $gensys/calc/insert_files/save_axl1.ins # Save variables for axle
insert file $gensys/calc/insert_files/save_creep1.ins # Save variables for the contact points
insert file $gensys/calc/insert_files/save_mass_1.ins # Save variables for masses
Program CALC do not store all variables in result file
MPdat,
because it will generate a too big result file,
therefore the user must specify the variables to be stored in MPdat-file.
The above substructure files have been written in order to easily store
the most interesting variables for post processing.
The insertion of these substructure is made at the end of the file
vhedat/vhe_model.ins.
Flange wear and RCF
In the combined substruct wear_RCF both wheel wear and RCF are evaluated,
and the results are stored for postprocessing.
##
## Calculate wear and RCF indexes
## ==============================================================
substruct wear_RCF [
func fl_wear_w $1 mu_cp1$1 mu_cp2$1 mu_cp3$1
s_var sngl cpa_$1.Fnu s_var sngl cp1_$1.Fnu s_var var_0 cp2_$1.Fnu s_var var_0 cp3_$1.Fnu
s_var sngl cpa_$1.FMnu s_var sngl cp1_$1.FMnu s_var var_0 cp2_$1.FMnu s_var var_0 cp3_$1.FMnu
#
func lpass2q_0 cp1_$1.FMnuq= cp1_$1.FMnu 3 .7
func max2 cp1_$1.FMnul= cp1_$1.FMnu cp1_$1.FMnuq
s_var sngl cp1_$1.FMnul
#
if_then_init .exist. cp2_$1.FMnu
func lpass2q_0 cp2_$1.FMnuq= cp2_$1.FMnu 3 .7
func max2 cp2_$1.FMnul= cp2_$1.FMnu cp2_$1.FMnuq
else
func const cp2_$1.FMnul= 0.
endif
s_var sngl cp2_$1.FMnul
#
if_then_init .exist. cp3_$1.FMnu
func lpass2q_0 cp3_$1.FMnuq= cp3_$1.FMnu 3 .7
func max2 cp3_$1.FMnul= cp3_$1.FMnu cp3_$1.FMnuq
else
func const cp3_$1.FMnul= 0.
endif
s_var sngl cp3_$1.FMnul
##
## Yield Dang Residual Wear Contact Wear
## Name whe_ Stress Van Stress Limit ForceLlim Cp1 Cp2 Cp3
func rolling_fatigue_3 RCF_$1 $1 300e6 0.32 0. 125 175 4000 cp1_$1.FMnul cp2_$1.FMnul cp3_$1.FMnul
##
## YieldStress= 300e6 after some hardening
##
## Surface fatigue index Subsurface fatigue index Deep subsurface fatigue index
s_var sngl RCF_$1.FPs s_var sngl RCF_$1.FPb s_var sngl RCF_$1.FPd
s_var sngl RCF_$1.FPs1 s_var sngl RCF_$1.FIs1
s_var sngl RCF_$1.FPs2 s_var sngl RCF_$1.FIs2
s_var sngl RCF_$1.FPs3 s_var sngl RCF_$1.FIs3
func operp RCF_$1.FPbm= RCF_$1.FPb / 450e6 - 1
s_var sngl RCF_$1.FPbm
]
The default vehicle property file
The following line redirects further input data reading to file vhedat/BoBo.propf.
##
## Insert default vehicle properties
## ==========================================================
insert file vhedat/BoBo.propf
In the sub-file vhedat/BoBo.propf the definition of all default values are made.
The vehicle dimensions are defined as variables in func const-commands.
Coupling properties are defined as coupl p_*-commands
In the sub-file vhedat/BoBo.propf all properties ends with an _ character,
this indicates that the property will be the default property for the whole train-set if no
other more specific property has been given in input data.
In the input data phase of program CALC,
a coupling specific property has highest priority,
a vehicle specific property has intermediate priority,
a default overall property has lowest priority.
In the documentation of the couplings is the
priority order
described.
Setting the positions of the vehicles along the track
After file vhedat/BoBo.propf has been read the variables acb_1 and aba_11 are known,
and we can position the cars along the track with the following code:
##
## Start positions along the track
## ==========================================================
func const sstart_1= Xtrac_start-(2+aba_11+acb_1) # vehicle #1
func const sstart_2= sstart_1-(acb_1+aba_12+2+2+aba_21+acb_2) # vehicle #2
func const sstart_3= sstart_2-(acb_2+aba_22+2+2+aba_31+acb_3) # vehicle #3
Change of vehicle data parameters
Between the definition of default vehicle properties and the creation of the vehicle model,
the user has the possibility to make changes to the defined data
or add coupling properties with higher priority.
Example:
The user wants to change the default value for the longitudinal primary stiffness to 12e6,
he/she also wants to set a specific longitudinal stiffness for the primary suspension 111r.
The notation 111r stands for: the first axle, in the first bogie, in the first vehicle, right side.
##
## Change of vehicle data parameters
## ======================================================
coupl p_lin kxba_ 0. 12e6 # primary stiffness, longitudinal
coupl p_lin kxba_111r 0. 8e6 # primary stiffness, longitudinal, axle box 111r
Vehicle model-file
The following lines order program CALC to continue read input data from file
vhedat/vhe_model.ins:
##
## Insert vehicle model-file
## ======================================================
insert file vhedat/BoBo.ins
Create local coordinate systems
##
## lsys e_abs_bend l_name vms sstart curve_R curve_f curve_z
## -------------------------------------------------------------------
# func intpl_r Speed_field insert free_form '(a,a)' track/Speed.txt # Vo speed in m/s
# lsys e_abs_bendrf esys_1 Speed_field sstart_1 ro_trac_design f_trac_design z_trac_design
lsys e_abs_bendrf esys_1 Vo sstart_1 ro_trac_design f_trac_design z_trac_design
4 4 4 4 4 4
##
## lsys l_local l_name esys a b h
## -------------------------------------------------
lsys l_local lsc_$1 esys_$1 0.0 0.0 0.0
lsys l_local lsb_$11 lsc_$1 acb 0.0 0.0
lsys l_local lsb_$12 lsc_$1 -acb 0.0 0.0
lsys l_local lsa_$111 lsb_$11 abw 0.0 0.0
lsys l_local lsa_$112 lsb_$11 -abw 0.0 0.0
lsys l_local lsa_$121 lsb_$12 abw 0.0 0.0
lsys l_local lsa_$122 lsb_$12 -abw 0.0 0.0
Coordinate systems taking large rotations into consideration are Euler coordinate systems.
These types of coordinate systems all begins with the letter e_ in GENSYS.
Linear coordinate systems begins with the letter l_.
Normally when creating a railway vehicle,
only one esys is created per vehicle and that coordinate system
is located approximately in the middle of the vehicle,
and other linear lsys are related to this esys.
It is good to have separate coordinate systems for all masses in the vehicle along the track,
because all masses are in different places along the track having different cant, curvature,
vertical lift,,, etc.
The speed of the Euler system is defined in argument Vo.
However if the speed along the track varies according to a speed profile,
a memory field can be inserted as an argument to lsys e_abs_bendrf.
Coordinate system lsys e_abs_bendrf is very similar to lsys e_abs_bend
which defines an ideal transition curve of type clothoid.
But coordinate system lsys e_abs_bendrf is more close to a transition curve we see in reality.
Because in reality the transition curve have rounded corners in the beginning and in the end.
Create masses
##
## Vehicle and track masses
## ========================
##
## mass m_rigid_6 m_name lsys acg bcg hcg m m m Jf Jk Jp
## ------------------------------------------------------------------------------------------------
mass m_rigid_6 car_1 lsc_1 accg_1 0.0 -hccg_1 mc_1 mc_1 mc_1 Jfc_1 Jkc_1 Jpc_1 # car-body
mass m_rigid_6 bog_11 lsb_11 0.0 0.0 -hbcg_11 mb_11 mb_11 mb_11 Jfb_11 Jkb_11 Jpb_11 # bogies
mass m_rigid_6 bog_12 lsb_12 0.0 0.0 -hbcg_12 mb_12 mb_12 mb_12 Jfb_12 Jkb_12 Jpb_12
#
mass fixpoint_6 grd_1 lsc_1 0.0 0.0 0.0 # ground points
mass fixpoint_6 grd_111 lsa_111 0.0 0.0 0.0
mass fixpoint_6 grd_112 lsa_112 0.0 0.0 0.0
mass fixpoint_6 grd_121 lsa_121 0.0 0.0 0.0
mass fixpoint_6 grd_122 lsa_122 0.0 0.0 0.0
##
## Create wheelsets
## ==============================================================
substruct create_axl [
mass m_rigid_6 axl_$1 lsa_$1 0. 0. -ro_$1 ma_$1 ma_$1 ma_$1 Jfa_$1 Jka_$1 Jpa_$1
constr fix_free_1 axl_$1.k= 0.
initval set_var axl_$1.vk= -Vo/ro_$1
]
in_substruct create_axl [ 111 ]
in_substruct create_axl [ 112 ]
in_substruct create_axl [ 121 ]
in_substruct create_axl [ 122 ]
##
## Create track-pieces
## ==============================================================
substruct create_trc [
mass m_rigid_6f trc_$1 lsa_$1 0. 0. 0. 0. myt_$1 mzt_$1 Jft_$1 0. 0.
constr fix_rigid_1 trc_$1 x 0. constr fix_rigid_1 trc_$1 z 0.
constr fix_rigid_1 trc_$1 f 0. constr fix_rigid_1 trc_$1 k 0. constr fix_rigid_1 trc_$1 p 0.
]
in_substruct create_trc [ 111 ]
in_substruct create_trc [ 112 ]
in_substruct create_trc [ 121 ]
in_substruct create_trc [ 122 ]
The masses of the bodies are variables defined in the
property file vhedat/BoBo.propf.
In this file the masses are named mc_1, mb_11, mb_12 ,,, etc.
These variables cannot be found in the main memory of the program,
because they have not been defined.
But the variable namnes contains an underscore sign which means that if not the variable name can be found
the program shall trunkate the name of the variable and make a new search.
After trunkation of the variable names the program will find the variables mc_, mb_, ma_ ,,, etc.
Which was defined in the beginning of the vhedat/BoBo.propf-file.
The wheelset and the piece of track under the wheelset requires more than one line of input data.
Therefore it is convinient to write the input data in a substructure in order to reduce numer of
lines in the input data file.
Calculation of creep and creep forces
Calculation of creep and creep forces are made by the function func wr_coupl_pe3
which is a very big function and requires many arguments.
##
## Calculation of creep and creepforces between wheels and rails
## ==============================================================
substruct wr_coupl_pe3 [
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
1 # Type of contact normal to the contact surface
#
axl_$1 # Body wheel right side
axl_$1 # Body wheel left side
trc_$1 # Body track
ro_$1r # Nominal wheel radius right wheel
42e6 # kyrt_$1r # Lateral stiffness rail - track
75e6 # kzrt_$1r # Vertical stiffness rail - track
-kmba.F0_$1+ma_$1/2*9.81 # kzrt.F0_$1r # Vertical prestress force rail - track
400e3 # cyrt_$1r # Lateral damping rail - track
1600e3 # czrt_$1r # Vertical damping rail - track
bo_$1r # Lateral semi-distance to nominal running circle, right side
ro_$1l # Nominal wheel radius left wheel
42e6 # kyrt_$1l # Lateral stiffness rail - track
75e6 # kzrt_$1l # Vertical stiffness rail - track
-kmba.F0_$1+ma_$1/2*9.81 # kzrt.F0_$1l # Vertical prestress force rail - track
400e3 # cyrt_$1l # Lateral damping rail - track
1600e3 # czrt_$1l # Vertical damping rail - track
-bo_$1l # Lateral semi-distance to nominal running circle, left side
#
cp1_$1r # Name of contact point #1 right side
trc_$1 cp1_$1r.ksi cp1_$1r.bo 0. # Contact on track
axl_$1 0. cp1_$1r.bo 0. # Contact on wheel/wheelset
mu_$1r1 # Coefficient of friction
2.05e11 .3 # Modulus of elasticity and Poisson's ratio
mu_$1r1/.6 mu_$1r1/.6 mu_$1r1/.6 # Creepage reduction due to contaminated rail surface
-kmba.F0_$1+ma_$1/2*9.81 2400e6 # Prestress force and stiffness normal to the surface
#
cp1_$1l
trc_$1 cp1_$1l.ksi cp1_$1l.bo 0. # Contact on track
axl_$1 0. cp1_$1l.bo 0. # Contact on wheel/wheelset
mu_$1l1 # Coefficient of friction
2.05e11 .3 # Modulus of elasticity and Poisson's ratio
mu_$1l1/.6 mu_$1l1/.6 mu_$1l1/.6 # Creepage reduction due to contaminated rail surface
-kmba.F0_$1+ma_$1/2*9.81 2400e6 # Prestress force and stiffness normal to the surface
#
#
cp2_$1r
trc_$1 cp2_$1r.ksi cp2_$1r.bo 0. # Contact on track
axl_$1 0. cp2_$1r.bo 0. # Contact on wheel/wheelset
mu_$1r2 # Coefficient of friction
2.05e11 .3 # Modulus of elasticity and Poisson's ratio
mu_$1r2/.6 mu_$1r2/.6 mu_$1r2/.6 # Creepage reduction due to contaminated rail surface
0. 2400e6 # Prestress force and stiffness normal to the surface
#
cp2_$1l
trc_$1 cp2_$1l.ksi cp2_$1l.bo 0. # Contact on track
axl_$1 0. cp2_$1l.bo 0. # Contact on wheel/wheelset
mu_$1l2 # Coefficient of friction
2.05e11 .3 # Modulus of elasticity and Poisson's ratio
mu_$1l2/.6 mu_$1l2/.6 mu_$1l2/.6 # Creepage reduction due to contaminated rail surface
0. 2400e6 # Prestress force and stiffness normal to the surface
#
#
cp3_$1r
trc_$1 cp3_$1r.ksi cp3_$1r.bo 0. # Contact on track
axl_$1 0. cp3_$1r.bo 0. # Contact on wheel/wheelset
mu_$1r3 # Coefficient of friction
2.05e11 .3 # Modulus of elasticity and Poisson's ratio
mu_$1r3/.6 mu_$1r3/.6 mu_$1r3/.6 # Creepage reduction due to contaminated rail surface
0. 2400e6 # Prestress force and stiffness normal to the surface
#
cp3_$1l
trc_$1 cp3_$1l.ksi cp3_$1l.bo 0. # Contact on track
axl_$1 0. cp3_$1l.bo 0. # Contact on wheel/wheelset
mu_$1l3 # Coefficient of friction
2.05e11 .3 # Modulus of elasticity and Poisson's ratio
mu_$1l3/.6 mu_$1l3/.6 mu_$1l3/.6 # Creepage reduction due to contaminated rail surface
0. 2400e6 # Prestress force and stiffness normal to the surface
]
in_substruct wr_coupl_pe3 [ 111 ]
in_substruct wr_coupl_pe3 [ 112 ]
in_substruct wr_coupl_pe3 [ 121 ]
in_substruct wr_coupl_pe3 [ 122 ]
Animate track irregularities in GPLOT
In order to see the track irregularities in program GPLOT.
Rail bodies must be created.
The positions of the rail-bodies are controlled by the variables: tral$1$2.y, tral$1$2.z, tral$1$2.k and tral$1$2.p.
##
## Animate track irregularities in GPLOT
## ======================================
substruct animate_rails [
mass fixpoint_6 rail_$1$2 lsa_$1 0. $3bo_ 0.
no_warning func copy rail_$1$2.y= tral$1$2.y
no_warning func copy rail_$1$2.z= tral$1$2.z
no_warning func copy rail_$1$2.k= tral$1$2.k
no_warning func copy rail_$1$2.p= tral$1$2.p
]
in_substruct animate_rails [ 111 l - ]
in_substruct animate_rails [ 111 r + ]
in_substruct animate_rails [ 112 l - ]
in_substruct animate_rails [ 112 r + ]
in_substruct animate_rails [ 121 l - ]
in_substruct animate_rails [ 121 r + ]
in_substruct animate_rails [ 122 l - ]
in_substruct animate_rails [ 122 r + ]
Regulate the longitudinal position of the vehicle
In long simulations the speed of the vehicle will drop because of dissipated energy in dampers and energy dissipation in the contact point between wheel and rail.
In some simulations a speed profile has been defined, see Create local coordinate systems above.
Therefore there is necessary to regulate the longitudinal position of the vehicle.
In the simple case a linear spring and damper can be connected to the body of the vehicle:
##
## Longitudinal stiffness connecting the car-body to the lsc_1 coordinate system.
## (In order to keep the speed up during long simulations)
## ===================================================================================
func const mvhe_1= mc_1+mb_11+mb_12+ma_111+Jka_111/ro_111^2+ma_112+Jka_112/ro_112^2+ma_121+Jka_121/ro_121^2+ma_122+Jka_122/ro_122^2
coupl k_lin kxcg1 car_1 x 0 0 -hccg_1*.6 grd_1 x 0 0 -hccg_1*.6 (2*pi*.25)^2*mvhe_1 # fo= 0.25[Hz]
coupl c_lin cxcg1 car_1 x 0 0 -hccg_1*.6 grd_1 x 0 0 -hccg_1*.6 4*pi*.7*.25*mvhe_1 # zeta=0.7
The total rolling mass of the vehicle also includes the rotation energy of the wheelsets Jka_/ro_^2
The spring and damper is attached to the vehicle at coordinate (0., 0., -hccg_1*.6)
The height -hccg_1*.6 approximately corresponds to the total c.g. of the vehicle taken into account the heights of all masses in the model.
The stiffness (2*pi*.25)^2*mvhe_1 will give a eigen frequency of 0.25 [Hz] in longitudinal direction for the whole vehicle.
The damping 4*pi*.7*.25*mvhe_1 will give a relative damping of 70% for the longitudinal eigen frequency.
A better model of the longitudinal regulator can be created with the following code:
##
## Add pitch moment on the wheelsets
## (In order to follow a speed profile)
## ===================================================================================
func const fxcg= 0.25
func const mvhe_1= mc_1+mb_11+mb_12+ma_111+Jka_111/ro_111^2+ma_112+Jka_112/ro_112^2+ma_121+Jka_121/ro_121^2+ma_122+Jka_122/ro_122^2
func const Kreg_1= (2*pi*fxcg)^2*mvhe_1*ro_1/4
func const Creg_1= 4*pi*.70*fxcg*mvhe_1*ro_1/4
func operp car_.x = ( car_1.x * mc_1 + bog_11.x * mb_11 + bog_12.x * mb_12 +
axl_111.x * ma_111 + axl_112.x * ma_112 + axl_121.x * ma_121 + axl_122.x * ma_122 ) / mvhe_1
func operp car_.vx= ( car_1.vx * mc_1 + bog_11.vx * mb_11 + bog_12.vx * mb_12 +
axl_111.vx * ma_111 + axl_112.vx * ma_112 + axl_121.vx * ma_121 + axl_122.vx * ma_122 ) / mvhe_1
#
func mul MtractionK_1= Kreg_1 car_.x
func mul MtractionC_1= Creg_1 car_.vx
func add Mtraction_1= MtractionK_1 MtractionC_1
func lpass2_0 MtractionF1_1= Mtraction_1 5. .9239 # Second order low pass filter, start value equal to 0(zero)
func lpass2_0 MtractionF2_1= MtractionF1_1 5. .3827 # Second order low pass filter, start value equal to 0(zero)
#
func incr axl_111.Mk= MtractionF2_1
func incr axl_112.Mk= MtractionF2_1
func incr axl_121.Mk= MtractionF2_1
func incr axl_122.Mk= MtractionF2_1
Here the longitudinal position of the vehicle is regulated via the creep-forces between wheel and rail.
This corresponds what also happens in reality.
N.B. If a speed profile given in Create local coordinate systems is supposed to be followed.
Please make sure that available friction between wheel and rail is enough,
otherwise the pitch velocity of the wheelsets will go to infinity.
An even better model can be created if the regulating force is created by applying a contact force between the wheelset and the bogie frame on the cog-wheels in the gearbox.
Acceleration points
##
## Acceleration response points on carbody floor
## **********************************************
##
## func accp_bodyf f_name m_name a b h
## --------------------------------------------------
func accp_bodyf car$1b1 car_$1 acb 0.0 -hfloor
func accp_bodyf car$1.m car_$1 0.0 0.0 -hfloor
func accp_bodyf car$1b2 car_$1 -acb 0.0 -hfloor
Acceleration points for ride index calculations must be specified.
The jerk can be obtained by derivating the acceleration variables
in the func deriv-command.
The derivation can also be done in the post processor MPLOT
by the filt deriv-command.
Position points
##
## Pantograph sway
## ***********************************************
##
## func pos_rlsys2 f_name m_name lsys a b h
## ---------------------------------------------------------
func pos_rlsys2 car$1b1 car_$1 lsb_$11 acb 0.0 -5.6
func pos_rlsys2 car$1b2 car_$1 lsb_$12 -acb 0.0 -5.6
Position points for different points in the vehicle can be specified.
Coordinate system in which the displacements should be calculated
can also be selected in command func pos_rlsys2.
In example above the motion in the carbody is expressed in the coordinate
of the bogies.
Graphical representation of the bodies
This section of the input data file is not read program CALC.
Only program GPLOT will read these lines:
##
## Graphical representation of the bodies
## ==============================================
body box_mass_733 car_1 acb_1+2.25 1.43 0.7 acb_1+1.38 1.2 -1.7
acb_1+2.25 -1.43 0.7 acb_1+1.38 -1.2 -1.7
-(acb_1+2.25) 1.43 0.7 -(acb_1+2.25) 1.2 -1.7
-(acb_1+2.25) -1.43 0.7 -(acb_1+2.25) -1.2 -1.7
insert file vhedat/body_car_X2000.ins
# insert file vhedat/body_car_Rc.ins
#
body box_mass bog_11 aba_11+.25 -aba_11-.25 1. -1. 0.15 -.2
body box_mass bog_12 aba_12+.25 -aba_12-.25 1. -1. 0.15 -.2
##
## body type m_name ro bo
## ---------------------------------------
body whe_set_mass axl_111 ro_111 bo_
body whe_set_mass axl_112 ro_112 bo_
body whe_set_mass axl_121 ro_121 bo_
body whe_set_mass axl_122 ro_122 bo_
#
body opengl_mass axl_111 1 1 1 1 CYL_W_DISK .35 13 .45 .55 # radius N H1 H2 brake disks
body opengl_mass axl_111 1 1 1 1 CYL_W_DISK .35 13 -.45 -.55 # radius N H1 H2
body opengl_mass axl_112 1 1 1 1 CYL_W_DISK .35 13 .45 .55 # radius N H1 H2
body opengl_mass axl_112 1 1 1 1 CYL_W_DISK .35 13 -.45 -.55 # radius N H1 H2
body opengl_mass axl_121 1 1 1 1 CYL_W_DISK .35 13 .45 .55 # radius N H1 H2
body opengl_mass axl_121 1 1 1 1 CYL_W_DISK .35 13 -.45 -.55 # radius N H1 H2
body opengl_mass axl_122 1 1 1 1 CYL_W_DISK .35 13 .45 .55 # radius N H1 H2
body opengl_mass axl_122 1 1 1 1 CYL_W_DISK .35 13 -.45 -.55 # radius N H1 H2
##
## body type m_name polygon
## ------------------------------------------------------------------------------
func const B_trc_1= 1.2675 # Semi-length of sleepers
body box_mass trc_111 0.5 -.5 B_trc_1 -B_trc_1 0.340 0.172
body box_mass rail_111r 0.5 -.5 0.0325 -.0325 0.172 0.
body box_mass rail_111l 0.5 -.5 0.0325 -.0325 0.172 0.
body box_mass trc_112 0.5 -.5 B_trc_1 -B_trc_1 0.340 0.172
body box_mass rail_112r 0.5 -.5 0.0325 -.0325 0.172 0.
body box_mass rail_112l 0.5 -.5 0.0325 -.0325 0.172 0.
body box_mass trc_121 0.5 -.5 B_trc_1 -B_trc_1 0.340 0.172
body box_mass rail_121r 0.5 -.5 0.0325 -.0325 0.172 0.
body box_mass rail_121l 0.5 -.5 0.0325 -.0325 0.172 0.
body box_mass trc_122 0.5 -.5 B_trc_1 -B_trc_1 0.340 0.172
body box_mass rail_122r 0.5 -.5 0.0325 -.0325 0.172 0.
body box_mass rail_122l 0.5 -.5 0.0325 -.0325 0.172 0.
Wear and RCF-indexes
Previously in the input data file was a substructure wear_RCF defined.
The purpose of wear_RCF was to calculate Wear and RCF-indexes.
Now use this substructure on the wheels that we are interested in:
##
## Calculate wear and RCF indexes
## (substruct wear_RCF is defined in file vhedat/std_inserts.ins)
## ==============================================================
in_substruct wear_RCF [ 111l ]
in_substruct wear_RCF [ 111r ]
in_substruct wear_RCF [ 112l ]
in_substruct wear_RCF [ 112r ]
Storing results for animation in GPLOT
The following section defines which kind of data to be written on the GPdat-file:
##
## Write to GPdat-file for animations in program GPLOT
## ==============================================================
s_var gpdat_r1 # Create a gp-file for animation in gplot
#
# s_var gpdat_force1 kzcb11r.F1y
# s_var gpdat_force1 kzcb11l.F1y
#
if_then_init .exist. cp1_111r.Fx
s_var gpdat_force1 cp1_111r.Fx s_var gpdat_force1 cp1_111r.Fy s_var gpdat_force1 cp1_111r.Fz
s_var gpdat_force1 cp1_111l.Fx s_var gpdat_force1 cp1_111l.Fy s_var gpdat_force1 cp1_111l.Fz
s_var gpdat_force1 cp1_112r.Fx s_var gpdat_force1 cp1_112r.Fy s_var gpdat_force1 cp1_112r.Fz
s_var gpdat_force1 cp1_112l.Fx s_var gpdat_force1 cp1_112l.Fy s_var gpdat_force1 cp1_112l.Fz
endif
if_then_init .exist. cp2_111r.Fx
s_var gpdat_force1 cp2_111r.Fx s_var gpdat_force1 cp2_111r.Fy s_var gpdat_force1 cp2_111r.Fz
s_var gpdat_force1 cp2_111l.Fx s_var gpdat_force1 cp2_111l.Fy s_var gpdat_force1 cp2_111l.Fz
s_var gpdat_force1 cp2_112r.Fx s_var gpdat_force1 cp2_112r.Fy s_var gpdat_force1 cp2_112r.Fz
s_var gpdat_force1 cp2_112l.Fx s_var gpdat_force1 cp2_112l.Fy s_var gpdat_force1 cp2_112l.Fz
endif
if_then_init .exist. cp3_111r.Fx
s_var gpdat_force1 cp3_111r.Fx s_var gpdat_force1 cp3_111r.Fy s_var gpdat_force1 cp3_111r.Fz
s_var gpdat_force1 cp3_111l.Fx s_var gpdat_force1 cp3_111l.Fy s_var gpdat_force1 cp3_111l.Fz
s_var gpdat_force1 cp3_112r.Fx s_var gpdat_force1 cp3_112r.Fy s_var gpdat_force1 cp3_112r.Fz
s_var gpdat_force1 cp3_112l.Fx s_var gpdat_force1 cp3_112l.Fy s_var gpdat_force1 cp3_112l.Fz
endif
#
s_var gpdat_wheel_info 111r lsa_111.b $genkpf/../w_prof/EN13715.2006/S1002t32.5_EN13715.wheel
s_var gpdat_wheel_info 111l lsa_111.b $genkpf/../w_prof/EN13715.2006/S1002t32.5_EN13715.wheel
s_var gpdat_wheel_info 112r lsa_112.b $genkpf/../w_prof/EN13715.2006/S1002t32.5_EN13715.wheel
s_var gpdat_wheel_info 112l lsa_112.b $genkpf/../w_prof/EN13715.2006/S1002t32.5_EN13715.wheel
#
if_then_char_init ckpfr .eq. "Variable_W/R-geom"
s_var gpdat_rail_info_right -100 $genkpf/../r_prof/bv50/bv50i30.rail
0 $genkpf/../r_prof/bv50/bv50i30.rail
5 $genkpf/../r_prof/bv50_worn/worn_rail_low3.rail
300 $genkpf/../r_prof/bv50_worn/worn_rail_low3.rail
305 $genkpf/../r_prof/bv50/bv50i30.rail
320 $genkpf/../r_prof/bv50/bv50i30.rail
325 $genkpf/../r_prof/bv50_worn/worn_rail_high3.rail
620 $genkpf/../r_prof/bv50_worn/worn_rail_high3.rail
625 $genkpf/../r_prof/bv50/bv50i30.rail
750 $genkpf/../r_prof/bv50/bv50i30.rail
#
s_var gpdat_rail_info_left -100 $genkpf/../r_prof/bv50/bv50i30.rail
0 $genkpf/../r_prof/bv50/bv50i30.rail
5 $genkpf/../r_prof/bv50_worn/worn_rail_high3.rail
300 $genkpf/../r_prof/bv50_worn/worn_rail_high3.rail
305 $genkpf/../r_prof/bv50/bv50i30.rail
320 $genkpf/../r_prof/bv50/bv50i30.rail
325 $genkpf/../r_prof/bv50_worn/worn_rail_low3.rail
620 $genkpf/../r_prof/bv50_worn/worn_rail_low3.rail
625 $genkpf/../r_prof/bv50/bv50i30.rail
750 $genkpf/../r_prof/bv50/bv50i30.rail
else
s_var gpdat_rail_info_right -100 $genkpf/../r_prof/uic60/uic60i40.rail
3000 $genkpf/../r_prof/uic60/uic60i40.rail
s_var gpdat_rail_info_left -100 $genkpf/../r_prof/uic60/uic60i40.rail
3000 $genkpf/../r_prof/uic60/uic60i40.rail
endif
If no "s_var gpdat_*"-command can be found in input data, no GPdat-file will be written.
For long and big simulations it can be a good idea to turn off the output to the GPdat-file,
because writing a lot of data slows down the computation speed.
Storing results for post processing in MPLOT
In order to save harddisk space and computation time,
the variables for storing must be specified by the user.
By using substructures
the specification of saved variables can be made very compact.
##
## Write to MPdat-file for later postprocessing in program MPLOT
## =============================================================
in_substruct save_car1 [ 1 ]
#
in_substruct save_bog1 [ 11 ]
in_substruct save_bog1 [ 12 ]
#
in_substruct save_axl1 [ 111 ]
in_substruct save_axl1 [ 112 ]
in_substruct save_axl1 [ 121 ]
in_substruct save_axl1 [ 122 ]
#
in_substruct save_creep1 [ 111l ]
in_substruct save_creep1 [ 111r ]
The substructures save_car1, save_bog1 and save_axl1 were earlier defined in
file vhedat/std_inserts.ins.
Secondary springs
##
## Secondary suspension: Coil springs
## ==================================
coupl k3_l kzcb11r # Name, first spring, right side
car_1 acb_1 kzcb.B -kzcb.H # Body #1 and its attachment point
bog_11 0.0 kzcb.B -kzcb.H # Body #2 and its attachment point
kxcb_11r kycb_11r kzcb_11r # Properties
kzcb.hs .5 # Height of spring
esys_1 m # Coordinate system and direction of action
bog_11.f bog_11.k bog_11.p # Spring tilted according to the bogie
#
coupl k3_l kzcb11l # Name, first spring, left side
car_1 acb_1 -kzcb.B -kzcb.H # Body #1 and its attachment point
bog_11 0.0 -kzcb.B -kzcb.H # Body #2 and its attachment point
kxcb_11l kycb_11l kzcb_11l # Properties
kzcb.hs .5 # Height of spring
esys_1 m # Coordinate system and direction of action
bog_11.f bog_11.k bog_11.p # Spring tilted according to the bogie
#
coupl k3_l kzcb12r # Name, second spring, right side
car_1 -acb_1 kzcb.B -kzcb.H # Body #1 and its attachment point
bog_12 0.0 kzcb.B -kzcb.H # Body #2 and its attachment point
kxcb_12r kycb_12r kzcb_12r # Properties
kzcb.hs .5 # Height of spring
esys_1 m # Coordinate system and direction of action
bog_12.f bog_12.k bog_12.p # Spring tilted according to the bogie
#
coupl k3_l kzcb12l # Name, second spring, left side
car_1 -acb_1 -kzcb.B -kzcb.H # Body #1 and its attachment point
bog_12 0.0 -kzcb.B -kzcb.H # Body #2 and its attachment point
kxcb_12l kycb_12l kzcb_12l # Properties
kzcb.hs .5 # Height of spring
esys_1 m # Coordinate system and direction of action
bog_12.f bog_12.k bog_12.p # Spring tilted according to the bogie
For vertical coil springs subjected to a vertical load is this k3_l-coupling developed.
Only three spring stiffnesses is required in input data: kxcbp_$11r, kycbp_$11r and kzcbp_$11r,
pure longitudinal stiffness, pure lateral stiffness and pure vertical stiffness respectively.
Pure longitudinal stiffness refers to the stiffness when the coil spring is subjected to a
pure shear deformation, no angular displacements of the ends of the spring.
All other non-diagonal stiffnesses is automatically calculated in the k3_l-coupling,
for further details please see coupl k3_l.
Anti-roll bars
##
## Secondary suspension: Anti-roll bars
## ====================================
##
## coupl k c_name body1 a1 b1 h1 body2 a2 b2 h2 prop esys dire
## -----------------------------------------------------------------------------------------
coupl k kfcb11 car_1 acb_1 0.0 -kfcb.H bog_11 0.0 0.0 -kfcb.H kfcb_11 esys_1 f
coupl k kfcb12 car_1 -acb_1 0.0 -kfcb.H bog_12 0.0 0.0 -kfcb.H kfcb_12 esys_1 f
In couplings without length the direction of action must be specified.
Traction rods
##
## Secondary suspension: Traction rods
## ===================================
##
## c_name body1 a1 b1 h1 body2 a2 b2 h2 prop esys dire
## -----------------------------------------------------------------------------------------------
coupl k ktr11 car_1 ktr.Ac ktr.Bc -ktr.Hc bog_11 ktr.Ab ktr.Bb -ktr.Hb ktr_11 esys_1 c
coupl k ktr12 car_1 -ktr.Ac ktr.Bc -ktr.Hc bog_12 -ktr.Ab ktr.Bb -ktr.Hb ktr_12 esys_1 c
coupl c ctr11 car_1 ktr.Ac ktr.Bc -ktr.Hc bog_11 ktr.Ab ktr.Bb -ktr.Hb ctr_11 esys_1 c
coupl c ctr12 car_1 -ktr.Ac ktr.Bc -ktr.Hc bog_12 -ktr.Ab ktr.Bb -ktr.Hb ctr_12 esys_1 c
In couplings with length the direction of action can be controlled by the
ends of the coupling.
Direction c is a fix direction through the simulation.
Direction cu updates the direction continuously through the simulation.
Yaw dampers
##
## Secondary suspension: Yaw viscous dampers
## =========================================
##
## c_name body1 a1 b1 h1 body2 a2 b2 h2 prop_k prop_c esys dire
## -------------------------------------------------------------------------------------------------------------------
coupl kc cccb11r car_1 cccb.Ac cccb.Bc -cccb.Hc bog_11 cccb.Ab cccb.Bb -cccb.Hb kccb_11r cccb_11r esys_1 c
coupl kc cccb11l car_1 cccb.Ac -cccb.Bc -cccb.Hc bog_11 cccb.Ab -cccb.Bb -cccb.Hb kccb_11l cccb_11l esys_1 c
coupl kc cccb12r car_1 -cccb.Ac cccb.Bc -cccb.Hc bog_12 -cccb.Ab cccb.Bb -cccb.Hb kccb_12r cccb_12r esys_1 c
coupl kc cccb12l car_1 -cccb.Ac -cccb.Bc -cccb.Hc bog_12 -cccb.Ab -cccb.Bb -cccb.Hb kccb_12l cccb_12l esys_1 c
Especially in yaw-dampers it is important to model the serial flexibility in the damper,
this is done in the kc-element.
Track model
The properties of the track affects the behavior of the vehicle,
especially the track forces at higher frequencies.
Typically the track flexibility v.s. frequency looks as:
The following track model has been developed to follow the above track properties:
Comparisions between measured and calculated track forces show overall good agreement.
Measured results were filtered in a 100[Hz] low-pass filter, why forces at higher frequencies not could be compared.
Therefore also the simulated results were filtered with the same low-pass filter.
Vertical forces left wheel:
Vertical forces right wheel:
Lateral forces left wheel:
Lateral forces right wheel:
PSD of vertical forces left and right wheel:
PSD of lateral forces left and right wheel:
Frequency response excitation
##
## Select type of excitation for program FRESP
## ==========================================================
# func char cexcitation Track_Vertical.001
# func char cexcitation Track_Lateral.001
insert file track/trc_fexcit.ins
The definition of different spectras for excitation in program FRESP are made in a subfile
track/trc_fexcit.ins.
Structural flexibility
##
## Read flexible parameters for the carbody
## ==========================================================
if_then_char_init CalcType .ne. NPICK
insert file npickr/$IDENT.npickr
endif
Output from program NPICK is written in a way that the result directly can be
inserted in the input data for program CALC.
In order to avoid program NPICK to read this line before the result file npickr/$IDENT.npickr
has been created, the insert command must be put inside a if_then_char_init-statement.
Initial values
##
## Read initial values from GPdat-file, generated by program QUASI
## ===============================================================
if_then_char_init CalcType .eq. TSIM
.or. CalcType .eq. MODAL
initval read_gpdat gp/$IDENT.gp 1
endif
Initial values from a previous calculation in TSIM or QUASI can be read.
In this case it is assumed the program mode QUASI should create this file gp/$IDENT.gp.
In order to avoid program mode QUASI to read this line before the result file gp/$IDENT.gp
is created, the initval command must be put inside a if_then_char_init-statement.
Secant conicity
The secant conicity according to the definition can be calculated if the following code is inserted in the input data file:
###
### Calculate secant conicity
#[-]{ ==========================================================
substruct secant_conicity [
func operp cp_$1r.dr= ( cp1_$1r.Fn * cp1_$1r.dr +
cp2_$1r.Fn * cp2_$1r.dr +
cp3_$1r.Fn * cp3_$1r.dr ) /
( cp1_$1r.Fn + cp2_$1r.Fn + cp3_$1r.Fn )
func operp cp_$1l.dr= ( cp1_$1l.Fn * cp1_$1l.dr +
cp2_$1l.Fn * cp2_$1l.dr +
cp3_$1l.Fn * cp3_$1l.dr ) /
( cp1_$1l.Fn + cp2_$1l.Fn + cp3_$1l.Fn )
func operp cp_$1.lam= ( cp_$1r.dr - cp_$1l.dr ) / 2 / axl_$1.y
func u_lim cp_$1.lam= 1.2
func l_lim cp_$1.lam= 0.
s_var sngl cp_$1.lam
]
in_substruct secant_conicity [ 111 ]
in_substruct secant_conicity [ 112 ]
in_substruct secant_conicity [ 121 ]
in_substruct secant_conicity [ 122 ]
#[-]} - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Plotting of the secant conicity can be made with the input data code:
filt lpass1_0 .2 cp_111.lam cp_111.lamF
filt lpass1_0 .2 cp_112.lam cp_112.lamF
filt lpass1_0 .2 cp_121.lam cp_121.lamF
filt lpass1_0 .2 cp_122.lam cp_122.lamF
Page -------------------------
ygridint= 1 xgridint= 2
y_bot= 0 yint/cm= .1 xax_yval= bot x_left= auto xint/cm= auto
Diagram 11
Curve yvar= cp_111.lam
Curve yvar= cp_111.lamF
Diagram 12
Curve yvar= cp_112.lam
Curve yvar= cp_112.lamF
Diagram 21
Curve yvar= cp_121.lam
Curve yvar= cp_121.lamF
Diagram 22
Curve yvar= cp_122.lam
Curve yvar= cp_122.lamF
EndPage
Stop conditions
##
## Stop the simulation at the end of the track,
## if not tstop will end the simulation first.
## ==========================================================
if_then lsa_111.pn .gt. Xtrac_stop
func print06_char_all " "
func print06_char_all " Execution interrupted due to lsa_111.pn > Xtrac_stop"
func print06_char_all " ----------------------------------------------------"
func stop
endif
Normally the time simulation stops when tstop has been reached.
If the user likes stop the simulation because of another event,
the user can write an if_then-endif-statement according the above example.
Recommended names of masses and couplings
The user can use any names he or she wants to when creating the masses and couplings,
but it is recommended to follow a convention in order
to more easily read input data files written by other people.
Recommended names of the masses:
| car_1 |
car-body |
| bog_11 |
bogie frame |
| bol_11 |
bolster beam |
| axl_111 |
Axle and/or wheelset |
| whe_111r |
Free rotating wheel or resilient wheel |
| trc_111 |
The accompanying piece of track under each wheelset |
| grd_111 |
The fix point under each piece of track |
Numbering system
As can be seen in the above:
One digit refers to the number of the vehicle.
Two digits refers to the number of the bogie or bolster beam.
The first bogie in the first vehicle is denoted 11,
the second bogie in the first vehicle is denoted 12,
the first bogie in the second vehicle is denoted 21,,, etc.
Three digits refers to the number of the wheelset, track piece or ground.
The first axle in the first bogie in the first vehicle is denoted 111,
the second axle in the first bogie in the first vehicle is denoted 112,
the first axle in the second bogie in the first vehicle is denoted 121,,, etc.
Recommended names of the couplings:
In principal a name of a coupling consists of:
four characters,
number of the coupling and
r for right or l for left.
The first introductionary characters have the following meaning:
| Character #1 |
= |
Type of coupling:
k for spring
c for viscous damper
f for friction damper
|
| Character #2 |
= |
Direction of action:
x for longitudinal
y for lateral
z for vertical
f for roll
k for pitch
p for yaw
c for direction of coupling
m for matrix direction
|
| Character #3 |
= |
Body connected to the first end of the coupling:
c for car-body
b for bogie
l for bolster
a for axel
r for rail
t for track
g for ground
|
| Character #4 |
= |
Body connected to the second end of the coupling:
c for car-body
b for bogie
l for bolster
a for axel
r for rail
t for track
g for ground
|
Examples:
| kzcb11r |
Secondary spring |
| kfcb11 |
Anti-roll bar |
| kycbs11 |
Secondary lateral bumpstop |
| cycb11r |
Secondary lateral hydraulic damper |
| czcb11r |
Secondary vertical hydraulic damper |
| cccb11r |
Yaw damper |
| kzba111r |
Primary spring |
| czba111r |
Primary vertical hydraulic damper |
| kytg111 |
Lateral track stiffness |
| cytg111 |
Lateral damping in track |
Names generated in substructure wr_coupl:
| tral111.y | Lateral displacement of track center line due to track irregularity |
| tral111.z | Vertical displacement of track center line due to track irregularity |
| tral111.f | Cant error due to track irregularity |
| tral111.k | Pitch error due to track irregularity |
| tral111.p | Yaw error due to track irregularity |
| |
| tral111.vy | Lateral velocity of track center line due to track irregularity |
| tral111.vz | Vertical velocity of track center line due to track irregularity |
| |
| tral111r.y | Lateral displacement right rail |
| tral111l.y | Lateral displacement left rail |
| tral111r.z | Vertical displacement right rail |
| tral111l.z | Vertical displacement left rail |
| |
| tral111r.vy | Lateral velocity right rail |
| tral111l.vy | Lateral velocity left rail |
| tral111r.vz | Vertical velocity right rail |
| tral111l.vz | Vertical velocity left rail |
| |
| cp_111r.eta | Relative wheel-rail displacement, right side |
| cp_111l.eta | Relative wheel-rail displacement, left side |
| cpt_111r.dr | Change in wheel radius right wheel |
| cpt_111l.dr | Change in wheel radius left wheel |
| cpt_111r.gam | Angle of contact point right wheel |
| cpt_111l.gam | Angle of contact point left wheel |
| cpt_111r.z | Wheel lift right wheel |
| cpt_111l.z | Wheel lift left wheel |
| cpt_111r.ro | Wheel-rail curvature difference, tread, right wheel |
| cpt_111l.ro | Wheel-rail curvature difference, tread, left wheel |
| cpt_111r.a/b | The a/b-ratio of the contact ellipse, tread right wheel |
| cpt_111r.c | Geom. average radius of the contact ellipse c=sqrt(a*b), tread right wheel |
| cpt_111r.nux | Longitudinal creepage, tread, right wheel |
| cpt_111l.nuy | Lateral creepage, tread, right wheel |
| cpt_111r.spin | Spin creepage, tread, right wheel |
| cpt_111l.Fn | Contact force, tread, right wheel |
| cpt_111r.Fny | Creep force tangential to the contact surface, tread, right wheel |
| cpt_111l.Fx | Longitudinal force, tread, right wheel |
| cpt_111r.Fy | Lateral force, tread, right wheel |
| cpt_111l.Fz | Vertical force, tread, right wheel |
Miscellaneous
Vehicles for other gauges than 1435.
If a model of a vehicle not have the gauge of 1435[mm], please observe the following:
- Running preprocessor KPF
Set the following input data parameters to their appropriate values:
bo2,
gauge_to_origo,
iwheel_spacing and
iwheel_to_origo.
When running program kpf
- Change the semi-distance between the nominal running circles.
In gensys defined in the key-variable bo_.
The value of bo_ shall be set equal to (gauge+2*32.5e-3)/2.
The distance from the track gauge measuring point to the nominal running circles is often 32.5[mm].
However there are other definitions, please look at a drawing of your track.
- Gauge irregularities
In the track irregularity files
trac, trax
and trax_wdesign
the gauge signal column #4 contains the quasistatic value of the gauge.
In order to handle the gauge correct the track data file must be modified, so the
quasistatic value of column #4 corresponds to the value of the gauge.
Also define the key-variable gauge_average equal to the new gauge.
If any track data file for the new gauge not are available,
it is possible to use a track data file for nominal gauge
and fake another gauge by setting the key-variable gauge_average equal to 1435.
Please look under Modify track gauge for
more explanations of the key-variable gauge_average.
- Designed cant
By dividing the designed cant with 2*bo_ as described under
Designed track geometry above,
the cant will automatically be translated into radians independently of the gauge.
Therefore the designed cant will not be affected by the gauge.
- Cant irregularities
In the track irregularity files
trac, trax
and trax_wdesign
the cant signal column #5 is the height difference between left and right rail.
If the key-variable CMtrac is defined as described under
Track irregularities above,
the cant errors will be translated into radians automatically.
If any track data file for the new gauge not are available,
it is possible to use a track data file for nominal gauge
and fake another gauge by setting the key-variable CMtrac equal to 1/1500.
Home
Reference Manuals