Home    Search    Up    Reference Manuals    Return   

Users Manual for Program MPLOT

Table of contents

Introduction

Flow chart

Command line options

Pulldown menus

Mouse button control

Post processing
  Input data commands which controls post processing
  Calculate different ride comfort assessments
  Designing higher order filters

Plotting
   Introduction
   Input data at the lowest input data level
   Input data valid at level DIAGRAM
   Input data valid at level PAGE
   Input data valid at level MAIN
   All plotting commands in alphabetical order

Examples

Introduction

Program MPLOT reads result files written in MPdat format, having the file extension .id or .mp. Program MPLOT has two main functions:

1. Post-processing
   Algebraic operations, filtering, statistical evaluations and different transformations can be made. All available post-processing commands are documented under Input data commands which controls post processing.

2. Plotting
   Two- and three- dimensional plots of scalars and vectors. The user has possibility to select results from many different idents by adding the name of the ident enclosed in parenthesis after the name of the variable. All available plot-processing commands are documented under Input data commands which controls plotting.

Some notes on the input data reading:

• Input data is read in free format, valid separators between the input data are <space>, <comma>, <tab>, <equal sign> or <carriage return>. The commands are understood both in lower and upper case letters.

• Lines starting with a #-sign will be treated as commentary lines.

• Lines starting with a !-sign will be sent as a command to the UNIX system.

• In the description of the input data commands in this manual, certain simplifications have been made in order to reduce the text volume in this document. The simplifications are implemented according to the same method as listed in the user manual for the CALC program.
  The simplifications are:
  • Words enclosed between grave accents ` `
    The program expects to read a valid string, which provides a valid main- or sub- command. An error will occur if integer or real are read.

  • Words enclosed between a grave accent and an acute accent ` '
    The program expects to read a string which must be a variable previously defined in the input data. An error will occur if integer or real are read.

  • Words without accents
    The program expects to read data constants which comprise integer or real. An error will occur if the character is read.

  • Words which begin with a grave accent `
    At this stage, the program expects to read a character string or a data constant. If a string is read, the program will seek the variable which has been assigned that name and will store the address to the variable. If a data constant is read, the value will be stored directly in the memory.

  • Words which begin with signs and a grave accent +-`
    At this stage, the program accepts reading a variable or a constant. The variable or constant can have up to two preceding signs minus and/or plus.

  • Words which begin with signs and a grave accent in parenthesis (+-`)
    At this stage, the program accepts reading a variable or a constant. The variable or constant can have up to two preceding signs minus and/or plus. The parentheses imply that if a variable is read, its value will not be updated. Program CALC will only use the value of the variable at time=tstart.

Flow chart

The flow of data in GENSYS is carried out as follows:

Activity 1
The results from the calculation activity TSIM, FRESP, MODAL or QUASI are stored in MPdat-format on an output data file named '\$ident.id'. The variables stored in the *.id-file are defined in the CALC-command s_var.

Activity 2
Program MPLOT copies the contents of file '\$ident.id' into the files '\$ident.mp' and '\$ident.mp2', because it is much faster to read and write in direct access files. The files '\$ident.mp' and '\$ident.mp2' are also working as a memory for program MPLOT, holding all new vectors and scalars generated in the post processing commands. In the command line arguments -save_mp and -no_save_mp the user can control if the files '\$ident.mp' and '\$ident.mp2' shall be saved or not after the MPLOT activity.

Activity 3
Plots can be created by reading result data files from several idents at the same time. If *.mp- and *.mp2- files do exist they will be read and plotted, but if they do not exist program MPLOT will use the *.id-files.

Command line options

When launching program MPLOT the user can supply a number of command line options. The user can put his or hers favorite options in a file named gen_conf. File gen_conf is primarily searched in the local working directory. If file gen_conf not can be found in the local working directory, program MPLOT searches for file .gen_conf in the users home-directory. If no file can be found locally or in the \$HOME-directory, program MPLOT will read the file \$gensys/bin/gen_conf.

If not input data file and/or ident has been given among the command line options script MPLOT will prompt the user for these items.

Description of pulldown menus

If program MPLOT is started with the -interactive command line option. The following pulldown menu will appear at the top of the window:

Pulldown menu File

Pulldown menu Post

Pulldown menu Draw

Pushbutton Edit opens current page for editing.

Pushbutton Reload rereads and reloads current page after editing.
(N.B. Current file must be saved before it can be reread.)

Pushbutton New creates a new page.

The textfields to the right of the Edit-pushbutton shows current coordinate when mouse button #2 is pressed.

The radiobuttons to the right of the textfields, shows the number of current page.

Mouse button control

In the interactive version of program MPLOT

Post processing

Input data commands which controls post processing

In Mplot there are a number of commands which create new curves and scalars. This section was previously referred to as DYNPOST, but is today an integrated part in Mplot. The various mplot commands and the DYNPOST commands can be combined today. Input data for these commands are read in free format. Two principles govern input of the input data:

• Alt 1)
  first a main command is read, and directly after the main command all input data are read in a long row.
• Alt 2)
  first a main command is read, thereafter the input data is read by subcommands.

The two input methods can also be combined, e.g. the user can begin with the method 1) and then change to method 2), and vice versa.

When an input data variable is required "Iname" the user can choose to read the variable from an other ident if he put the name of the ident directly after the name and enclosed in parenthesis ex. "Iname(ident)"

The following post-processing commands are available at level MAIN in Mplot:
(the list begins with a brief summary)

Adds new points to a new or existing vector in the memory.

                                                          
  create_curve append_sngl  vname, tname, v_dim, values   
                                                          

Creates two vectors in the memory.
Command 'file_vpair_free' reads value-pairs from an external file. If a line in the external file 'file' begins with the letter # it will be regarded as a comment.

                                                                           
  create_curve file_vpair_free  tname, vname, t_dim, v_dim, format, file   
                                                                           

Creates a new vector in the memory, linearly increasing from vstart.

                                                                        
  create_curve linear_increasing  vname, vstart, vincr, npoints, v_dim  
                                                                        

Creates a new vector in the memory.

                                                        
  create_curve new_sngl  vname, tname, v_dim, values    
                                                        

Truncates an existing vector into a new vector.

                                                                                   
  create_curve truncate  new_yvar new_xvar  old_yvar old_xvar  +-`tstart +-`tstop  
                                                                                   

Directive to create a new scalar in current ident.

TOC:

Creates a scalar in memory, which is the first value in a variable.
This command is redundant, please use create_scalar curve_interp instead.

                                           
  create_scalar curve_first  pname= vname  
                                           

Creates a scalar in memory, interpolated from a variable.

                                           
  create_scalar curve_interp  pname= vname  tval  tname
                                           

Creates a scalar in memory, which is the last value in a variable.

                                           
  create_scalar curve_last  pname= vname  
                                           

Creates a scalar in memory, which is the sum of all the points of a variable.

                                          
  create_scalar curve_sum  pname= vname   
                                          

Creates a scalar in the memory, which is the maximum value of a variable.

                                                
  create_scalar  curve_vmax  pname= vname       
                                                

Creates a scalar in the memory, containing the X-value of the default X-axis, when the max value of vname was reached. (After a simulation the default X-axis are "time" for all variables)
Scalar pname can be used in command create_scalar curve_interp to find values of other variables that occurs at the same time as when vname reaches its maximum value.

                                                
  create_scalar  curve_vmax_x  pname= vname       
                                                

Creates a scalar in the memory, which is the minimum value of a variable.

                                                
  create_scalar  curve_vmin  pname= vname       
                                                

Creates scalars in the memory, containing all X-values for which variable vname is zero.

                                                
  create_scalar curve_zero  pname= vname        
                                                

Creates a new scalar in memory.

                                                
  create_scalar new  pname= pvalue  p_dim       
                                                

Directive to inspect the contents of current ident.
The output is written to file defined in directive CATFIL below.

Define the name of the file to which the CATALO-output above will be written.
If the file-name is " " or "no", the output will be written to standard output. The default value of file-name is "\$ident.cata".

Directive to delete a vector in current ident.

Directive to delete a scalar in current ident.

The ELSE statement is used when coding an IF_THEN-else decision statement. The keyword precedes an else-block, defined to be all the statements after the ELSE-statement up to, but not including the corresponding ENDIF-statement.

The command ENDIF concludes the statement IF_THEN.

Directive to generate curves with equidistant time steps.

Directive to filtrate in time domain. The command requires that the input variable has equidistant time steps.

Calculation of different types of Fourier spectras.
To make Fourier spectras of a variable, the steps in variable Tname must be equidistant. According to the Nyquist sampling theorem maximum frequency range in the created spectra is from -1/(2*DX) up to +1/(2*DX). Where DX is the equidistant step in Tname. If Tname equals variable time, DX equals tout.
Text file example    HTML example

Fourier series calculation of vectors and calculation of ride index. This command creates two curves (Ftname and Wzname) and one scalar (Wzscal), the ride index is stored in scalar Wzscal. Command FTWZ also writes information to the *.resu-file. The command requires that the input variable has equidistant time steps.

There are two ways in which the input data to the command FUNC can be written:

1. Method 1
   Indata_group begins with a sub-command which controls how the FUNC-command will work. The sub-commands are similar to the FUNC-commands in program CALC. See, Reading FUNC-commands with subcommands.
2. Method 2
   If indata_group not begins with a sub-command, the input data will be read in the same way as previously in MPLOT until Rel.9502. See, Reading FUNC-commands without subcommands.

Indata_group includes the subcommands `f_type` and input data(*) adapted to every subcommand. Here follows a brief summary of the subcommands available in FUNC. Thereafter, a more detailed description of each subcommands will be given.

abs	=	Calculates the absolute value of a variable.
add	=	Addition
acos	=	Calculates the arc-cos of a variable.
asin	=	Calculates the arc-sin of a variable.
atan	=	Calculates the arc tangent of a variable.
atan2	=	Calculates the arc tangent of two variables
cabs	=	Calculates the complex absolute value of two variables
cen_erri_595	=	Calculate the r.m.s. 95%th percentile of a variable accoring to CEN TC_256 WG_7 and ERRI B153
const	=	Creates a new scalar or vector.
copy	=	Copies a variable to a new variable.
cos	=	Calculates the cosinus of a variable.
db	=	Calculates decibel as 20*log10(abs(var)).
div	=	Division
exp	=	Exponential function base e.
decr	=	Reduces a variable's value by a variable or value.
deriv_m	=	Creates the derivative of a variable.
div	=	Divide two variables by each other.
incr	=	Increases a variable's value by a variable or value.
integ_heun	=	Integrates a variable according to Heun's method.
intpl_l	=	Creates a linear interpolated variable.
inv	=	The multiplicative inverse of a variable.
l_lim	=	Sets the lower limit of a variable.
log	=	Logarithmic function base e.
log10	=	Logarithmic function base 10.
max	=	Calculates the max. value of constants, scalars or vectors.
maxloc	=	The location of the max. value. To be used together with func max
mean_sec	=	Calculation of average value section per section
min	=	Calculates the min. value of constants, scalars or vectors.
minloc	=	The location of the min. value. To be used together with func min
mul	=	Multiplies two variables with each other.
opere	=	Evaluate an expression.
operf	=	Evaluate an expression and store the output to a variable.
operp	=	Executes algebraic operations in order of priority.
power	=	First variable to the power of the second.
rot_orient	=	Orients a vector with respect to another vector.
reverse	=	Writes the contents of a vector in reverse order.
sign2	=	variable #1 multiplied with the sign from variable #2.
sin	=	Calculates the sinus of a variable.
slope_dx	=	Derivation of a variable, where the size of "dt" is choosen by the user.
spline_G_rel	=	Natural B-spline data smoothing.
sqrt	=	Calculates the square root of a variable.
sub	=	Subtracts two variables from each other.
tan	=	Calculates the tangent of a variable.
u_lim	=	Sets the upper limit of a variable.

In order to limit the amount of text, certain abbreviations have been used in the user manual. These abbreviations are also used in the CALC-program, and are as follows:

1. Words enclosed between grave accents ``
   The program expects to read a valid string, which defines a valid main or sub-command. An error will occur if an integer or real is read.
2. Words enclosed between a grave accent and an acute accent ` '
   The program expects to read a string which defines a variable previously defined in the input data. An error will occur if an integer or real is read.
3. Words without accents
   The program expects to read data constants which comprise integer or real. An error will occur if a character is read.
4. Words which begin with a grave accent `
   At this stage, the program expects to read a character string or a data constant. If a string is read, the program will seek the variable which has been assigned that name and will store the address to the variable. If a data constant is read, the value will be stored directly in the memory.
5. Words which begin with the signs +-
   At this stage, the program accepts reading one or two symbols before the constants or the variables. A plus sign means that the variable's positive value, likewise a minus sign implies that the variable's negative value, is used in the calculation. Should two minus signs be used in a row, the variable's positive value will be applied. Should +- or -+ be printed before the variable, the variable's negative value will be used.

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

                                
  func abs  `f_name', +-`var    
                                

Creates a new variable which is dependent on two input variables, `add` stands for addition, `sub` stands for subtraction, `div` stands for division and `power` raises var1 to the value of var2. In the case f_type=`div` and abs(var2) < 1.e-30, the result will be set to 1.e30.

                                             
  func add    `f_name', +-`var1, +-`var2     
  func sub    `f_name', +-`var1, +-`var2     
  func mul    `f_name', +-`var1, +-`var2     
  func div    `f_name', +-`var1, +-`var2     
  func power  `f_name', +-`var1, +-`var2     
                                             

Calculates one of the trigonometric functions arc-cos, arc-sin, arc-tan, cosinus, sinus or tangent for the input variable `var', and stores the output 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   
                                

Calculates the arc tangent of two variables. The arguments must not both be 0.0.
If argument 2 is 0.0, the absolute value of the result is π/2. If argument 1 is 0.0, the absolute value of the result is 0.0 if argument 2 is positive and π if argument is negative. Otherwise, the result is in the range -π, exclusive, through +π, inclusive, and is calculated as follows:
arctan(arg_1/arg_2)

                                                
  func atan2  `f_name', +-`arg_1, +-`arg_2      
                                                

Calculates the complex absolute value of two variables. Argument 1 is considered to be the real part and argument 2 is considered to be the imaginary part.

                                                
  func cabs  `f_name', +-`arg_1, +-`arg_2       
                                                

Calculate the r.m.s. 95%th percentile of a variable accoring to CEN TC_256 WG_7 and ERRI B153
The norm specifies that the input filtered accelerations shall be divided into 5[s] sections. The r.m.s. values are calculated for each section. Finally the total 95%th percentile of all r.m.s. is calculated.

                                     
  func cen_erri_595  `f_name'= +-`acc   
                                     

The 5[s] r.m.s. values will be stored in memory under the name "f_name_5RMS".

The cumulative frequency function of all r.m.s. values will be stored in memory under the name "f_name_FD".

Text file example    HTML example

Creates a new scalar or vector.

                                 
  func const  `f_name', +-`var   
                                 

Copies a variable with the same content as a previously defined variable.

                                
  func copy  `f_name', +-`var   
                                

Calculates decibel as 20*log10(abs(var)), stores the result in f_name. If the input variable is less than 1.e-30, the result will be set equal to -600.

                                
  func db    `f_name', +-`var   
                                

Decreases a variable's value with `var.

                                
  func decr  `f_name', +-`var   
                                

Creates the derivative of a variable.
The derivation is symmetric in every point dy(t)= (y(t+dt)-y(t-dt))/(2*dt), except in the first and last point.

                                  
  func deriv_m  `f_name', +-`var  
                                  

The value e raised to the power of var. If the input variable var is bigger than 70, the result will be set equal to 2.5e30.

                                
  func exp   `f_name', +-`var   
                                

Increase a variable's value with `var.

                                
  func incr  `f_name', +-`var   
                                

Integrates a variable.
The integration is made according to Heun's method.

                                     
  func integ_heun  `f_name', +-`var  
                                     

Creates a linear interpolated variable.
The points of interpolation are given in this directive. The independent variable is read from an existing scalar or constant. The input data reading into field `intpl_l` is ended by giving a new main command according to post processing-commands or Plotting-commands. If the value in `var' lies outside the interval x₁ - x_n, the output data is extrapolated with help of the gradients from the outer points.

                                                                
  func intpl_l       `f_name' `var' x1,y1 x2,y2 x3,y3 x4, ....  
                                                                

Inverts the variable `var', and stores the output data in `f_name'. If the variable `var' is less than 1.e-30, f_name will be set at 1.e30.

                                
  func inv  `f_name', +-`var    
                                

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  
                                

Calculates the logarithmic function base e of the variable var, stores the result in f_name. If the input variable is less than 1.e-30, the result will be set equal to -69.0775.

                                
  func log   `f_name', +-`var   
                                

Calculates the logarithmic function base 10 of the variable var, stores the result in f_name. If the input variable is less than 1.e-30, the result will be set equal to -30.

                                 
  func log10  `f_name', +-`var   
                                 

Creates a new variable which is the maximum of two or more input variables.

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

The location of the maximum value. When searching for the max value of many variables, it can also be of interest to know the name/number of the variable having the greatest value. To be used together with func max.

                                                          
  func maxloc  `f_name'  +-`var1  +-`var2  +-`var3 ,,, etc.  
                                                          

Calculation of average value section per section.

  func mean_sec  `f_name' +-'sec_length +-'var_name  +-'var_tname

Also a X-variable for f_name will be created. The elements in the X-variable are calculated as:

X(isec)= sum(Xvect(isec_beg:isec_end)) / (isec_end-isec_beg+1)

Creates a new variable which is the minimum of two or more input variables.

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

The location of the minimum value. When searching for the min value of many variables, it can also be of interest to know the name/number of the variable having the smallest value. To be used together with func min.

                                                          
  func minloc  `f_name'  +-`var1  +-`var2  +-`var3 ,,, etc.  
                                                          

Evaluate an expression. The expression shall be written as a command to matlab or octave. Output from the command is written to standard output.

                                                          
  func opere  `expression`
                                                          

Evaluate an expression. The expression shall be written as a command to matlab or octave. Output is written to variable f_name.

                                                          
  func operf  f_name= `expression`   tname= var
                                                          

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

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

The following symbols represent permitted operations:

`+`	=	Addition
`-`	=	Subtraction
`*`	=	Multiplication
`/`	=	Division
`(`	=	Beginning of parenthesis
`)`	=	End of parenthesis

N.B. A delimiter must be used between every `var and `oper`. A delimiter is either a space, a tab sign, or a comma. Parentheses are only permitted up to 101 levels.

Orients a vector with respect to another vector.
The function is especially developed for wheel measurements made with the miniprof wheel- and rail- profile measuring device. Sometimes it can be difficult to know how the miniprof recorder was oriented when it was measuring a profile. This function allows the user to compare the measured profile with a theoretical profile and orient the measured profile with respect to theoretical profile.

                                                                                               
  func rot_orient  `f_name'  `var_meas' `var_orig'  +-'xbeg_1 +-'xend_1  +-'xbeg_2 +-'xendp_2  
                                                                                               

• Example:

• The following input data lines could be used as a template.
  The input data below reads the standard S1002 profile stored in directory \$genkpf/../w_prof/S1002, and a measured profile from file 5V.wheel. Command func rot_orient rotates the measured profile with respect to profile var_orig. Only in the areas xbeg_1-xend_1 and xbeg_2-xend_2 the difference in angle are considered. The rotated measured profile can be exported to ASCII-file PRYFIL by using the command print.
  Rotation and translation of the profile can also be made manually by using the func operp command.
  The input data below ends by plotting the S1002 profile, the measured profile and the rotated measured wheel profile.

                                                                                                  
  ##                                                                                               
  ##      Input data for program MPLOT
  ## ------------------------------------                                                          
  #                                                                                               
   ilaser= 9                                                                                      
  #                                                                                               
  # create_curve file_vpair_free  tname  vname t_dim v_dim format file                            
  # ---------------------------------------------------------------------                         
   create_curve file_vpair_free  xS1002 S1002 format='(a,a)'  \$genkpf/../w_prof/S1002/S1002.wheel 
   create_curve file_vpair_free  x5V    5V    format='(a,a)'  5V.wheel                            
                                                                                                  
   func rot_orient  5V_rot  5V S1002  -57. -53.  53  57                                           
                                                                                                  
   pryfil= 5V_rot.wheel                                                                           
   print vector 5V_rot                                                                            
                                                                                                  
                                                                                                  
   Page  ----------------------------------------                                                 
                                                                                                  
    Page_head 1 Upper diagram original profiles                                                   
    Page_head 2 Lower diagram measured profile rotated                                            
                                                                                                  
    Diagram 11                                                                                    
     x_left= -70   x_right= 70                                                                    
     y_bot=   -5   y_top  = 35                                                                    
     Curve yvar= S1002                                                                            
     Curve yvar= 5V                                                                               
    EndDiagram                                                                                    
                                                                                                  
    Diagram 21                                                                                    
     x_left= -70   x_right= 70                                                                    
     y_bot=   -5   y_top  = 35                                                                    
     Curve yvar= S1002                                                                            
     Curve yvar= 5V_rot                                                                           
    EndDiagram                                                                                    
                                                                                                  
   EndPage                                                                                        
  

  
  

Writes the contents of a vector in reverse order to the new variable f_name.
The function can be used when creating low- and high- pass filters without phase shift.

                                      
  func reverse  `f_name', +-`var1     
                                      

Creates a new variable which is based on two inputs `var1 and `var2. Command `sign2` reads the value from the variable var1 and multiplies its absolute value with the sign of variable var2.

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

Creates the derivative of a variable.
The derivative is calculated according to dy(t)= (y(t+dt)-y(t))/dt.

                                
  func slope_dx  `f_name', +-`var, +-`dt
                                

Natural B-spline data smoothing.

                                
  func spline_G_rel  `f_name', +-`var, tol
                                

Calculates the square root of the variable var, and stores the result in f_name. If the variable is less than 0, the absolute value of the variable var is taken, before the square root is calculated.

                                
  func sqrt  `f_name', +-`var   
                                

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  
                                

This method of reading FUNC-input data commands is an old method and is only kept for backward compatibility. In this case, the indata_group has the same formation regardless of function, "FUNC, Indata_group" can thereby be replaced by the following:

                                        
  FUNC,  Yname1, Oper, Yname2, Fname    
                                        

Definition of include-files.
This directive makes it possible for the user to redirect the input reading to another file. The insert-command can also be given in the inserted file, to further redirect the input reading.

The inserted file is read just as it is, without any filtering functions.

                                
  insert file   `insfile'       
                                

The insert file is read according to the format specification for the input data file. This directive is applicable when the input data is to read from an extern file, but the user wishes to select a desired number of columns.

                                        
  insert format  `formspec' `insfile'   
                                        

                                         
  insert format '(a10,10x,a10)' testfile 
                                         

The insert-file is read in free format, certain columns are selected with the special format-command to free_form. This directive is applicable when input data is to be read from an extern file and certain columns are to be selected, but the number of characters in the columns and/or spaces is not known. The following characters can be used as delimiters: space, tabulator, comma, and equal signs.

                                                
  insert free_form  `formspec' `insfile'        
                                                

                                                 
  insert free_form '(a,x,a,x,x)' data/testfile   
                                                 

The insert file will be read according to the format specification, but the input rows from the inserted file can also be selected.

                                                                
  insert format_rows  `formspec'  istart  istop  `insfile'      
                                                                

The insert-file will be read according to the format specification as in_type=free_form, but the input rows from the inserted file can also be selected.

                                                                
  insert free_form_rows  `formspec'  istart  istop  `insfile'   
                                                                

Definition of an (else)if_then-block.
By using the if_then-command, the user has the possibility to control which statements in the input data file that shall be executed or not. If the test condition is true all statements inside the if_then-block will be executed, otherwise they will be passed over. The if_then-block is ended with an ELSEIF_THEN, ELSE or ENDIF -command. The command if_then has the following input data:

N.B. For the test conditions .eq. and .ne., variable_1 and variable_2 will be converted to integers before the test is undertaken.

Command if_then can also be used for checking if a variable exists or not, see the alternative usage of command if_then below.

Definition of an if_then-block.
This alternative usage of command if_then make tests on one variable only.

Calls a substructure which has previously been defined with the command substruct. The same number of arguments will be defined within brackets that have been used in the definition of the substructure. The delimiters which are used to separate the arguments are comma, space, or tabulator sign. The argument will replace \$1, \$2 etc. in the substructure.

Command LOOP is used when a set of commands shall be repeated. The group of loop-commands is concluded with a UNTIL-command.

Directive for suppressing of warning text.
When the command NO_WARNING is given, a flag is placed in the program so that any error prints from coming commands are suppressed. The command NO_WARNING only applies to the subsequent commands. If the user has a series of commands which will repeatedly give rise to warning texts, the command NO_WARNING must be given for each of these commands.

Number of columns to be written in the *.resu-file.
Declared= Integer*4    Default = 4

Command which exports results into text files. The output is written to the file name defined in PRYFIL. If the output file already exists its contents will be appended. The following subcommands are available:

Sets the name of the file to where output from command PRINT will be written.

Directive which executes statistical operations and calculations of the input variable. In addition to FDname and FRname, the following scalars are created:

Iname+'MAX'	=	Max.value
Iname+'MIN'	=	Min.value
Iname+'MED'	=	Mean value
Iname+'MEDIAN'	=	Median
Iname+'STD'	=	Standard deviation
Iname+'RMS'	=	RMS-value
Iname+'RMQ'	=	RMQ-value
Iname+'TMA'	=	Time when max
Iname+'TMI'	=	Time when min

These scalars created in directive STAT will also be written to file \$ident.resu.

Directive for 3-dimensional statistical analysis of the input variables IHname and IVname. The output data is presented in a table with the IHname horizontally and the IVname vertically. In every square, a figure is presented which will indicate the degree of probability that this particular combination will occur. The output data in every square is given in per mille. The interval of the squares is divided into Fminx, Fminx+dx, Fminx+2*dx, etc. up to Fmaxx. The step dx is equal to: dx = (Fmaxx-Fminx) / Nintx The same classification is used in the Y-direction as in the X-direction.
At the end of the print, the probability will be multiplied in each cell by the value of the vertical variable. The products in each column are then summed up, and the result is presented at the bottom of each print. This print can be useful in e.g. the evaluation of where on the wheel or the rail, the most wear occurs.
The created Y-curve which contains the sum of the probability in each column is stored in memory under the name IVname+'.stat2'. The created X-curve which contains the center point in each column is stored in memory under the name IHname+'.stat2'.
The output data is written to a separate file, named \$ident.stat2.

When the same input data shall be repeated several times, and/or with only a minor difference in the input data between the different times, it can be suitable to formulate the input data in a substructure with arguments. When the substructure is then called, different values can be given to the substructure's argument. Users, who are acquainted with the program in FORTRAN or in Pascal, will see great similarities with FORTRAN's subroutines and/or Pascal's procedures. Users, who have worked with UNIX-scripts may see great similarities between a substructure in CALC-input data and a UNIX-script.

Directive to filtrate in the frequency domain. The command requires that the input variable has equidistant time steps.

Directive to filtrate in the frequency domain, for filtration in the spectra generated by the FRESP program.

Same filters and Indata(i) as in command TRANS are also available in command TRANSF.

Directive, similar to the command TRANS , to filtrate in the frequency domain. The difference between TRANS and TRANST, is that the command TRANST has a subcommand Tsname. Same filters and Indata(i) as in command TRANS are also available in command TRANST.

Directive which concludes an input data group opened with LOOP. The commands given between LOOP and UNTIL will be repeated until the test condition becomes true.

For the test conditions .eq. and .ne., variable_1 and variable_2 will be converted to integers before the test is undertaken. All other tests are undertaken in real.

Directive to calculate a WZ-factor from an absolute value variable created by the program FRESP. The command does not care which frequency step the spectra has been stored with on the output file. The command WZ_AFRESP interpolates the spectra from 0.05-15 Hz with a step of 0.05 Hz regardless of how the variable has been stored on the output file. The Fourier serie variable Iname will be the absolute value of the real part and the imaginary part. The directive creates the variable WZname, which contains the filtrated frequency variable of Iname. A frequency axis, named EQ_freq_0.05, is created for the variable Wzname. However, the variable EQ_freq_0.05 is not created if it already exists. Print of the WZ-value occurs on file \$ident.resu and is stored in the memory as a scalar.

Calculate different ride comfort assessments.

Ride comfort according to:

• Wz
• ISO 2631/1-1985
• BS 6841:1987
• EN12299, CEN Technical Committee 256 WG 7 and ERRI Question B 153.

Motion sickness according to:

• ISO 2631/3-1985 and 2631-1:1997
  
• ISO 8041
  
• BS 6841:1987
  

Calculation of ride index according to Wz.

                                                                                                
  create_scalar new  Xeval_start= 120                                                           
  Ftwz car_1b1.ay  FTname= car_1b1.ay.ft  ityp= lpv  tstart= Xeval_start  tsname= lsb_11.pn     
  Ftwz car_1.m.ay  FTname= car_1.m.ay.ft  ityp= lpv  tstart= Xeval_start  tsname= lsc_1.pn      
  Ftwz car_1b2.ay  FTname= car_1b2.ay.ft  ityp= lpv  tstart= Xeval_start  tsname= lsb_12.pn     
                                                                                                

                                                                
                 =======================================        
                   S U M M A R Y   O F   R E S U L T S          
                 =======================================        
                                                                
                                                                
 RIDE QUALITY   for     car_1b1.az    car_1.m.az    car_1b2.az  
 ------------                                                   
 WZ  (VPV     )          1.95         1.61         2.07         
 DOMINANT FREQ.          2.24          .67         1.11         
                                                                
                                                                
 RIDE QUALITY   for     car_1b1.ay    car_1.m.ay    car_1b2.ay  
 ------------                                                   
 WZ  (LPV     )          2.28         2.05         2.40         
 DOMINANT FREQ.          2.28         2.28         2.28         
                                                                
                                                                
                                                                
 FREQUENCY ANALYSIS   car_1b1.ay.ft car_1.m.ay.ft car_1b2.ay.ft 
 ------------------                                             
 FREQUENCY no  1         1.243         .474        2.282        
 AMPLITUDE             .388349E-01  .345279E-01  .363003E-01    
                                                                
 FREQUENCY no  2         1.383        2.283         .475        
 AMPLITUDE             .372562E-01  .336819E-01  .348181E-01    
                                                                
 FREQUENCY no  3         1.156         .457         .457        
 AMPLITUDE             .367242E-01  .330116E-01  .338166E-01    
                                                                
 FREQUENCY no  4          .455         .439         .962        
 AMPLITUDE             .337917E-01  .303532E-01  .324284E-01    
                                                                
 FREQUENCY no  5          .473         .421        1.683        
 AMPLITUDE             .332709E-01  .293488E-01  .315409E-01    
                                                                
 FREQUENCY no  6          .963        2.224        2.223        
 AMPLITUDE             .329042E-01  .263795E-01  .311171E-01    
                                                                
                                                                
                                                                
 FREQUENCY ANALYSIS   car_1b1.az.ft car_1.m.az.ft car_1b2.az.ft 
 ------------------                                             
 FREQUENCY no  1          .671         .673         .862        
 AMPLITUDE             .220027E-01  .227541E-01  .329338E-01    
                                                                
 FREQUENCY no  2         1.109         .615         .938        
 AMPLITUDE             .215236E-01  .191837E-01  .320969E-01    
                                                                
 FREQUENCY no  3         1.284         .503        1.109        
 AMPLITUDE             .210400E-01  .183239E-01  .308856E-01    
                                                                
 FREQUENCY no  4         1.173         .462         .985        
 AMPLITUDE             .206495E-01  .152621E-01  .298146E-01    
                                                                
 FREQUENCY no  5         2.241         .860         .674        
 AMPLITUDE             .202751E-01  .137461E-01  .295354E-01    
                                                                
 FREQUENCY no  6         1.348         .702        1.067        
 AMPLITUDE             .194817E-01  .123255E-01  .260435E-01    
                                                                

The print is started with an ident name, date and heading. Thereafter follows the print of the Wz-factors and the frequency component which states the dominant frequency for the Wz-factor. Finally, a summary of the six largest tops in the Fourier serie of the non-filtered acceleration variable.

Calculation of comfort factors according to ISO 2631/1-1985.

In ISO 2631, an evaluation has been made of the effect that different vibration environments have on people. The study has primarily studied one frequency at a time in order to acquire a comfort requirement. When measuring vibrations including several frequencies, there are fundamentally only two methods to choose between: 1) Broad-band analysis, where the entire frequency register is weighed together and a RMS-value is calculated, 2) Third octave band analysis where the RMS-level in every octave is calculated and the max. value is acquired.
Method 1) is a good alternative if a simple factor is required as certification for comfort, and to acquire a certification which is simple to compare with other vibration spectra, calculated by the same method.
Method 2) is a more exact method to be able to evaluate the limit of fatigue experienced by a person sitting in a vibrating environment. However, this works best if the vibrations are concentrated to primarily one single frequency.

ISO 2631 Method 1) Calculation of the broad-band comfort factor

The method first filtrates the acceleration variable with a weight filter, then the variable's RMS-value is calculated. This RMS-value functions as a comfort factor. The filter has no physical background, but instead is a mathematical structure as straight and ideal as shown in the standard.

                                                                        
   Illustration of the vertical filter:                                 
                                                                        
     ^                                                                  
     |                                                                  
     |            _____            The transfer function has the value  
     |           /|   |\           "1" in the interval 4-8 (Hz).        
     |          / |   | \                                               
     |         /  |   |  \                                              
     |        /   |   |   \                                             
     |       |    |   |    \                                            
     |       |    |   |     \                                           
     |       |    |   |      \                                          
      -------------------------->                                       
             1    4   8      36  (Hz)                                   
                                                                        
                                                                        
   Illustration of the lateral filter:                                  
                                                                        
     ^                                                                  
     |                                                                  
     |                               The transfer function has the value
     |      ______                   "1" in the interval  1-2 (Hz).     
     |      |    |\                                                     
     |      |    | \                                                    
     |      |    |  \                                                   
     |      |    |   \                                                  
     |      |    |    \                                                 
     |      |    |     \                                                
      ---------------------------->                                     
            1    2     36          (Hz)                                 
                                                                        

In MPLOT, the octave band is studied from 1 to 31.5 (Hz) in the ISO-analysis, but as every octave has a third octave width, this means that frequencies from 0.841 to 38.05 will be taken into consideration.

In order to execute a comfort calculation according to ISO 2631, an example of input data is given here: The acceleration variables are then filtered through weight filters. The vertical filter is called ISOV, and the filter which is used for transversal accelerations is called ISOL.
Example:

                                                       
  Trans car_1b1.ax   fname= car_1b1.axISO  type= ISOL  
  Trans car_1.m.ax   fname= car_1.m.axISO  type= ISOL  
  Trans car_1b2.ax   fname= car_1b2.axISO  type= ISOL  
                                                       
  Trans car_1b1.ay   fname= car_1b1.ayISO  type= ISOL  
  Trans car_1.m.ay   fname= car_1.m.ayISO  type= ISOL  
  Trans car_1b2.ay   fname= car_1b2.ayISO  type= ISOL  
                                                       
  Trans car_1b1.az   fname= car_1b1.azISO  type= ISOV  
  Trans car_1.m.az   fname= car_1.m.azISO  type= ISOV  
  Trans car_1b2.az   fname= car_1b2.azISO  type= ISOV  
                                                       

The filtered variable's RMS-value is then calculated in command STAT.
Example:

                                                                                
  Create_scalar new  Xeval_start=  120                                          
  Create_scalar new  Xeval_stop = 2120                                          
                                                                                
  Stat car_1b1.axISO  tstart= Xeval_start  tstop= Xeval_stop  tname= lsb_11.pn  
  Stat car_1.m.axISO  tstart= Xeval_start  tstop= Xeval_stop  tname= lsc_1.pn   
  Stat car_1b2.axISO  tstart= Xeval_start  tstop= Xeval_stop  tname= lsb_12.pn  
                                                                                
  Stat car_1b1.ayISO  tstart= Xeval_start  tstop= Xeval_stop  tname= lsb_11.pn  
  Stat car_1.m.ayISO  tstart= Xeval_start  tstop= Xeval_stop  tname= lsc_1.pn   
  Stat car_1b2.ayISO  tstart= Xeval_start  tstop= Xeval_stop  tname= lsb_12.pn  
                                                                                
  Stat car_1b1.azISO  tstart= Xeval_start  tstop= Xeval_stop  tname= lsb_11.pn  
  Stat car_1.m.azISO  tstart= Xeval_start  tstop= Xeval_stop  tname= lsc_1.pn   
  Stat car_1b2.azISO  tstart= Xeval_start  tstop= Xeval_stop  tname= lsb_12.pn  
                                                                                

The output from the statistical calculation will be presented on file \$ident.resu. ISO's comfort factor equals the RMS-value of the filtered acceleration. Example:

                                                                             
  STATISTICS     for    car_1b1.ayISO car_1.m.ayISO car_1b2.ayISO            
  ----------                                                                 
  common exponent:       *E -3        *E -3        *E -3                     
    MAX    VALUE        572.364      299.483      697.256                    
    MIN    VALUE       -614.531     -350.874     -770.525                    
    RMS    VALUE        160.733       78.368      187.065  <- Ride Index     
    RMQ    VALUE        217.853      107.326      251.346                    
  AVERAGE  VALUE           .120        -.006        -.125                    
  MEDIAN                  -.589        -.656       -1.385                    
  STANDARD DEVIATION    160.733       78.368      187.065                    
                                                                             

If only a part of the variable is used in the evaluation of the comfort factor, the selection shall be made in the STAT command and not in the TRANS command, as the TRANS command fill out the result with zeros in order to make Fname to the same length as the input vector Iname.

ISO 2631 Method 2) Calculation of the comfort factor with the third band analysis

It has been discussed in ISO-norms, that there is at present no evidence to show that several interference acceleration tones of different frequency mix with each other, and result in a decrease in comfort. Today's research results show that the dominating frequency is the tone which governs the comfort factor. That is why ISO 2631/1-1985 suggests that the comfort factors are evaluated within every octave band, and the octave which has the highest RMS-value determines the comfort factor for the entire the broad-band spectra. According to ISO, this method is superior to the method described above under Method 1), but ISO adds that the differences between the methods are usually not so significant which is why the method under Method 1) can be used, as it is simpler to use in analysis and, moreover, it is more conservative.

There is the possibility to use ISO 2631 in MPLOT with third octave analysis. The filter variable is created under the TRANS directive with the ISOTV filter for vertical acceleration, and ISOTL for transversal acceleration.

Example:

  Create_scalar new  Xeval_start=  120                                                                              
  Create_scalar new  Xeval_stop = 2120                                                                              
                                                                                                                    
##                                                                                                                  
## Ride Comfort according to ISO 2631 1985 third band analysis.                                                     
## ------------------------------------------------------------                                                     
  Transt car_1b1.ax  fname= car_1b1.axISOT  type= ISOTL  tsname= lsb_11.pn  tstart= Xeval_start  tstop= Xeval_stop  
  Transt car_1.m.ax  fname= car_1.m.axISOT  type= ISOTL  tsname= lsc_1.pn   tstart= Xeval_start  tstop= Xeval_stop  
  Transt car_1b2.ax  fname= car_1b2.axISOT  type= ISOTL  tsname= lsb_12.pn  tstart= Xeval_start  tstop= Xeval_stop  
#                                                                                                                   
  Transt car_1b1.ay  fname= car_1b1.ayISOT  type= ISOTL  tsname= lsb_11.pn  tstart= Xeval_start  tstop= Xeval_stop  
  Transt car_1.m.ay  fname= car_1.m.ayISOT  type= ISOTL  tsname= lsc_1.pn   tstart= Xeval_start  tstop= Xeval_stop  
  Transt car_1b2.ay  fname= car_1b2.ayISOT  type= ISOTL  tsname= lsb_12.pn  tstart= Xeval_start  tstop= Xeval_stop  
#                                                                                                                   
  Transt car_1b1.az  fname= car_1b1.azISOT  type= ISOTL  tsname= lsb_11.pn  tstart= Xeval_start  tstop= Xeval_stop  
  Transt car_1.m.az  fname= car_1.m.azISOT  type= ISOTL  tsname= lsc_1.pn   tstart= Xeval_start  tstop= Xeval_stop  
  Transt car_1b2.az  fname= car_1b2.azISOT  type= ISOTL  tsname= lsb_12.pn  tstart= Xeval_start  tstop= Xeval_stop  
#                                                                                                                   
  no_warning Stat car_1b1.axISOT  no_warning Stat car_1.m.axISOT  no_warning Stat car_1b2.axISOT                    
  no_warning Stat car_1b1.ayISOT  no_warning Stat car_1.m.ayISOT  no_warning Stat car_1b2.ayISOT                    
  no_warning Stat car_1b1.azISOT  no_warning Stat car_1.m.azISOT  no_warning Stat car_1b2.azISOT                    

If desired, the spectra can be plotted:

The above diagram has been created with the following input data:

  Page                                      
   xaxis= log                               
   y_bot= 0                                 
   Diagram 11  Curve yvar= car_1b1.ayISOT   
   Diagram 12  Curve yvar= car_1.m.ayISOT   
   Diagram 13  Curve yvar= car_1b2.ayISOT   
   Diagram 21  Curve yvar= car_1b1.azISOT   
   Diagram 22  Curve yvar= car_1.m.azISOT   
   Diagram 23  Curve yvar= car_1b2.azISOT   
  EndPage                                   

From the max. value of the statistical print, the ride index can be determined. The dominating octave's frequency can also be read in the same statistical column. In order to acquire an understanding of the quality of the result, the following table can be used:

                                                                
                           Vertical           Transversal       
  Limit of fatigue         RMS [m/s2]         RMS [m/s2]        
  -----------------        ----------         -----------       
       24 h                  0.140              0.100           
       16 h                  0.212              0.150           
        8 h                  0.315              0.224           
        4 h                  0.530              0.355           
      2.5 h                  0.710              0.500           
        1 h                  1.180              0.850           
       25 min                1.800              1.250           
       16 min                2.120              1.500           
        1 min                2.800              2.000           
                                                                

When the three ride indexes are calculated for all three coordinate directions, a total ride index can be calculated by the following equation:

 Asum= √(1.4*Ax)2 + (1.4*Ay)2 + Az2 

The Asum value in the formula above has the same scale as vertical accelerations. In order to acquire an understanding of the fatigue limit in the table above, the column for vertical RMS shall be read.

Calculation of ride comfort according to BS 6841:1987.

In the standard, there are several different methods to evaluate mechanical vibrations depending on the type of vibration environment, and what type of activities are to be undertaken. In this section of the user manual, chapter 6) from BS 6841:1987 is discussed. The chapter is called "Guide to the evaluation of vibration and repeated shock with respect to discomfort and perception" and deals with the comfort of people of normal health, who are exposed to full-body vibrations during journeys, both for pleasure and work.

Input data example:

                                                                                         
  create_scalar new  Xeval_start= 120                                                    
  create_scalar new  Xeval_stop = 2120                                                   
#                                                                                        
  Transt car_1b1.ax     fname= car_1b1.ax.BS  type= BS_WD                                
  Transt car_1.m.ax     fname= car_1.m.ax.BS  type= BS_WD                                
  Transt car_1b2.ax     fname= car_1b2.ax.BS  type= BS_WD                                
  Stat   car_1b1.ax.BS  tname= lsb_11.pn     tstart= Xeval_start  tstop= Xeval_stop      
  Stat   car_1.m.ax.BS  tname= lsc_1.pn      tstart= Xeval_start  tstop= Xeval_stop      
  Stat   car_1b2.ax.BS  tname= lsb_12.pn     tstart= Xeval_start  tstop= Xeval_stop      
#                                                                                        
  Transt car_1b1.ay     fname= car_1b1.ay.BS  type= BS_WD                                
  Transt car_1.m.ay     fname= car_1.m.ay.BS  type= BS_WD                                
  Transt car_1b2.ay     fname= car_1b2.ay.BS  type= BS_WD                                
  Stat   car_1b1.ay.BS  tname= lsb_11.pn     tstart= Xeval_start  tstop= Xeval_stop      
  Stat   car_1.m.ay.BS  tname= lsc_1.pn      tstart= Xeval_start  tstop= Xeval_stop      
  Stat   car_1b2.ay.BS  tname= lsb_12.pn     tstart= Xeval_start  tstop= Xeval_stop      
#                                                                                        
  Transt car_1b1.az     fname= car_1b1.az.BS  type= BS_WB                                
  Transt car_1.m.az     fname= car_1.m.az.BS  type= BS_WB                                
  Transt car_1b2.az     fname= car_1b2.az.BS  type= BS_WB                                
  Stat   car_1b1.az.BS  tname= lsb_11.pn     tstart= Xeval_start  tstop= Xeval_stop      
  Stat   car_1.m.az.BS  tname= lsc_1.pn      tstart= Xeval_start  tstop= Xeval_stop      
  Stat   car_1b2.az.BS  tname= lsb_12.pn     tstart= Xeval_start  tstop= Xeval_stop      
                                                                                         

In order to determine whether the RMS- or RMQ-value shall be used in the evaluation of the BS ride index, a so-called "crest factor" must be calculated. If the crest factor exceeds the value 6.0 the RMQ-value shall be used otherwise the RMS-value shall be used. The crest factors can be calculated by the following input data commands:

                                                                
  Func operp  crestxb1= car_1b1.ax.BSMAX / car_1b1.ax.BSRMS     
  Func operp  crestx.m= car_1b1.ax.BSMAX / car_1b1.ax.BSRMS     
  Func operp  crestxb2= car_1b1.ax.BSMAX / car_1b1.ax.BSRMS     
 #                                                              
  Func operp  crestyb1= car_1b1.ay.BSMAX / car_1b1.ay.BSRMS     
  Func operp  cresty.m= car_1b1.ay.BSMAX / car_1b1.ay.BSRMS     
  Func operp  crestyb2= car_1b1.ay.BSMAX / car_1b1.ay.BSRMS     
#                                                               
  Func operp  crestzb1= car_1b1.az.BSMAX / car_1b1.az.BSRMS     
  Func operp  crestz.m= car_1b1.az.BSMAX / car_1b1.az.BSRMS     
  Func operp  crestzb2= car_1b1.az.BSMAX / car_1b1.az.BSRMS     
#                                                               
  print scalar  crestxb1 crestx.m crestxb2                      
                crestyb1 cresty.m crestyb2                      
                crestzb1 crestz.m crestzb2                      
                                                                

The crest factors will be written to the print-file by the print command. If the crest factor exceeds 6.0 at any point, the evaluation of the comfort factor will, instead, be executed according to app. C in BS 6841. It states here that the RMQ-value for the variable will be used instead of the RMS-value. No special calculation of the RMQ-value is necessary, as this is calculated simultaneously with the RMS-value through the STAT directive.
When the three ride indexes are calculated for all three coordinate directions, a total ride index can be calculated by the following equation:

  Asum= sqrt( Ax2 + Ay2 + Az2 )

If any of the values Ax,Ay or Az are lower than 25% of max.(Ax,Ay,Az), this value will not be used in the computation. If two of the values are less than 25% of the third value, Asum will be equal to the greatest value Ax,Ay and Az.
In BS 6841:1987, no limit values for fatigue levels are discussed, due to the fact that there are so many other impressions which affect the aspect of comfort, e.g. sound, smells, seating quality etc.. But the following table is presented under App.C as a guideline:

                                                                
  Acceleration variable                                         
     RMS (m/s2)                   Subjective opinion            
  -------------------             ---------------------         
      < 0.015                     no noticeable vibration       
      < 0.315                     not       uncomfortable       
    0.315 - 0.630                 a little  uncomfortable       
    0.500 - 1.000                 quite     uncomfortable       
    0.800 - 1.600                           uncomfortable       
    1.250 - 2.500                 very      uncomfortable       
       > 2.0                      extremely uncomfortable       
                                                                

Calculation of the ride comfort according to: EN12299, CEN Technical Committee 256 WG 7 and ERRI Question B 153.

The standard covers four types comfort evaluations:

NMV	=	Mean comfort simplified.
NVD & NVA	=	Mean comfort complete.
PCT	=	Comfort on curve transitions.
PDE	=	Comfort on discrete events.

• On the floor in the car-body, measure the accelerations in all three directions X, Y and Z:
  Under the front right aisle seat.
  Under the middle right aisle seat.
  Under the back left aisle seat.
• Filter the measured accelerations in direction X and Y with filter TRANS EN12299_Wd.
• Filter the measured accelerations in direction Z with filter TRANS EN12299_Wb.
• Calculate the 95% probability of rms-values for time intervals of 5 [s] in func cen_erri_595
• Calculate partial comfort index:

  In longitudinal direction:	$N_{MVx}= 6\cdot \ddot x^{Wd}_{P95}$
  In lateral direction:	$N_{MVy}= 6\cdot \ddot y^{Wd}_{P95}$
  In vertical direction:	$N_{MVz}= 6\cdot \ddot z^{Wb}_{P95}$

• Calculate N_MV according to
  $N_{MV}= 6\cdot\sqrt{\left(\ddot x^{Wd}_{P95}\right)^2 + \left(\ddot y^{Wd}_{P95}\right)^2 + \left(\ddot z^{Wb}_{P95}\right)^2}$
  
• Text file example    HTML example

• Measure the lateral acceleration in [m/s] and car-body roll rotation speed in degrees per second.
• Filter the two signals in a 1 [s] averaging window.
• Calculate the jerk by connecting two points in the filtered acceleration in a time interval of 1 [s].
• In the phase from beginning to the end of the transition curve read the maximum value of the car-body roll rotation speed.
• In the phase from beginning to end + 1.6 [s] of the transition curve read the maximum value of the lateral acceleration.
• In the phase from 1 [s] before the beginning to the end of the transition curve read the maximum value of the lateral jerk.
• Calculate P_CT according to
  
• The term in brackets is included only if > 0.
• If the measured lateral acceleration is in [m/s] the coefficients A, B, C, D, E are as follows:

  Conditions	A	B	C	D	E
  In rest - standing	28.542	20.693	11.1	0.185	2.283
  In rest - seated	8.9704	9.6840	5.9	0.120	1.626

  
  In the standard EN 12299 the acceleration is expressed in percent of gravitational acceleration, why the original table is as follows:

  Conditions	A	B	C	D	E
  In rest - standing	2.80	2.03	11.1	0.185	2.283
  In rest - seated	0.88	0.95	5.9	0.120	1.626

• Text file example    HTML example

• Measure the lateral acceleration in the car-body
• Filter the acceleration in filter EN12299_PDE
• Calculate sliding average-, max- and min- value in a 2 [s] interval
• Calculate sliding peak value by subtracting the sliding max- and min- value
• Calculate P_DE according to
  
• If the measured lateral acceleration is in [m/s] the coefficients a, b, c are as follows:

  Conditions	a	b	c
  In rest - standing	16.616	27.013	37.0
  In rest - seated	8.4608	13.048	21.7

  
  In the standard EN 12299 the acceleration is expressed in percent of gravitational acceleration, why the original table is as follows:

  Conditions	a	b	c
  In rest - standing	1.63	2.65	37.0
  In rest - seated	0.83	1.28	21.7

• Text file example    HTML example

Proposed scale in comfort units for N_MV, N_VA, N_VD is as follows:

                                                 
        N < 1           Very comfortable         
    1 ≤ N < 2           Comfortable              
    2 ≤ N < 4           Medium                   
    4 ≤ N < 5           Uncomfortable            
    5 ≤ N               Very uncomfortable       
                                                 

Calculation of motion sickness value according to ISO 2631/3-1985 and ISO 2631-1:1997.

An evaluation has been carried out by ISO 2631/3 to study people's tendency towards motion sickness. It is stated in the norms that there are many factors in addition to motion, that cause motion sickness among passengers. It has, been difficult to formulate a good criterion, for other factors than vertical motion, therefore only vertical motions is covered in the norm. The acceleration has been measured at a point as far from the center of the car-body as possible, in order to acquire the greatest possible vertical motion.
In the formulation of the norm, only one frequency at a time has been studied in order to determine the requirement. In case of an excitation comprising of several frequencies, a broad-band analysis must be made where the entire frequency register is computed, and a total RMS-value is calculated according to Method 1).
The calculation of motion sickness according to ISO 2631/3-1985 is carried out by first filtering the acceleration variable, and then calculating the RMS value of the variable. The RMS value equals the motion sickness value.

                                                                        
  Illustration of the vertical motion sickness filter ISOV_2631_3:      
                                                                        
    ^                                                                   
    |                                                                   
    |                               The transfer function has the value 
    |      ______                   "1" in interval  0.1-0.315 (Hz).    
    |      |    |\                                                      
    |      |    | \                                                     
    |      |    |  \                                                    
    |      |    |   \                                                   
    |      |    |    \                                                  
    |      |    |     |                                                 
    |      |    |     |                                                 
    |      |    |     |                                                 
     ---------------------------->                                      
          0.1  0.315  0.63        (Hz)                                  
                                                                        

The filter ISOV_2631_3 has no physical background. No frequencies over 0.63 Hz are taken into consideration, nor will any frequencies under 0.1 Hz be taken into consideration. According to ISO 2631/3-1985, it has been difficult to prove that frequencies outside 0.1-0.63 Hz give rise to motion sickness.
In the ISO-analysis, the third octave band is from 0.1 to 0.63 Hz in filter ISOV_2631_3. However, as every octave has a third octave width, this will mean that the frequency range will be extended from 0.089 to 0.708.
In order to be able to calculate the risk of motion sickness according to ISO 2631/3, an example is given:

                                                                                        
  Create_scalar new  Xeval_start= 120                                                   
  Create_scalar new  Xeval_stop = 2120                                                  
#                                                                                       
  Transt car_1b1.az           fname= car_1b1.az.ISO_MS85  type= ISOV_2631_3             
  Transt car_1.m.az           fname= car_1.m.az.ISO_MS85  type= ISOV_2631_3             
  Transt car_1b2.az           fname= car_1b2.az.ISO_MS85  type= ISOV_2631_3             
  Stat   car_1b1.az.ISO_MS85  tname= lsb_11.pn   tstart= Xeval_start  tstop= Xeval_stop 
  Stat   car_1.m.az.ISO_MS85  tname= lsc_1.pn    tstart= Xeval_start  tstop= Xeval_stop 
  Stat   car_1b2.az.ISO_MS85  tname= lsb_12.pn   tstart= Xeval_start  tstop= Xeval_stop 
                                                                                        

In order to be able to calculate the risk of motion sickness according to ISO 2631-1:1997, an example is given:

                                                                                        
  Create_scalar new  Xeval_start= 120                                                   
  Create_scalar new  Xeval_stop = 2120                                                  
#                                                                                       
  Transt car_1b1.az           fname= car_1b1.az.ISO_MS97  type= ISO2631_97WF            
  Transt car_1.m.az           fname= car_1.m.az.ISO_MS97  type= ISO2631_97WF            
  Transt car_1b2.az           fname= car_1b2.az.ISO_MS97  type= ISO2631_97WF            
  Stat   car_1b1.az.ISO_MS97  tname= lsb_11.pn   tstart= Xeval_start  tstop= Xeval_stop 
  Stat   car_1.m.az.ISO_MS97  tname= lsc_1.pn    tstart= Xeval_start  tstop= Xeval_stop 
  Stat   car_1b2.az.ISO_MS97  tname= lsb_12.pn   tstart= Xeval_start  tstop= Xeval_stop 
                                                                                        

Output from the statistical calculation will be printed on the file \$ident.resu.
Example:.

                                                                                   
 STATISTICS     for    car_1b1.az.    car_1.m.az.    car_1b2.az.                     
 ----------            ISO_MS85       ISO_MS85       ISO_MS85                          
 common exponent:       *E -3          *E -3          *E -3                            
   MAX    VALUE         39.316         37.327         44.755                           
   MIN    VALUE        -36.759        -34.646        -44.080                           
   RMS    VALUE         16.246         15.682         18.972  <- motion sickness value 
   RMQ    VALUE         20.660         19.920         24.187                           
 AVERAGE  VALUE           .241           .230           .209                           
 MEDIAN                   .119           .370           .975                           
 STANDARD DEVIATION     16.245         15.680         18.971                           
                                                                                       
 XVAR  WHEN MAX        924.000        649.333        646.667                           
 XVAR  WHEN MIN       1204.000       1476.000       1474.222                           
                                                                                   

If only a part of the variable is used in the evaluation of the comfort factor, the selection shall be made in the STAT command and not in the TRANS command, as the TRANS command fill out the result with zeros in order to make Fname to the same length as the input vector Iname.

Calculation of vertical motion sickness according to ISO 8041

ISO 8041 "Human response to vibration - Measuring instrumentation" shows how a physical filter with poles and zeros can be designed which is adapted to ISO 2631/3. The filter includes two fundamental parts, a band pass filter and a frequency weighting filter.
The band pass filter is designed as follows:

 Hb(s) =             s2               ·          omega22
         (s2 + s·omega1/Q1 + omega12) · (s2 + s·omega2/Q1 + omega22)


 where omega1 = 0.49909   [rad/s]
       omega2 = 4.99090   [rad/s]
       Q1     = 0.7071067 [1]

The frequency weighting filter is designed as follows:

  Hms(s) =         1 + 0.105 · s
            (0.472·s)2 + 0.581·s + 1

In order to be able to calculate the motion sickness factor according to ISO 8041, an example is given:
Example:

                                                                                        
  Create_scalar new  Xeval_start= 120                                                   
  Create_scalar new  Xeval_stop = 2120                                                  
#                                                                                       
  Transt car_1b1.az           fname= car_1b1.az.ISO_MS41  type= ISO8041V_MS             
  Transt car_1.m.az           fname= car_1.m.az.ISO_MS41  type= ISO8041V_MS             
  Transt car_1b2.az           fname= car_1b2.az.ISO_MS41  type= ISO8041V_MS             
  Stat   car_1b1.az.ISO_MS41  tname= lsb_11.pn   tstart= Xeval_start  tstop= Xeval_stop 
  Stat   car_1.m.az.ISO_MS41  tname= lsc_1.pn    tstart= Xeval_start  tstop= Xeval_stop 
  Stat   car_1b2.az.ISO_MS41  tname= lsb_12.pn   tstart= Xeval_start  tstop= Xeval_stop 
                                                                                        

Output from the statistical calculation will be printed on file \$ident.resu.
Example:

                                                                                   
 STATISTICS     for    car_1b1.az.    car_1.m.az.    car_1b2.az.                     
 ----------            ISO_MS41       ISO_MS41       ISO_MS41                            
 common exponent:       *E -3          *E -3          *E -3                            
   MAX    VALUE         41.254         37.554         50.971                           
   MIN    VALUE        -42.739        -34.946        -52.018                           
   RMS    VALUE         15.417         14.681         18.363  <- motion sickness value
   RMQ    VALUE         19.927         18.962         24.291                           
 AVERAGE  VALUE           .037           .028           .051                           
 MEDIAN                   .781           .876          1.591                           
 STANDARD DEVIATION     15.417         14.681         18.363                           
                                                                                       
 XVAR  WHEN MAX        687.556        686.667        685.778                           
 XVAR  WHEN MIN        299.111        298.222        299.111                           
                                                                                   

If only a part of the variable is used in the evaluation of the comfort factor, the selection shall be made in the STAT command and not in the TRANS command, as the TRANS command fill out the result with zeros in order to make Fname to the same length as the input vector Iname.

Calculation of the motion sickness factor according to BS 6841:1987.

BS 6841:1987 is very similar to ISO 2631/3. The main difference is that a physical filter has been adapted to the ideal curvature in ISO 2631/3. The filter in BS 6841:1987 comprises a band pass filter in series with a filter which is called frequency weight filter.
The band pass filter is designed as follows:

 Hb(s) =             s2               ·          omega22
         (s2 + s·omega1/Q1 + omega12) · (s2 + s·omega2/Q1 + omega22)


 where: omega1 = 0.5026548 [rad/s]
        omega2 = 3.9584067 [rad/s]
        Q1     = 0.71      [1]

The frequency weighting filter is designed as follows:

  Hw(s) = K * H4 * H5 * H6

  where:

                     omega42
  H4(s) = ----------------------------------
           (s2 + s*omega4/Q2 + omega42)


           (s2 + s*omega5/Q3 + omega52)
  H5(s) = ----------------------------------
                     omega52


                     omega62
  H6(s) = ----------------------------------
           (s2 + s*omega6/Q4 + omega62)


  K      = 0.4       [1]
  omega4 = 1.5707963 [rad/s]
  omega5 = 0.3926990 [rad/s]
  omega6 = 0.6283185 [rad/s]
  Q2     = 0.86      [1]
  Q3     = 0.80      [1]
  Q4     = 0.80      [1]

In order to calculate the motion sickness factor according to BS 6841:1987, an example is given below:

                                                                                        
  Create_scalar new  Xeval_start= 120                                                   
  Create_scalar new  Xeval_stop = 2120                                                  
#                                                                                       
  Transt car_1b1.az        fname= car_1b1.az.BS_WF     type= BS_WF                      
  Transt car_1.m.az        fname= car_1.m.az.BS_WF     type= BS_WF                      
  Transt car_1b2.az        fname= car_1b2.az.BS_WF     type= BS_WF                      
  Stat   car_1b1.az.BS_WF  tname= lsb_11.pn   tstart= Xeval_start  tstop= Xeval_stop    
  Stat   car_1.m.az.BS_WF  tname= lsc_1.pn    tstart= Xeval_start  tstop= Xeval_stop    
  Stat   car_1b2.az.BS_WF  tname= lsb_12.pn   tstart= Xeval_start  tstop= Xeval_stop    
                                                                                        

Output from the statistical calculation will be printed on file \$ident.resu. Example:

                                                                                    
 STATISTICS     for    car_1b1.az.BS car_1.m.az.BS car_1b2.az.BS                    
 ----------            _WF          _WF          _WF                                
 common exponent:       *E -3        *E -3        *E -3                             
   MAX    VALUE         20.087       18.801       24.729                            
   MIN    VALUE        -24.954      -22.399      -29.222                            
   RMS    VALUE          8.797        8.366        9.772  <- motion sickness value  
   RMQ    VALUE         11.289       10.788       12.780                            
 AVERAGE  VALUE          -.013        -.008        -.024                            
 MEDIAN                   .003         .066         .502                            
 STANDARD DEVIATION      8.797        8.366        9.772                            
                                                                                    
 XVAR  WHEN MAX        696.444      696.444      694.667                            
 XVAR  WHEN MIN        306.222      308.889      306.222                            
                                                                                    

If only a part of the variable is used in the evaluation of the comfort factor, the selection shall be made in the STAT command and not in the TRANST command, as the TRANST command fill out the result with zeros in order to make Fname to the same length as the input vector Iname.

5.3) Designing higher order filters.

In command FILT exists only first and second order, low and high pass filters. If a filter of higher order is required it can created by making several filtering in series.

5.3.1) Butterworth-filter

The Butterworth filter is a type of filter where the poles are equidistantly placed in a half circle in the complex factor domain. The half circle only exists for negative sigma values.
In a Butterworth filter all sub filters shall have the same cut-off frequency, only the damping zeta shall be different according to the table below.

                                                                            
Filter's                                                     Approximate    
Order    Filter    Filter type    Relative damping         relative damping 
                                                                            
   2        1        lpass2_0       sin (π/4)                0.7071        
                                                                            
   3        1        lpass1_0                                               
            2        lpass2_0       sin (π/6)                0.5000        
                                                                            
   4        1        lpass2_0       sin (π/8)                0.3827        
            2        lpass2_0       sin (3*π/8)              0.9239        
                                                                            
   5        1        lpass1_0                                               
            2        lpass2_0       sin (π/10)               0.3090        
            3        lpass2_0       sin (3*π/10)             0.8090        
                                                                            
   6        1        lpass2_0       sin (π/12)               0.2588        
            2        lpass2_0       sin (3*π/12)             0.7071        
            3        lpass2_0       sin (5*π/12)             0.9659        
                                                                            
   7        1        lpass1_0                                               
            2        lpass2_0       sin (π/14)               0.2225        
            3        lpass2_0       sin (3*π/14)             0.6235        
            4        lpass2_0       sin (5*π/14)             0.9010        
                                                                            
   8        1        lpass2_0       sin (π/16)               0.1951        
            2        lpass2_0       sin (3*π/16)             0.5556        
            3        lpass2_0       sin (5*π/16)             0.8315        
            4        lpass2_0       sin (7*π/16)             0.9808        
                                                                            
   9        1        lpass1_0                                               
            2        lpass2_0       sin (π/18)               0.1736        
            3        lpass2_0       sin (3*π/18)             0.5000        
            4        lpass2_0       sin (5*π/18)             0.7660        
            5        lpass2_0       sin (7*π/18)             0.9397        
                                                                            
  10        1        lpass2_0       sin (π/20)               0.1564        
            2        lpass2_0       sin (3*π/20)             0.4540        
            3        lpass2_0       sin (5*π/20)             0.7071        
            4        lpass2_0       sin (7*π/20)             0.8910        
            5        lpass2_0       sin (9*π/20)             0.9877        
                                                                            

Input data commands which controls plotting

In plotting MPLOT reads input data at different levels.

The levels are:

Example:

Func,  Stat,        <---   In the beginning of the file, input are 
Filt,...Etc.               read at level MAIN



Page 1             <---   Command to move input data reading to level PAGE


 Diagram 11        <---   Command to move input data reading to level DIAGRAM



  Curve            <---   Command to move input data reading to lowest level
                         Here you can define all data that is only valid
                         for this curve or point: yvar, xvar, line_type, 
                         linetext, ...etc.
                         An EndCurve-command is not needed the curve- or point-
                         definition is finished by writing a new CURVE-, POINT-,
                         POINT_LINE-, POINT3D- or EndDiagram- command.


 EndDiagram        <---   Command to leave level DIAGRAM


EndPage            <---   Command to leave level PAGE and draw the page

                    <---   Back to level level MAIN again

When a new curve or point is to be created, input data given under lowest level will have the highest priority, and input data given under level MAIN will have the lowest priority.

Input data commands are not case sensitive, but variable names are.

Input data that valid at the lowest level is also valid in the levels above level PAGE and level MAIN. Therefore starts the input data descriptions at the lowest level:

All plotting commands in alphabetical order

Date of calculation, shown under each diagram.

See also: LOC_CALC_DATE, SIZE_CALC_DATE, WRITE_CALC_DATE

Declared= Character*80    Default= The date read from the MPdat-file

The CURVE command initializes the definition of a new curve and moves the input data reading to level CURVE.

Defines the hight of the diagram.

Defines the width of the diagram.

Read the diagram number and move input data reading to level DIAGRAM.

Defines the shape of the dots used when plotting scalars.

Drawing of isolines, for points which are defined with the command DIAGPT3D. The command demands that the points lie in a grid, and are numbered with point number 1 at the top left-hand corner, and point 2 to the right of point 1 etc. downwards in rows until the last point is located at the bottom to the right. This also implies that every line is equally long, and every column equally high. Long and high refer to the number of points in the lines and columns, however it is not required that the points are located at a equidistant spacing from each other.

The ENDDIAGRAM command ends current diagram definition and returns the input data reading to level PAGE.

The ENDPAGE command ends the current page definition, and writes the output on screen and/or file. After command ENDPAGE further input data will be read at level MAIN.

Terminates the ongoing command.
Certain commands are not executed until a new main-command has been read. This is due to the fact that the amount of input data is not known from the outset. After program MPLOT have read command EXEC, further input data reading will continue at level MAIN

Declared= Character*12    Default= GLOBAL_LOCAL

Input of text header lines, written in the diagrams.

In the header lines the user has the possibility to retrieve values of scalars. In order to retrieve a value from a scalar, the user shall write the name of the scalar with a \$-sign in the beginning of the name of the scalar.
The following example retrieves the values the ride comfort indexes in current ident:

                                                        
 head1= 'Wz.m=$car_1.m.ayWZ   RMS.m=$car_1.m.ay.ERRMS'  
 head2= 'Wzb1=$car_1b1.ayWZ   RMSb1=$car_1b1.ay.ERRMS'  
 head3= 'Wzb2=$car_1b2.ayWZ   RMSb2=$car_1b2.ay.ERRMS'  
                                                        

The following example retrieves the values the ride comfort indexes in other idents:

                                                                                
 head1= 'Wz.m=$car_1.m.ayWZ(ident_001)   RMS.m=$car_1.m.ay.ERRMS(ident_001)'    
 head2= 'Wz.m=$car_1.m.ayWZ(ident_002)   RMS.m=$car_1.m.ay.ERRMS(ident_002)'    
 head3= 'Wz.m=$car_1.m.ayWZ(ident_003)   RMS.m=$car_1.m.ay.ERRMS(ident_003)'    
                                                                                

If the user wishes the heading text to be retrieved from the MPdat-file, the following sub directives can be given in command HEAD:

                                        
 head1= IDENT= ident_001    HEAD= 3     
 head2= IDENT= ident_001    HEAD= 2     
 head3= IDENT= ident_001    HEAD= 1     
                                        

See also: LOC_HEAD, SIZE_HEAD, WRITE_HEAD.

Format for graphic output. Valid values for ILASER are: intro_common_commands.html#jILASER

Declared= Integer*4    Default= 6

Controls the writing of a debug logging file.
Command INKFIL can be switched on and off several times during the plotting activity. INKFIL can be given the following values:
0 => No printing.
3 => Print of log file to the file code 03.
6 => Print of log file to the file code 06 i.e. standard output.

Declared= Integer*4    Default= 0

Declared= Integer*4    Default= 0

Creation of limit lines in the diagram.

Explanatory text for LIMIT_LINE.

See also: LOC_LIMIT_EXPL, SIZE_LIMIT_EXPL

Command LINE_TYPE determines the type of line to be used when drawing curves.
LINE_TYPE controls the color and shape of the curves.

Explanatory text for the actual LINE_TYPE.
The text is written if it is non-blank.

See also: LOC_LINETEXT, SIZE_LINETEXT

Declared= Character*80    Default= " " (Blank)

Controls the location of CALC_DATE.

Location of the lower left corner of the DIAGRAM.

Location of the lower left corner of the drawing area, in relation to the lower left corner of the local DIAGRAM.

Controls the position of the HEAD-lines.

Sets the location of LIMIT_LINE_EXPL.

Controls the location of the text defined in command LINETEXT.

Controls the location of MPLOT_DATE.

Controls the location of MPLOT_ID.

Controls the position of PAGE_HEAD.

Controls the location of the page number in X- and Y-coordinates.

Sets the location of VAR_ID.

Sets the location of XNAME.

Sets the location of XVAR_EXPL.

Controls the location of YNAME.

Controls the location of YVAR_EXPL.

Sets the length of the X-axis.

Sets the length of the Y-axis.

Current date, shown in the upper right-hand corner of the title.

See also: LOC_MPLOT_DATE, SIZE_MPLOT_DATE, WRITE_MPLOT_DATE

Declared= Character*80    Default= Current date

Ident for current plotting activity, plotted in the upper right corner of the title. Can be set in this command or given in Command Line Options.

See also: LOC_MPLOT_ID, SIZE_MPLOT_ID, WRITE_MPLOT_ID

Declared= Character*80    Default= "mplot_id"

Defines number of columns of local diagrams.

See also: NROWS

Commentary line, the rest of the line is ignored.

Declared= Character*80    Default= Blank

Defines number of rows of local diagrams.

See also: NCOLS

States the area of which the curves may be plotted. Following values are valid:

Declared= Character*6    Default= 'NO'

Read page number and move input data reading to level PAGE.

Declared= Integer*4    Default= "Previous page number" + 1

Text header lines, written above the diagrams.

If the user wishes the header line to be read from a MPdat-file, htext can be replaced by the sub-directives IDENT and HEAD:

See also: LOC_PAGE_HEAD, SIZE_PAGE_HEAD, WRITE_PAGE_HEAD.

Defines the size of the paper to be used.
The orientation of the paper is controlled in command XAXIS_ALONG.
Following values are valid:

  A0 => Selects paper A0.
  A1 => Selects paper A1.
  A2 => Selects paper A2.
  A3 => Selects paper A3.
  A4 => Selects paper A4.

Declared= Character*2    Default= 'A4'

The POINT command initializes the definition of a new symbol and moves the input data reading to level POINT.

The POINT_LINE command initializes the definition of a new curve and moves the input data reading to POINT_LINE.

POINT_LINE plots a curve, fitted to the points given by command POINT.

The POINT3D command initializes the definition of a three-dimensional point and moves the input data reading to level POINT3D.

Sets the name of the graphic output data file.

See also: ILASER

Declared= Character*80    Default= "\$ident.ps"

End the execution of program MPLOT.

Controls the rotation in degrees of the text to the left of the Y-axis.
The scale to the left of the Y-axis can be rotated in a arbitrary angle. The text strings WRITE_ID, VAR_ID, YNAME and YVAR_EXPL are rotated 0. or 180. degrees.

The rotation is a right handed rotation. Which means that setting ROT_YTEXT= -90 vill give a scale with upright numbers.

If ROT_YTEXT is set equal to -90 you may also want to make more space to the left of the Y-axis. This can be made with the LOC_FRAME_LL-command.

Declared= Real*4    Default = 180. [deg]

Controls the character size of CALC_DATE.

Declared= Real*4    Default = .175 [cm]

Controls the character size of HEAD.

Declared= Real*4    Default = .175 [cm]

Controls the character size of LIMIT_LINE_EXPL.

Declared= Real*4    Default = .175 [cm]

Controls the character size of LINETEXT.

Declared= Real*4    Default = .175 [cm]

Controls the character size of MPLOT_DATE.

Declared= Real*4    Default = .2 [cm]

Controls the size of MPLOT_ID.

Declared= Real*4    Default= .2 [cm]

Controls the size of PAGE_HEAD.

Declared= Real*4    Default= AUTO, max. .25 [cm]

Controls the size of the page number.

Declared= Real*4    Default= .2 [cm]

Controls the size of XNAME.

Declared= Real*4    Default= .175 [cm]

Controls the size of YNAME.

Declared= Real*4    Default= .175 [cm]

Directory where the calculation results are stored.

Declared= Character*80    Default= "."  i.e. current directory

Sets the ident from which the variable shall be read.
Following wildcards are allowed:

See also: LOC_VAR_ID, WRITE_VAR_ID

Controls the plotting of CALC_DATE.
Following values are valid:

'Y' or 'YES' indicates that the date will be plotted.
'N' or 'NO' indicates that the date will not be plotted.

Declared= Character*3    Default= 'N'

Controls the printing of HEAD-lines.

Gives information which command that has created the curve or point

'Y' or 'YES' indicates that the text will be printed.
'N' or 'NO' indicates that the tex will not be printed.

Declared= Character*3    Default = 'Y'

Controls the printing of MPLOT_DATE.

'Y' or 'YES' states that the date will be printed
'N' or 'NO' states that the date will not be printed

Declared= Character*3    Default= 'Y'

Controls the plotting of current ident MPLOT_ID.

'Y' or 'YES' states that the plot ident will be plotted.
'N' or 'NO' states that the plot ident will not be plotted.

Declared= Character*3    Default= 'Y'

Controls the printing of PAGE_HEAD-lines.

Controls the plotting of page number.

'Y' or 'YES' indicates that the page number will be plotted.
'N' or 'NO' indicates that the page number will not be plotted.

Declared= Character*3    Default= 'Y'

Controls the plotting of VAR_ID.
Following values are valid:

'Y' or 'YES' indicates that the ident text will be printed.
'N' or 'NO' indicates that the ident text will not be printed.

Declared= Character*3    Default= 'Y'

Controls the plotting of XNAME.
Following values are valid:

'Y' or 'YES' indicates that the text will be printed.
'N' or 'NO' indicates that the text will not be printed.

Declared= Character*3    Default = 'Y'

Controls the plotting of YNAME.
Following values are valid:

'Y' or 'YES' indicates that the text will be printed.
'N' or 'NO' indicates that the text will not be printed.

Declared= Character*3    Default= 'Y'

Controls the plotting of all text to the left of the Y-axis, i.e. all of WRITE_ID, WRITE_VAR_ID and WRITE_YNAME.

Following values are valid:

'Y' or 'YES' indicates that all Y-text will be printed.
'N' or 'NO' indicates that no Y-text will not be printed.

Declared= Character*3    Default= 'Y'

Sets the left-hand value of the X-axis. This input data is equal to the commands X_MID and X_RIGHT, the last given input data command will apply.
X_LEFT, X_MID and X_RIGHT shall all be set to 'AUTO' if automatic scaling is desired.

A special case occurs if both X_LEFT and X_RIGHT are defined but not XCM/DEC. In that case XINT/CM will be set to (X_RIGHT-X_LEFT)/LXCM and the MARKINGS-distance in the XAXIS-command will be set to a suitable value in order to give integer numbers at the X-axis. This special case do only occur if X_LEFT and X_RIGHT is given under level DIAGRAM, and please set XGRIDINT equal to 'AUTO'.

See also: X_MID, X_RIGHT, XINT/CM,

Declared= If text: Character*4 else Real*4
Default  = 'AUTO'

Sets the value of the X-axis at the midpoint of the axis. This input data is equal to the commands X_LEFT and X_RIGHT, the last given input data command will apply.
X_LEFT, X_MID and X_RIGHT shall all be set to 'AUTO' if automatic scaling is desired.

See also: X_LEFT, X_RIGHT, XINT/CM,

Declared= If text: Character*4 else Real*4
Default  = 'AUTO'

Sets the right-hand value of the X-axis. This input data is equal to the commands X_MID and X_LEFT, the last given input data command will apply.
X_LEFT, X_MID and X_RIGHT shall all be set to 'AUTO' if automatic scaling is desired.

A special case occurs if both X_LEFT and X_RIGHT are defined but not XCM/DEC. In that case XINT/CM will be set to (X_RIGHT-X_LEFT)/LXCM and the MARKINGS-distance in the XAXIS-command will be set to a suitable value in order to give integer numbers at the X-axis. This special case do only occur if X_LEFT and X_RIGHT is given under level DIAGRAM, and please set XGRIDINT equal to 'AUTO'.

See also: X_MID, X_RIGHT, XINT/CM,

Declared= If text: Character*4 else Real*4
Default  = 'AUTO'

Controls the location of the X-axis in the diagram. XAX_YVAL refers to the value where the X-axis will meet the Y-axis. Instead of giving a Y-value, following character strings are understood:

Declared= If text: Character*3 else Real*4 Units= [cm]
Default  = 'BOT'

Controls the plotting of the X-axis.

Orientation of the X-axis. Following values are valid:

Declared= Character*12    Default= 'LONG_SIDE'

Sets the scale factor of the X-axle, if XAXIS has been set to 'LOG'.
XCM/DEC defines the number of cm per decade.

See also: X_LEFT, X_MID, X_RIGHT, XINT/CM

Declared= If text: Character*4 else Real*4
Default  = 'AUTO' (i.e. a value from the following series: 1,2,5,10,20,...etc.)

Sets number of cm from the Y-axis to the first grid line.

See also: XGRIDINT

Declared= If text: Character*4 else Real*4
Default  = 'AUTO' i.e. same distance as to the first axis marking.

Sets the number of cm between every vertical line of the grid.
The grid pattern is drawn with LINE_TYPE= 2.

See also: XGRID1

Declared= If text: Character*4 else Real*4
Default  = 'AUTO' i.e. same distance as the axis markings.

Sets the scale factor of the X-axle, if XAXIS has been set to 'LIN'.
XINT/CM defines the number of units per cm.

See also: X_LEFT, X_MID, X_RIGHT, XCM/DEC

Declared= If text: Character*4 else Real*4
Default  = 'AUTO' (i.e. a value from the following series: 1,2,5,10,20,...etc.)

Sets variable-name to be plotted at the X-axis.

See also: LOC_XNAME, SIZE_XNAME, WRITE_XNAME

Declared= Character*80
Default  = Same name as XVAR.

Manually set the X-value of the point.

Declared= Real*4
Default  = The value of XVAR

Select variable for the X-axle.

The user can draw a X-variable from an another ident, by defining the name of the ident inside parenthesis: XVAR= var_name(ident)

Different curves can have different X-variables, but the text under the X-axle will be picked from XVAR(1).

Declared= Character*80(200)
Default = The default X-variable of YVAR.

Explanatory text of XVAR.
The text is printed if it is non-blank. The text is printed with the same text size as XNAME.

See also: LOC_XVAR_EXPL

Declared= Character*80    Default= " "(Blank)

The value of the Y-axis at the bottom of the axis. This input data is equal to the commands Y_MID and Y_TOP, the last given input data command will apply.
Y_BOT, Y_MID and Y_TOP shall all be set to 'AUTO' if automatic scaling is desired.

A special case occurs if both Y_BOT and Y_TOP are defined but not YINT/CM. In that case YINT/CM will be set to (Y_BOT-Y_TOP)/LYCM and the MARKINGS-distance in the YAXIS-command will be set to a suitable value in order to give integer numbers at the Y-axis. This special case do only occur if Y_BOT and Y_TOP is given under level DIAGRAM, and please set YGRIDINT equal to 'AUTO'.

See also: Y_MID, Y_TOP, YINT/CM,

Declared= If text: Character*4 else Real*4
Default  = 'AUTO'

The value of the Y-axis at the middle of the axis. This input data is equal to the commands Y_BOT and Y_TOP, the last given input data command will apply.
Y_BOT, Y_MID and Y_TOP shall all be set to 'AUTO' if automatic scaling is desired.

See also: Y_BOT, Y_TOP, YINT/CM,

Declared= If text: Character*4 else Real*4
Default  = 'AUTO'

The value of the Y-axis at the top of the axis. This input data is equal to the commands Y_MID and Y_BOT, the last given input data command will apply.
Y_BOT, Y_MID and Y_TOP shall all be set to 'AUTO' if automatic scaling is desired.

A special case occurs if both Y_BOT and Y_TOP are defined but not YINT/CM. In that case YINT/CM will be set to (Y_BOT-Y_TOP)/LYCM and the MARKINGS-distance in the YAXIS-command will be set to a suitable value in order to give integer numbers at the Y-axis. This special case do only occur if Y_BOT and Y_TOP is given under level DIAGRAM, and please set YGRIDINT equal to 'AUTO'.

Declared= If text: Character*4 else Real*4
Default  = 'AUTO'

Controls the location of the Y-axis in the diagram. YAX_XVAL refers to the value where the Y-axis will meet the X-axis. Instead of giving a X-value, following character strings are understood:

Declared= If text: Character*5 else Real*4 Units= [cm]
Default  = 'LEFT'

Controls the plotting of the Y-axis.

Sets the scale factor of the Y-axle, if YAXIS has been set to 'LOG'.
YCM/DEC defines the number of cm per decade.

See also: Y_TOP, Y_MID, Y_BOT, YINT/CM

Declared= If text: Character*4 else Real*4
Default  = 'AUTO' (i.e. a value from the following series: 1,2,5,10,20,...etc.)

Sets the number of cm from the x-axis to the first grid line.

See also: YGRIDINT

Declared= If text: Character*4 else Real*4
Default  = 'AUTO' i.e. same distance as to the first axis marking.

Sets the number of cm between every horizontal line in the grid.
The grid pattern is drawn with LINE_TYPE= 2.

See also: YGRID1

Declared= If text: Character*4 else Real*4
Default  = 'AUTO' i.e. same distance as the axis markings.

Sets the scale factor of the Y-axle, if YAXIS has been set to 'LIN'.
YINT/CM defines the number of units per cm.

See also: Y_BOT, Y_MID, Y_TOP, YCM/DEC

Declared= If text: Character*4 else Real*4
Default  = 'AUTO' (i.e. a value from the following series: 1,2,5,10,20,...etc.)

Sets variable-name to be plotted at the Y-axis.

See also: LOC_YNAME, SIZE_YNAME, WRITE_YNAME

Declared= Character*80
Default  = Same name as YVAR.

Manually set the Y-value of the point.

Declared= Real*4
Default  = The value of YVAR

Select variable to draw in the diagram.

The user can draw an Y-variable from an another ident, by defining the name of the ident inside parenthesis: YVAR= var_name(ident)

The variable for the X-axle is defined in XVAR. If XVAR is undefined, the default X-variable of YVAR will apply.

In order to draw the curve upside-down, the variable can be preceded by a "-" sign. However in this case the auto-scale will not work. The user must manually set the scale factor in command YINT/CM.

Declared= Character*80(200)
Default  = 'NONE' i.e. no Y-variable.

Explanatory text of YVAR.
The text is printed if it is non-blank. The text is printed with the same text size as YNAME.

See also: LOC_YVAR_EXPL

Declared= Character*80    Default= " "(Blank)

Manually set the Z-value of the point.
Declared= Real*4
Default  = The value of ZVAR

Selects the scalar to be used as Z-value of the dot.

The user can draw a Z-variable from an another ident, by defining the name of the ident inside parenthesis: ZVAR= var_name(ident)

Declared= Character*80(200)
Default  = n/a

Examples

	Tsim_Simple_OneIdent.mplotf	Plotting curves from one ident.
	Tsim_Simple_ManyIdent.mplotf	Plotting curves from many idents.
	Tsim_Safe_OneIdent.mplotf	Postprocessing a time-domain simulation of a railway vehicle.
	wear_cur_opti_scal.mplotf	Plotting scalars from many idents.
	Root_Locus.mplotf	Creating a root-locus plot.
	vary_speed_lambda.mplotf	Creating a three-dimensional plot.