Home    Reference Manuals    Return   

Users Manual for Program CALC

Table of contents

Introduction
   General information on input.
   Error statements.
   Memory dump.
   Predefined variables.
   Redirection of input data reading.
   Definition and input of substructures.

Command line options

Description of the main calculation programs
   FRESP Frequency-response analysis.
   MODAL Modal analysis.
   QUASI Quasistatical analysis.
   TSIM Numerical integration.
   Local coordinate systems.
   Couplings.

Search command by operation

Input data commands

Examples

Export of results

Introduction

The program CALC is the central calculation program in GENSYS. The program can be started with four different scripts depending on which type of analysis is required. The different scripts are:

1. QUASI, which calculates the quasistatical state of the input data model, i.e. seeks the position where all the speed derivatives are equal to zero.
2. MODAL, which performs eigenfrequency calculations of the input data model.
3. FRESP, which performs frequency-response analysis of the input data model.
4. TSIM, which performs numerical integration in the time domain.

The program is a general variable processing program. All the major functions in the program are labeled variables. The variables are dependent on each other according to a specific system described in the input data. The input data model can be built-up of local coordinate systems, bodies, couplings, and mathematical functions. The mathematical functions are defined by the main command 'func' and are very powerful. In addition to creating new variables in the memory, they can also transfer output data in existing variables.

General information on input procedures and the user manual

Input data consists of word and word-delimiters, and is read in free format. Word-delimiters are: "="(equal sign), " "(space),"→"(tab), ","(comma) and "↵"(carriage return). All other characters or word are considered to be commands or data.

Main commands and sub-commands are case insensitive. Other input data is case sensitive. I.e variable VKMH is not the same as variable vkmh.

Almost all input data commands consists of the following four items:

1. Main Command
2. Sub-command (sub-commands are different for different main commands)
3. Coupling, mass, variable,,,etc. to be created.
4. Input data arguments depending on the main- and sub- command

In order to differentiate between different types of input data in this manual. Variables has been marked with differet types of symbols/accents. The accents have the following meanings:

• Words enclosed between grave accents ` `
  The program expects to read a valid main- or sub- command.
• Words enclosed between a grave accent and an acute accent ` '
  The program expects to read a variable previously defined in the input data.
• Words without accents
  The program expects to read data constants which comprise integer or real.
• Words which begin with signs and a grave accent +-`
  The program accepts reading a variable or a constant. The name of the variable can have up to two preceding plus and/or minus signs
• Words which begin with signs and a grave accent in parenthesis (+-`)
  The program accepts reading a variable or a constant, as under +-` above. But in this case the value of the variable is only retrived during the startup phase of the calculation program. After the text "Initial time" has been written to standard output, the value of the variable to the right of (+-`) will not be updated.
• Words given in braces { } separated by vertical bars |
  Gives the user the opportunities to give several alternative names of variables for program CALC to read. Example:
  { var1 | var2 | var3 }
  Program CALC starts seaching for variable var1. If not variable var1 can be found, program CALC searches in the memory again, now for variable var2. If not variable var2 can be found, program CALC searches in the memory again, now for variable var3 , , , etc.

If the variable consists of a +, -, *, /, ( or ) - sign. Program CALC assumes that a formula has been written as input. Program CALC will then evaluate the value of the formula and use the result as input data.

Variables containing an "_" (underscore) in its name has a very special meaning. The underscore sign indicates that the name of the variable can be truncated.
Example:
You define variable mu_1 in your input data file, when the wheel rail couplings later are going to be created the value of variable mu_1 will correspond to the coefficient of friction between wheel and rail in the first vehicle. Because when the first coupling/contact-zone cp1_111r is going to be created the coupling initially looks for a friction named mu_111r. If variable mu_111r not can be found in memory, cp1_111r continues and searches for a variable named mu_111. If variable mu_111 is undefined, coupling cp1_111r looks for a variable named mu_11. Finally if variable mu_11 is undefined, coupling cp1_111r will search and find the variable mu_1.
This means that you in input data can define two or more coefficient of friction between wheel and rail. For example if mu_1 and cp1_111l are defined, this will lead to that all wheels in vehicle number 1, will be given friction coefficient mu_1 except wheel number 111l that will be given the friction coefficient mu_111l.
A friction variable named mu_ will denote the default coefficient of friction for all wheels in all vehicles.

The input data file is concluded with the characters E0F to mark that the file has come to an end. The reason why it is done in this way, is to enable the main program to determine whether the expansion of all insert files and substructures has succeeded.

Error statements.

CALC separates fatal errors, where execution cannot continue, from non-fatal errors, where only a warning text appears. A fatal error has the following fundamental appearance:

                                                                
 ***ERROR*** In In_mass:                                        
             Max. no. of bodies = 400                           
             mass type = m_rigid_6                              
             mass name = car_1                                  
             cannot be created, skip the rest of data group     
                                                                

After the ***ERROR***-text, the subroutine will be displayed which generated the statement. The type of error will be displayed on the second line, and the type of component and component's name, which were under operation when the error arose, will be displayed on the third and fourth line. This means that the program will skip over the number of posts which remain to be read in the input data group. After this statement, the program will be terminated and the script will be interrupted.

A non-fatal error has the following fundamental appearance:

                                                                
 * warning * In Error: from routine=In_coupl                    
             Variable name kxkb_1h is already defined           
             coupling type = k_lin                              
             coupling name = kxkb_1h                            
             cannot be created, skip the rest of data group     
                                                                

After the * warning * -text, the subroutine will be displayed which generated the statement, and in this case the statement has occurred in the routine Error as instructed by the routine In_coupl. The reason for the error is given on the second line, and the type of component and component's name, which were under operation when the error arose, are displayed on the third and fourth line. This last line means that the program has skipped over the number of posts which remain to be read in the input data group, so that the next input data group can be read.

Memory dump

Every command in the input data file creates a number of memory cells in the program's memory. The different commands occupy a different number of cells in the memory. The variables, which are created with the main command func, occupy the least space, whilst the main command lsys and mass can occupy up to 80 memory cells. Printing of the memory's content can be ordered if the input data 'idebug' is assigned any other value than zero. The memory dump has fundamentally the following appearance:

• Header lines.
• Index for local coordinate systems.
• Index for the system's degrees of freedom.
• Index for the system's bodies.
• Index for the system's couplings.
• Index for the functions.
• The equation matrix which transforms from the number of defined degrees of freedom to non restricted degrees of freedom.
• Memory cells, stored in the same order as the variables were defined in the input data file. The table comprises 5 columns No, Irel, It, Name, and Var:
  

  No	Refers to the number of the memory cell
  Irel	Refers to the relative address within each input data group
  It	Refers to the type of data which is stored in the memory cell =  0 Var contains the value of the variable = -1 Var contains the address to the variable = -2 Var contains the address to the variable, which negative value shall be used = -4 Var is a character variable = -5 Var is a memory field created in func intpl_r, func fifo_mem or func intpl_track_irr3, = -6 Var is a memory field created in func intpl2_r, = -7 Var is a coupling property >  0 Var is a function
  Name	Refers to the name of the variable
  Var	Is the memory cell

Predefined variables

Program CALC creates the first 23 variables in the memory before the input data is read. The first 23 variables contain the following information:

                                                                                           
 No Irel It Name              Var           Explanation                                    
---------------------------------------------------------------------------------------    
  1  0   0  time              0.00000e+00   Time variable for TSIM                         
  2  1   0  timestep          1.00000e-03   Time step in TSIM                              
  3  2   0  timestep_err      0.00000e+00   Numerical error in TSIM for each timestep      
  4  3   0  freq              0.00000e+00   Frequency variable for FRESP                   
  5  4   0  fstep             0.00000e+00   Frequency step in FRESP                        
  6  5   0  accel.x           0.00000e+00   Longitudinal acceleration in fsys              
  7  6   0  accel.y           0.00000e+00   Lateral acceleration in fsys.                  
  8  7   0  accel.z           9.81000e+00   Vertical acceleration in fsys                  
  9  8   0  tout              1.00000e-02   Time step for writing on file MPdat            
 10  9   0  zero              0.00000e+00   Variable containing the value zero             
 11 10   0  calc_type         4.00000E+00   Variable indicating type of analysis           
 12 11   0  max_tstep         1.00000E-03   Max allowable timestep                         
 13 12   0  min_tstep         1.00000E-07   Min allowable timestep                         
 14 13   0  IntegratorDebug   0.00000E+00   Degree of freedom which controls the timestep  
 15 14   0  tstart            0.00000E+00   Start time                                     
 16 15   0  tstop             4.00000E+00   Stop time                                      
 17 16   0                    0.00000E+00   Extra memory cells reserved for future use     
 18 17   0                    0.00000E+00                                                  
 19 18   0                    0.00000E+00                                                  
 20 19   0                    0.00000E+00                                                  
 21 20   0                    0.00000E+00                                                  
 22  0  -4  CalcType                 TSIM   Character variable indicating type of analysis 
 23  1   1  char              1.00000E+00                                                  
                                                                                           

The character-variable CalcType is a variable indicating type of analysis being currently performed. It is an information for the user if he or she like to write input data which shall be different depending on type of analysis. The character-variable CalcType can have the following values:

 FRESP     Frequency-Response analysis                                  
 MODAL     Modal analysis                                               
 QUASI     Quasistatical analysis                                       
 TSIM      Time domain integration analysis                             
 NPICK     Picking flexible mode shapes from a FEM-analysis             
 PREDAT    Create stiffnesses and damping from preferred eigenvalues    
 GPLOT     Geometry plot program                                        
 RUNF_INFO Input data file information program                          

In input data the user can use the CalcType-variable in the following example:

##                                                                      
##  Read flexible parameters for the carbody                            
##  ==========================================================          
   if_then_char_init CalcType .ne. NPICK                                
    insert file npickr/$IDENT.npickr                                    
   endif                                                                

In the above example file npickr/$IDENT.npickr is not read when current analysis type is NPICK. We don't want program NPICK to read that file because program NPICK is supposed to create that file.

Redirection of input data reading

In the command 'insert file <insfil>', input reading will be redirected to file insfil. The insert-command can also be given in the inserted file to further redirect the input reading.

In command 'insert format' <format> <insfil>, the input data file and its contents will be expanded from a pre-defined ASCII-file insfile, according to the format specification <format>.
The file will be inserted into the main file in the exact same form. The format statement which is given in input data, is used in FORTRAN's read statement which reads <insfil>.
During the input phase, there are two valid format specifications which are: a(character) and x(skip). Almost all format specifications contain commas, which is why the format specification must be enclosed in accents. Otherwise the comma will be interpreted as a delimiter. Moreover, the format specifications must also be set in parentheses.

Example:
Read the column positions 1-10 and 21-30 from the file "testfile".

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

Please see further details under main command "insert"

Definition and input of substructures.

If the same input data shall be repeated several times with only minor differences in the actual data, the input data can easily be formulated in a substructure with arguments. When the substructure is later called, the different values can be entered into the substructure's argument.
Users, who are acquainted with programming in FORTRAN or Pascal, will see great similarities with FORTRAN's substructures and/or Pascal's procedures. Users, who have worked with UNIX-scripts may see similarities between a substructure in CALC-input data and a UNIX-script.
Below follows a description using a simple example.
A substructure is defined with the command:

                                    
 substruct struct_name [            
  . . . .                           
  input data commands               
  containing arguments $1, $2, etc. 
  . . . .                           
 ]                                  
                                    

Every substructure is given a name "struct_name", and the content of the substructure is defined within brackets [ ]. This substructure is now stored in an temporary file for later use in the directive in_substruct. Like in a UNIX-script the substructure has arguments $1, $2 etc. up to $9. When the command in_substruct is given, this argument must be replaced by a character string or a number. The routine which inserts the argument into the substructure is a simple text editor. If a number is given as argument in the summons of a substructure, it will still be treated as a text string which replaces the symbol $1 in the substructure.

The following command initiates the input of a defined substructure:

                                                
 in_substruct struct_name [ arg1, arg2, etc. ]  
                                                

The definition of the argument to the substructure is given in brackets.

Example:
A wheel-rail geometry function to describe wheels with constant conicity.

                                                                               
 #                                                                             
 #                                                                             
 #     WHEEL-RAIL GEOMETRY FUNCTION for ideally conic wheels                   
 #     -----------------------------------------------------                   
 #     $1 = name or number of the vehicle                                      
 #     $2 = the conicity of the wheel                                          
 #                                                                             
         substruct kpf_rkona   [                                               
    func  intpl_r  drkp_r$1    -1.000    -$2       1.000     $2                
    func  intpl_r  gamkph_r$1  -1.000    -$2       1.000    -$2                
    func  intpl_r  gamkpv_r$1  -1.000     $2       1.000     $2                
    func  intpl_r  zkp_r$1     -1.000    -$2       1.000     $2                
    func  intpl_r  rohr_r$1    -1.000     2.222222 1.        2.222222  ]       
                                                                               

It is now possible to use the different conicities for the different carriages in a train unit of the same substructure. This can be done in the following way using the substructure commands:

                                        
  in_substruct kpf_rkona [ 1 0.1 ]      
  in_substruct kpf_rkona [ 2 0.200 ]    
  in_substruct kpf_rkona [ 111 0.3 ]    
                                        

The output data from the above-mentioned commands will give a wheel-rail profile with a conicity of 0.1 in the vehicle named 1, 0.2 in the vehicle named 2, and conicity 0.3 in the vehicle named 111. All the wheels are given a lateral curvature variance of 2.222 (m).

                                                                        
  func  intpl_r  drkp_r1    -1.000    -0.1       1.000     0.1          
  func  intpl_r  gamkph_r1  -1.000    -0.1       1.000    -0.1          
  func  intpl_r  gamkpv_r1  -1.000     0.1       1.000     0.1          
  func  intpl_r  zkp_r1     -1.000    -0.1       1.000     0.1          
  func  intpl_r  rohr_r1    -1.000     2.222222 1.      2.222222        
                                                                        
  func  intpl_r  drkp_r2    -1.000    -0.200       1.000     0.200      
  func  intpl_r  gamkph_r2  -1.000    -0.200       1.000    -0.200      
  func  intpl_r  gamkpv_r2  -1.000     0.200       1.000     0.200      
  func  intpl_r  zkp_r2     -1.000    -0.200       1.000     0.200      
  func  intpl_r  rohr_r2    -1.000     2.222222 1.        2.222222      
                                                                        
  func  intpl_r  drkp_r111    -1.000    -0.3       1.000     0.3        
  func  intpl_r  gamkph_r111  -1.000    -0.3       1.000    -0.3        
  func  intpl_r  gamkpv_r111  -1.000     0.3       1.000     0.3        
  func  intpl_r  zkp_r111     -1.000    -0.3       1.000     0.3        
  func  intpl_r  rohr_r111    -1.000     2.222222 1.        2.222222    
                                                                        

Command line options.

For program CALC a number of command line options are available. The user can put his or hers favorite options in a file named .gen_conf. Program CALC searches primarily for the .gen_conf-file in the local working directory. If the file not can be found in the local working directory, program CALC searches for the .gen_conf-file in the users home-directory. At last if no .gen_conf-file can be found program CALC reads the file $gensys/scripts/gen_conf. Following options are understood:

Description of the main calculation programs.

FRESP Frequency-response analysis.

FRESP is the mode in program CALC which performs the frequency response analysis. The user can choose between different types of frequency response analysis in command fresp_param. The excitation of the model in mode FRESP is defined in command fexcit. Before the analysis starts in FRESP the model must be linearized, because the frequency response analysis is performed in the frequency domain.
The linearization process is made automatically in FRESP, the user must not change anything in the input data. FRESP linearizes the model by moving each degree of freedom an amount epsilon and measure the response in all other degrees of freedom in the model. In this way, a so-called "Jacobian matrix" is formed which describes the properties of the model for small movements around the actual position of the model. The actual position around which the linearization takes place can be changed by giving the model an initial offset by the initval command.
When the Jacobian matrix is created program FRESP uses the matrix for creating the frequency response by stepping from fstart to fstop in steps controlled by fstep. If the frequency response type in command fresp_param equals to Fourier_CG1 the answer will be complex, in this case FRESP will store the results in the following way:

If the user only is interested in the absolute value of the frequency response spectra, he or she can use the function cabs available in program MPLOT, in order to make the complex frequency response spectra a real frequency response spectra. If the user is interested in knowing the time shift for a frequency in the spectra the user shall look at the phase angle of the spectra. The phase angle is defined as atan2( mass.vx, mass.x), and can be calculated by function atan2 in MPLOT.
The output data from the frequency response analysis is presented in two different files:

$ident.modjac
The Jacobian matrix is presented in the output data file with the extension .modjac. The file is written in ASCII-format and can be viewed directly in a editor.

$ident.id
The frequency response spectra are stored as complex vectors on the output data file with the extension.id. The storing of the vectors for further post processing is specified in command s_var sngl. The file is written in MPdat-format so that it can be read by the post processor MPLOT.

MODAL Modal analysis.

MODAL is the mode in program CALC calculating the eigenvalues and modal shapes of the model. In command modal_param the user can choose between different types of methods in the modal analysis procedure. In modal analysis there is no need for excitation of the model. Before the analysis starts in MODAL the model must be linearized, because the search for eigenvalues is performed in the frequency domain.

The linearization process is made automatically in MODAL, the user must not change anything in the input data. MODAL linearizes the model by moving each degree of freedom an amount epsilon and measure the response in all other degrees of freedom in the model. In this way, a so-called "Jacobian matrix" is formed which describes the properties of the model for small movements around the actual position of the model. The actual position around which the linearization takes place can be changed by giving the model an initial offset by the initval command.

When the Jacobian matrix is created program MODAL uses the matrix for calculating the eigenvalues. The analysis in program MODAL will be complex because large damping in the model is considered.

The deduction of the complex eigen value for a one-dimensional mass is shown in the document Eigen_Freq_Deduce.html

The output data from the modal analysis is presented in five different files:

$ident.modjac
The Jacobian matrix is presented in the output data file with the extension .modjac. The file is written in ASCII-format and can be viewed directly in a editor.

$ident.mode
All the eigenvalues are presented in the output data file with the extension .mode. The file is in ASCII-format and can be printed directly on a laser printer.

$ident.modf
All the modal shapes are presented on the output data file with the extension .modf. The file is in ASCII-format and can be printed directly on a laser printer. On the file, the modal shapes are scaled so that the largest component is equal to the complex number (1,0). Furthermore, the modal shapes are listed so that the modal shape's largest component is listed first and is then followed by the remaining components in order of size.

$ident.id
All the eigenfrequencies are stored as complex scalars on the output data file with the extension.id. The file is written in MPdat-format so that it can be read by the plot program MPLOT. The complex scalars are stored with names taken from the degree of freedom which has the predominant modal shape. It is not possible to determine whether an eigenfrequency belongs to a certain degree of freedom, but the scalars must have a name to make reference possible in MPLOT, so therefore the MODAL program has been provided with this name-giving generator. On certain occasions the name-giving generator can assign an unfortunate name to an eigenfrequency, so in order to determine the actual physiognomy of an eigenfrequency, it is recommended that the forms' appearance is plotted out in the program GPLOT. However, it can be practical to assign a name to the forms when a parameter variation is executed, and the forms' appearance does not greatly vary between each parameter change. The name-generator will then assign the same name to the same forms, even if the output data is derived from different calculations.

$ident.gp
All the eigenvalues and eigenmodes will be stored in GPdat-format on the output data file with extension .gp. The file can be read in program GPLOT for plotting and animating the different mode shapes.

QUASI Quasistatical analysis.

QUASI is the mode in program CALC calculating the quasistatical position of the model. In command quasi_param the user can choose between different types of methods in the quasistatical analysis procedure. Program mode QUASI operates on the full non-linear model, searching the position where internal forces are balanced with respect to external forces and acceleration fields.
The output data from the quasistatical analysis is presented in two different files:

$ident.id
The frequency response spectra are stored as complex vectors on the output data file with the extension.id. The file is written in MPdat-format so that it can be read by the plot program MPLOT. All the eigenfrequencies are stored as complex scalars on the output data file with the extension.id. The file is written in MPdat-format so that it can be read by the plot program MPLOT. The complex scalars are stored with names taken from the degree of freedom which has the predominant modal shape. It is not possible to determine whether an eigenfrequency belongs to a certain degree of freedom, but the scalars must have a name to make reference possible in MPLOT, so therefore the MODAL program has been provided with this name-giving generator. On certain occasions the name-giving generator can assign an unfortunate name to an eigenfrequency, so in order to determine the actual physiognomy of an eigenfrequency, it is recommended that the forms' appearance is plotted out in the program GPLOT. However, it can be practical to assign a name to the forms when a parameter variation is executed, and the forms' appearance does not greatly vary between each parameter change. The name-generator will then assign the same name to the same forms, even if the output data is derived from different calculations.

$ident.gp
All the eigenvalues and eigenmodes will be stored in GPdat-format on the output data file with extension .gp. The file can be read in program GPLOT for plotting and animating the different mode shapes.

QUASI is the command and subprogram which searches the position of all degree of freedoms where internal forces are balanced with respect to external forces, acceleration fields and track irregularities. The program is useful for many things. For example:

• Calculation of initial conditions for program FRESP, MODAL and TSIM. Especially for programs FRESP and MODAL it is important to have correct initial conditions, otherwise the normal forces in the contact point can be wrong.

• Calculation of carbody and bogie roll-coefficient. Please read the document Calculation of roll coefficient on tangent track.

• Calculation of wheel unloading on twisted track. Please read the document Calculation of wheel unloading on twisted track.

The output data from the calculation is loaded onto a file in GPdat-format using the name $ident.gp. This data can be retrieved by CALC using the directive initval read_gpdat. The GPdat-file can also be loaded into the plotting program GPLOT for graphic presentation of the vehicle's position.

The output data can also be stored as scalars in a file written in MPdat-format. In order to save scalars to the MPdat-file, please use the commands: s_var scalar_0 or s_var var_0.

TSIM Numerical integration in time domain.

TSIM is the command and subprogram which executes time simulations. The program advances in time with the help of a numerical integrator which is selected in the command tsim_param.

The integrator performs the commands in the same order as the input data has built-up the model. It is, therefore, important that the input data is entered in the right time order, so that the calculations will also be executed in the right order. All ingoing variables must be defined before they can be used. All new variables, which are defined in the program, are checked that their names have not been defined earlier, if so a warning or error message will appear. Further information about execution order can be found in TSIM order

Local coordinate systems, bodies and couplings cannot be redefined in the input data file, the data will be taken from the first definition. If the user tries to redefine an existing coordinate system, body or coupling, program CALC will not read the new data, only a warning message will be printed.
In command FUNC however it is the opposite because command FUNC writes directly on the variable when the input data line is read. If the variable does not exist it will be created, and if it exists it will be overwritten.

Local coordinate systems.

When creating models in GENSYS the user have access to three types of coordinate systems:

The coordinate systems are connected to each other according to the following figure:

bsys is the body fixed coordinate system, which describes the position of the mass relative to its lsys.

Variable Shift_Xposition

If the longitudinal coordinate of the track consists of many digits i.e. more digits than can be read in single precision. The user has the possibility to shift the whole train-set in longitudinal direction, including the track irregularities and the designed track geometry. In order to shift the whole model in longitudinal direction a variable with the name "Shift_Xposition" must exit. If the starting position of the model has a coordinate bigger than 100000 or less than -100000 the user will be prompted to define the "Shift_Xposition"-variable.

Couplings.

The couplings between the different bodies are defined with the command 'coupl'. They can include stiffness, viscous dampers, friction dampers, viscous dampers in series with stiffness, and rolling friction coupling between wheel and rail.

If the coupling's direction is equal to x, y, z, f, k, p, or m, the displacement of the coupling will be calculated in the following way: the position of the coupling's attachment point in body 2 is subtracted by the position of the coupling's attachment in body 1. The attachment points' positions are calculated in the esys which was specified in the input data of the coupling. If a coupling has been used which lacks the input data argument for esys, the connected bodies must both belong to the same esys, otherwise an error print will occur.

If the coupling's direction is equal to 'c' or 'cu', the variable 'coupl.d' is written with a plus sign when the coupling is extended, and with a minus sign when the coupling is compressed. The coupling's force 'coupl.F' is calculated as 'coupl.d' multiplied by the stiffness' characteristic.

The same rationale, as stated above, also applies for dampers. However, instead of the coupling's deformation, the coupling's deformation velocity is used.

Search by operation.

3) Input data main-commands.

Summary of all main commands:

Old and obsolete input data commands.

For backward compatibility reasons, old and obsolete input data commands has been kept in the program. However the use of old input data commands is not encourenged, therefore they have been removed from the list above. If you have an old input data file contaning old commands that is not documented in this manual, you can search for your command in Old_input_calc.html.

'accel', `a_type`, input(*)

Definition of an external acceleration field.
Input data consists of subcommand `a_type`, and a number of input data arguments depending on the chosen subcommand.

The acceleration field is applied to all the bodies in the model. The coordinate directions are set according to every body's individual lsys.

                                
  accel local_all  ax ay az     
                                

Three values are read (ax,ay,az), one value for each direction of the coordinate axes. Default values are ax=0., ay=0. and az=9.81.

`body`

Definition of the physical size and shape of a mass.
Data describing the physical size and shape of a mass can be given in the input data file, but it's contents will not be read by program CALC. The size and shape of the mass is intended for the graphic postprocessor GPLOT. For the description of available body-commands please look in the users manual of program GPLOT.

`check_if_then_at_0`

Always check the test in if_then-statements, even at time= tstart.
If not check_if_then_at_0 is set, all statements in all if_then-endif-blocks will be executed when program CALC reads the input data file at time= tstart. If check_if_then_at_0 is set, program CALC will always check if the test is true or false before executing the commands inside if_then-statements.

The reason for introducing this command is to keep backward compatibility for old input data files.

`constr`= `cr_type`, input(*)

Setting constraints to integrated variables.
When a constraint is set to the system, the number of freedoms in the system will be reduced.
Command `constr` has the following subcommands:

Transfers forces and moments acting on a constraint body to a free body.
The body `m_constr' is not allowed to have any degrees of freedom, in the directions listed under `directions` below. I.e. before command conn_body_fm can be used the user must set a constraint constr fix_rigid_1, constr fix_free_1 or the constraint body may have been generated by the command mass fixpoint_6.
The procedure for the transfer of forces between the bodies, is that the forces acting on the constraint body is simply added to the forces acting on the free body. The procedure for the transfer of moments between the bodies, is that the moments acting on the constraint body is added to the moments acting on the free body, but considerations will also be taken if the two bodies have their center of gravity located at different places.
The free body and the constraint body must belong to the same lsys, otherwise program CALC will stop and an error message will be written.

                                                        
  constr conn_body_fm  `m_constr' `m_conn' `directions` 
                                                        

Eliminates an equation of motion.
Eliminates a defined degree of freedom in the equation system.
The equation of motion is expressed as a linear combination of other unconstraint equation of motion in the system.

                                                                                   
  constr conn_free_1  `f_name' +-`fact1 `y_name1' +-`fact2 `y_name2' +-`fact3,,,   
                                                                                   

f_name = fact1*y_name1 + fact2*y_name2 + ... etc.

Input data reading of factors and variables will take place until a new valid main command according to Input data commands has been read.

Eliminates an equation of motion in the equation system.
This command just simply removes the equation of motion for the degree of freedom given in `freedom_name' below. The integrated variable `freedom_name' will now be transformed into an ordinary variable in the main memory of program CALC. After removing the equation of motion for variable `freedom_name', its value will be set to the constant value "cvalue". If the user wants to change or regulate the variable `freedom_name' it is now OK to overwrite its value with func-commands.

                                                
  constr fix_free_1  `freedom_name'  cvalue     
                                                

In time domain simulation and quasistatical analysis, the variable `freedom_name' will be set to a constant value "cvalue". In frequency-response and modal analysis, the real part will be set to "cvalue", and the imaginary part is set to 0(zero).

Eliminates a degree of motion in a body.
Sets the positional degree of freedom to a constant value, and the velocity degree of freedom to 0 (zero).

                                                
  constr fix_rigid_1  `m_name' `dire` value     
                                                

In time simulation and quasistatical analysis, the data position m_name.dire will be set to a constant value, the body's velocity will be set to 0 (zero) in direction `dire`. In frequency-response and modal analysis, the real part will be set to value, and the imaginary part will be set to 0 (zero).

Eliminates a degree of motion in a body.
Sets the positional degree of freedom to a value which varies according to a previously defined variable. The velocity degree of freedom for the body will be set to the value 0 (zero).

                                                  
  constr fix_rigid_2  `m_name' `dire` `variable'  
                                                  

In time simulation and quasistatical analysis, variable m_name.dire will be set to a value taken from a previously defined variable in the main memory. The velocity of the body will not be calculated, the fix_rigid_2-command will set the velocity of the body to 0(zero). In frequency-response and modal analysis, the real part will be set to the value of the variable, and the imaginary part will be set to 0 (zero).

`eof`

Marks the end of the input data file.
Because the expansion of substructures is made in smaller programs outside the main program, it is necessary to have a final flag on the input data file which verifies that the expansion of the substructures has been successful.

'fexcit'= `fex_type`, input(*)

Definition of excitation points for frequency-response spectra analysis.
Input data consists of subcommand `fex_type`, and a number of input data arguments depending on the chosen subcommand.
Command `force` has the following valid subcommands:

This type of excitation refers to a displacement of a body's center of gravity in any of the coordinate directions x,y,z,f,k or p. In the direction the body is excited, the body's degrees of freedom must have constraints, alternatively the body can be defined with the command `mass fixpoint_6`. The spectra which is used in the excitation must be real. The spectra can, for example, be given via the command "func intpl_r". Despite the fact that the spectra is real in command "func intpl_r", it is in command "fexcit displ_fr" stored in a complex form, due to the time delay t_delay given in input(*) below.

                                                        
  fexcit displ_fr  `body' `dire` `spectra' +-`t_delay   
                                                        

  Fex(f) = F(f)*e(-2*pi*i*f*t_delay)

In contrast to displ_fr, displ_o reads a complex spectra with angular frequency scale. The command displ_o also has an input data parameter t_fact which makes it possible to change the scale of the frequency of the input spectra. If the value of t_fact is set to the speed of the vehicle, the input spectra `spectra_r' and `spectra_i' will be read as spatial frequency. This type of excitation refers to a displacement of a body's center of gravity in any of the coordinate directions x,y,z,f,k or p. In the direction the body is excited, the body's degrees of freedom must have constraints, alternatively the body can be defined in the command `mass fixpoint_6`. The frequency spectra is defined by two data fields `spectra_r' and `spectra_i', defining the real and imaginary part respectively. The data fields `spectra_r' and `spectra_i', can for example, be given in the command "func intpl_r".

                                                                                
  fexcit displ_o  `body' `dire` `spectra_r' `spectra_i' +-`t_delay +-`t_fact    
                                                                                

  Fex(omega) = F(omega)*e(-i*omega*t_delay)

                        
  fext = omega/t_fact   
                        

`force` = `force_type`, input(*)

Definition of external forces.
Input data consists of subcommand `force_type`, and a number of input data arguments depending on the chosen subcommand.
Command `force` has the following valid subcommands:

External force applied to a mass in its local coordinate system lsys. Input data is given as follows:

force rel_lsys1  `fo_name' `m_name'   +-`a  +-`b  +-`h        
                                      +-`Fx +-`Fy +-`Fz       
                                      +-`Mf +-`Mk +-`Mp       

External force applied to a mass. The force is attached to the mass. If the mass moves the force will follow with the mass. Input data is given as follows:

force rel_mass1  `fo_name' `m_name'   +-`a  +-`b  +-`h        
                                      +-`Fx +-`Fy +-`Fz       
                                      +-`Mf +-`Mk +-`Mp       

`fresp`

Order the CALC-program to perform a frequency-response analysis.
Normally this command is given via the script fresp when the frequency-response analysis is initiated, but it can also be given manually if so desired.

`fresp_param` = `f_method`, input(*)

Defines different parameters for the frequency-response analysis.
If command fresp_param not is given in the input data file, m_method='Fourier_CG1' with its default values will apply.
Command `fresp_param` has the following valid subcommands:

Method Fourier_CGI calculates frequency-responses of Fourier spectra.
The spectra are calculated using Gauss elimination. In order to obtain a result not equal zero, the model must be excited in one or more points, this can be done with command `fexcit`.
Input data to `fresp_param Fourier_CG1` are:

                                                                                  
  fresp_param Fourier_CG1  linj_eps   idof_1 leps_1  idof_2 leps_2  idof_3  etc.  
                                                                                  

Method PSD_LU1 calculates frequency-responses of PSD-spectra.
The spectra are calculated using LU factorization. In order to obtain a result not equal zero, the model must be excited in one or more points, this can be done with command `fexcit`.
Input data to `fresp_param PSD_LU1` are:

                                                                              
  fresp_param PSD_LU1  linj_eps   idof_1 leps_1  idof_2 leps_2  idof_3  etc.  
                                                                              

`fstart`

Specifies the start frequency in frequency-response analysis.

`fstep`

Specifies the frequency steps in frequency-response analysis.
A positive number for fstep, gives the frequency step directly in (Hz). A negative number for fstep, gives the multiplication factor between two consecutive frequency steps. E.g. fstep = -1.10 means that every frequency step shall be separated by 10%.

`fstop`

Specifies the stop frequency in frequency-response analysis.

`head` = head#, text

Definition of head lines.

The text is read from the lines first non-blank character until the end of the line. If the user wishes to begin the header line with a blank, this must be marked by the header being inserted within acute accents 'Headtext'. If a word in the head line is preceded by the $-sign, the CALC program will try to find a variable with the same name and replace the variable name including the $-sign with the variables value at time=0. If there is no variable name in the program's memory, this will not affect the content of the head text.

`idebug` = itype

Definition of different types of debug printing.

itype = 0

Does not normally give a debug print. But the program can create a debug print itself, which involves a memory dump to the file calc.out if an error is read in the input data.

itype = 1

Gives a memory dump to the file "calc.out" at time zero.

itype = 2

Gives a memory dump to the file "calc.out" at time zero.
In case of CalcType="TSIM", a memory dump also occurs to the file "calc.out" on calculation of the last time step. In addition to the memory dumps, all the function commands are written during the input phase on standard output.

itype = 3

Gives a memory dump to the file "calc.out" at time zero.
In the case of CalcType="TSIM", a memory dump also occurs to the file "calc.out" simultaneously with the output data storage on the file *.ca, i.e. every time tout is passed. In addition to the memory dumps, all the function commands under the input and calculation phases are printed on standard output.

`idebug_file`   file_name

Set the name of the file to where the debug information will be written. Amount of debug information to be written is controlled in the idebug-command. The default value for idebug_file is 'calc.out'.

`if_then`= `variable_1, `test`, `variable_2

Definition of an 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, depending on how variable_1 stands in relation to variable_2. The if_then-block is ended with the command endif, see below. If the test is true, the statements will be executed in the if_then-endif block, otherwise they will be passed over. Only coupl and func can appear in an if_then-block. The command if_then has the following input data:

variable_1 =

Test variable number 1 containing a variable name or data constant.

test =

Text string which defines the test condition. Following test strings are valid in test:
.eq.
True if variable_1 is equal to variable_2.      (See N.B. below)
.ne.
True if variable_1 is not equal to variable_2.   (See N.B. below)
.gt.
True if variable_1 is greater than variable_2.
.ge.
True if variable_1 is greater than or equal to variable_2.
.lt.
True if variable_1 is lesser than variable_2.
.le.
True if variable_1 is lesser than or equal to variable_2.

variable_2 =

Test variable number 2 containing a variable name or data constant.

All input data is, however, read into the memory during the program's input phase regardless of whether the test condition is true or false. The testing of whether the statement is true or false takes place in the calculation step, which is why the user can receive error prints during the input phase if the same variables are defined both inside and outside an if_then-endif block. The if_then-endif block can be written at several levels, as desired by the user. This will allow tests to be carried out which are based on several test conditions.
If it is enough to check the test condition in the input data phase of the program, the if_then_init-command can be used instead of the if_then-command. When the command if_then_init is given in the input data file, all the input data will be disregarded until the next endif-command. It is subsequently not possible to call upon the input data which have been disregarded.

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

`if_then_char_init`= `cvar1 `test1` `cvar2 `test2` `cvar3 `test3` `cvar4 ,,,etc.

Definition of an if_then_char_init-block.
The if_then_char_init-block works in a similar way as the if_then_init-command, with the exception that in if_then_char_init character variables are tested. If the test condition is true, the input data lines after the statement will be read until the next elseif_then_char_init-, else- or endif- statement.

It does not matter if the test condition changes value later during the calculation phase, as the program cannot return to the input phase and enter additional input data in the memory. The if_then_char_init-endif block can be written at several levels inside each other. However, max. 50 levels can be used.
The command "func char" enables the variable name to read the character strings.

`if_then_init`= +-`var1 `test1` +-`var2 `test2` +-`var3 `test3` +-`var4 ,,,etc.

Definition of an if_then_init-block.
The if_then_init-block works in a similar way as the if_then-command above, with the exception that the test condition is checked only once in the if_then_init-command. The checking of the test condition takes only place in the input data reading phase, and nothing will happen if the test condition changes state during the calculation phase. If the test condition is true, the input data lines after the statement will be read until the next elseif_then_init-, else- or endif- statement.

It does not matter if the test condition changes value later during the calculation phase, as the program cannot return to the input phase and enter additional input data in the memory. The if_then_init-endif block can be written at several levels inside each other. However, max. 50 levels can be used.
If the user wishes to be able to control the execution of different statements during the course of the calculation, please use the command if_then above.

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

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

`if_then_init`= `test`, `variable_1

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

`else`

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. An if_then-else decision statement begins with one of the commands: if_then-, if_then_char_init- or if_then_init

`elseif_then_init`= +-`var1 `test1` +-`var2 `test2` +-`var3 `test3` +-`var4 ,,,etc.

Continuation of an if_then_init-block.
If the previous if_then_init-statement was false the program will continue and evaluate the elseif_then_init statement. If the test condition in the elseif_then_init-statement is true, the input data lines after the statement will be read until the next elseif_then_init-, else- or endif- statement. How to formulate a test contition can be found under the if_then_init-command.

`elseif_then_char_init`= +-`var1 `test1` +-`var2 `test2` +-`var3 `test3` +-`var4 ,,,etc.

Continuation of an if_then_char_init-block.
If the previous if_then_char_init-statement was false the program will continue and evaluate the elseif_then_char_init statement. If the test condition in the elseif_then_char_init-statement is true, the input data lines after the statement will be read until the next elseif_then_char_init-, else- or endif- statement. How to formulate a test contition can be found under the if_then_char_init-command.

`endif`

End of an if_then-, if_then_char_init- or if_then_init-block

`initval`=`i_type`, input(*)

Input reading of initial values.
In the initval-command, initial values can be given to all variables in the main memory. If several initval-commands are given to the same variable, the last initval-command will apply.
Command `initval` has the following subcommands:

Reads the initial values from GPdat-file. If there are more degrees of freedom in the model than there are files, no value will be set on these degrees of freedom. If there are degrees of freedom on the file which are not available in the model, a warning text will appear but the program will continue execution without reading the initial value for unknown degree of freedom.

                                        
  initval read_gpdat  'filegp' def_no   
                                        

Sets initial values to masses.

                                                
  initval set_mass  `m_name' `dire` (+-`)value  
                                                

Sets the initial value to an arbitrary variable.

                                        
  initval set_var  `var' (+-`)value     
                                        

`insert` =`in_type`, input(*)

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.
Command `insert` has the following subcommands:

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

                                
  insert file  `insfile'        
                                

The insert and decrypt a file.
The inserted file must be encrypted by Program GENCRYPT. When a encrypted file has been read by the coded_file command it is not possible to write any information to the calc.out file.

                                        
  insert coded_file `key'  `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 '(10x,10a,10x,10a)' testfil    
                                               

The command above will on each line of testfil read the positions 11-20 and 31-40, the rest of testfil will be skipped.

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'        
                                                

Example:
A file contains 5 columns, columns 1 and 3 shall be read from the file data/testfil.

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

NB! All columns on the file data/testfil must be marked, either with an 'a' if the column is to be read, or with an 'x' if the column is not to be read.

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'   
                                                                

`loop_beg`= `var', tol, maxloop, `method`, input(*)

Definition of an algebraic loop.
If an algebraic loop has been defined in the input data, it will be enclosed between the commands loop_beg and loop_end. The command loop_beg requires the following input data:

`loop_end`

End of algebraic loop defined by loop_beg.

`loop_beg2`= `borv',`regv', tol, maxloop, `method`

Definition of an algebraic loop with two arguments.
Loop_beg2 and loop_end2 work in the same way as loop_beg and loop_end to solve algebraic loops in the input data model. Unlike loop_beg, loop_beg2 works with two arguments.Loop_beg2 uses argument two to coordinate that argument one is fulfilled. The command loop_beg2 requires the following input data:

`loop_end2`

End of algebraic loop defined by loop_beg2.

`lsys` = `l_type`, input(*)

Definition of local coordinate system.
There are a total of three different types of coordinate systems in the calculation model. These are:

1. fsys
   Fixed coordinate system, a coordinate system which always lies fixed and cannot be moved, hereafter called "fsys". The fsys coordinate system is the common coordinate system for all masses and couplings in the model.
2. esys
   Euler system, is a coordinate system which handle large displacements and rotations in relation to fsys. The Euler systems are hereafter called "esys" in this manual.
3. lsys
   Linear system, is the coordinate system which only considers small angles relative to esys. The linear system is hereafter called "lsys" in this manual.

Only esys and lsys can be defined in command lsys, as fsys always remains fixed.
It is relatively common that the simulated structure can move a large distance, but that the relative internal movements in the structure are small, the program is built-up so that in the modeling of the problem, first an esys is defined relative to fsys where large displacements and rotations are considered, then a lsys is defined for every mass in the structure relative to the created esys system where small rotations are considered. If large displacements and rotations between different parts in the structure must be considered, additional esys must be created. The reason for not creating an esys for each mass in the model is that the esys-systems are more CPU-consuming in relation to the lsys-systems.
In order to be able to define a body, it is necessary that a lsys is available for the body to relate to, and to be able to define a lsys, it is necessary that there is an esys which the lsys can relate to. Forces and displacements in couplings are normally calculated in an esys. For further details see how each coupling is defined.
Command `lsys` has the following subcommands:

Creates a fixed esys.
The position of the coordinate system is set during the initial phase of the calculation, and does not move during the calculation.

                                
  lsys e_fix  `l_name' xk yk zk 
                                

Creates a moving esys, clothoid type of transition curves.
The moving esys is guided by three memory fields ro_field, fi_field and z_field. The curvature, cant and vertical lift of the coordinate system is created by a linear interpolation in the memory fields.

Input data syntax:

                                                                             
  lsys e_abs_bend  `l_name' +-`vx (+-`)x `ro_field' `fi_field' `z_field'     
                                                                             

The variables created by lsys e_abs_bend are the same as created by lsys e_fix. Plus the following variables:

Creates a moving esys with transition curves proposed by Ruch in 1903, see equations below.
The three memory fields ro_field, fi_field and z_field, defines designed curvature, designed cant and designed vertical lift of track center line.

Input data syntax:

                                                                        
  lsys e_abs_bendr  `l_name'    +-`vx  (+-`)x                           
                    `ro_field'      `fi_field'      `z_field'           
                    (+-`)b1 (+-`)b2 (+-`)f1 (+-`)f2 (+-`)z1 (+-`)z2     
                                                                        

The variables created by lsys e_abs_bendr are the same as created by lsys e_abs_bend.

Below is a description of the transition curve's mathematical form for the track's curvature. The same equations also apply to cant and vertical lift of the track center line.

                                                                                
  Notations:                                                                    
  Lt   = Total length of the transition curve, including all three parts.       
  Lt*e1= Length of the first part of the transition curve.                      
  Lt*e2= Length of the third part of the transition curve.                      
  k0   = Curvature at the beginning of the transition curve.                    
  k1   = Curvature at the end of the transition curve.                          
  s    = Distance along the track.                                              
  k'   = The curvature's derivative in the second part of the transition curve. 
                                                                                
                                                                                
  Conditions:                                                                   
  Lt > 0                                                                        
  0 < e1 < 1                                                                    
  0 < e2 < 1                                                                    
  e1+e2 < 1                                                                     
                                                                                
  Equations:                                                                    
                                                                                
  k' = (k1-k0)/Lt/(1-e1/2-e2/2)                                                 
                                                                                
  The following applies for the first part:                                     
                                                                                
  k(s) = k0 + s^2*k'/Lt/e1/2                                                    
  0 < s < Lt*e1                                                                 
                                                                                
  The following applies for the second part:                                    
                                                                                
  k(s) = k0 + (s-Lt*e1/2)*k'                                                    
  Lt*e1 < s < Lt-Lt*e2                                                          
                                                                                
  The following applies for the third part:                                     
                                                                                
  k(s) = k1 - (Lt - s)^2*k'/Lt/e2/2                                             
  Lt-Lt*e2 < s < Lt                                                             
                                                                                

The three functions are created in such a way that the function and its first derivative are continuous within the transition curve and to the connecting circular curves.

The special case e1= e2= 0. makes the Ruch-curve equal to a clothoid.

The special case e1= e2= 0.5 makes the Ruch-curve equal to a Helmert or Schramm curve

Creates a moving esys with Ruch type of transition curves with fixed lengths
This coordinate system is very similar to lsys e_abs_bendr, but in lsys e_abs_bendrf the first and third part (e1 and e2) of the transition curve have fixed lengths.
If the length of the transition curve is shorter than e1+e2, then coordinate system e_abs_bendrf will create a transition curve according to Helmert.

Input data syntax:

                                                                        
  lsys e_abs_bendrf `l_name'    +-`vx  (+-`)x                           
                    `ro_field'      `fi_field'      `z_field'           
                    (+-`)b1 (+-`)b2 (+-`)f1 (+-`)f2 (+-`)z1 (+-`)z2     
                                                                        

The variables created by lsys e_abs_bendrf are the same as created by lsys e_abs_bend.

Below is a description of the transition curve's mathematical form for the track's curvature. The same equations also apply to cant and vertical lift of the track center line.

                                                                                
  Notations:                                                                    
  Lt = Total length of the transition curve, including all three parts.         
  d1 = Length of the transition curve's first part.                             
  d2 = Length of the transition curve's third part.                             
  k0 = Curvature at the beginning of the transition curve.                      
  k1 = Curvature at the end of the transition curve.                            
  s  = Distance along the track.                                                
  k' = The curvature's derivative in the second part of the transition curve.   
                                                                                
                                                                                
  Conditions:                                                                   
  Lt > 0                                                                        
  0 < d1 < Lt                                                                   
  0 < d2 < Lt                                                                   
  d1+d2 < Lt                                                                    
                                                                                
  Equations:                                                                    
                                                                                
  k' = (k1-k0) / (Lt-d1/2-d2/2)                                                 
                                                                                
  The following applies for the first part:                                     
                                                                                
  k(s) = k0 + s^2*k'/(2*d1)                                                     
  0 < s < d1                                                              
                                                                                
  The following applies for the second part:                                    
                                                                                
  k(s) = k0 + (s-d1/2)*k'                                                       
  d1 < s < Lt-d2                                                                
                                                                                
  The following applies for the third part:                                     
                                                                                
  k(s) = k1 - (Lt - s)^2*k'/(2*d2)                                              
  Lt-d2 < s < Lt                                                                
                                                                                

Creates a moving esys, guided by three memory fields ro_field, fi_field and z_field.
Interpolation in the memory fields are made with cubic splines.

Input data syntax:

                                                                              
  lsys e_abs_bends  `l_name' +-`vx (+-`)x  `ro_field' `fi_field' `z_field'    
                                                                              

The variables created by lsys e_abs_bends are the same as created by lsys e_abs_bend.

Controls the longitudinal position of a moving esys.
The position, velocity and acceleration of a Euler coordinate system, is controlled by connecting the coordinate system to a mass.

Input data syntax:

                                                                
  lsys e_reg_xpos  `l_name' `m_name' (+-`)efreq (+-`)edamp      
                                                                

Creates a linear local coordinate system.
L_local considers only small angles relative to the esys which lsys is related to. If the given esys system is one of the following types: e_abs_bend, e_abs_bendr, e_abs_bendrf or e_abs_bends, the same curvature, cant, and vertical lift will be used as defined in the definition of esys.

Input data syntax:

                                                          
  lsys l_local  `l_name' `esys' (+-`)xk (+-`)yk (+-`)zk   
                                                          

N.B. If the linear local coordinate system is connected to a Euler system of type e_abs_bend, e_abs_bendr, e_abs_bendrf or e_abs_bends, all the coordinate systems shall be defined on top of rail.

If lsys is connected to e_abs_bend, e_abs_bendr or e_abs_bends the following variables will also be generated in main memory:

`mass` = `m_type`, input(*)

Definition of a mass.
If a new body is created, and the new body has the same name as a previous body, the first body cannot be overwritten, as different masses require different amounts of space in the main memory. Therefore, the first defined body is the valid mass, and the second body will be ignored.

First a brief summary is given of the available subcommands in mass, followed by a detailed description of each subcommand.

m_type = `fixpoint_6`

Creates a mass with 6 directions, however these directions have no degrees of freedom as all movements are constricted. Therefore, no data regarding the mass matrix is necessary. The user can still move the mass defined in command fixpoint_6, by using simple func-commands which will overwrite the variables generated in the fixpoint_6-command.

                                                                
  mass fixpoint_6  `m_name' `lsys' (+-`)acg (+-`)bcg (+-`)hcg   
                                                                

m_type = `m_flex_1`

Defines a flexible body.
Before this command can be given, a rigid mass must have been defined previously in the input data, by command "mass m_rigid_6" or "mass m_rigid_36b". For every eigenfrequency which is given in this command, two equations of motion are added to the total number of equations in the input data model. The new equations are expressed in so-called generalized coordinates and are excited by generalized forces, which will be defined in command "coupl m_flex_1". Input of the input data is ended when new valid main command according to Input data main-commands is given.

                                                                                                        
  mass m_flex_1 `m_name' (+-`)fq1 (+-`)damp1 (+-`)fq2 (+-`)damp2 (+-`)fq3 ,,,  (+-`)fq(n) (+-`)damp(n)  
                                                                                                        

m_type = `m_rigid_1`

Creates a rigid mass with 1 degree of freedom.

                                                                                 
 mass m_rigid_1 `m_name' `lsys'  (+-`)acg (+-`)bcg (+-`)hcg  (+-`)m_data `dire`  
                                                                                 

m_type = `m_rigid_6`

Creates a mass with 6 degrees of freedoms.
In input data only the diagonal of the mass matrix of the mass, will be read.

                                                                                
  mass m_rigid_6  `m_name' `lsys'  (+-`)acg (+-`)bcg (+-`)hcg  (+-`)m_diag      
                                                                                

m_type = `m_rigid_6f`

Creates a mass without inertia acceleration.
In input data only the diagonal of the mass matrix of the mass, will be read. This type of mass is similar to the m_rigid_6-type of mass, except that m_rigid_6f has no inertia acceleration due to accelerating coordinate systems.

                                                                                
  mass m_rigid_6f  `m_name' `lsys'  (+-`)acg (+-`)bcg (+-`)hcg  (+-`)m_diag     
                                                                                

m_type = `m_rigid_36b`

Creates a body with 6 degrees of freedoms.
The equations of motion are set up in a body-fixed coordinate system. As input data, the entire local mass matrix is given.

                                                                                
  mass m_rigid_36b  `m_name' `lsys'  (+-`)acg (+-`)bcg (+-`)hcg  (+-`)m_mat     
                                                                                

  mxx, mxy, mxz, mxf, mxk, mxp, 
  myx, myy, myz, myf, myk, myp, 
  mzx, mzy, mzz, mzf, mzk, mzp, 
  mfx, mfy, mfz, mff, mfk, mfp, 
  mkx, mky, mkz, mkf, mkk, mkp, 
  mpx, mpy, mpz, mpf, mpk, mpp  

The variables generated in main memory are the same as for m_rigid_6.

m_type = `massless1`

Creates a mass without mass matrix, with the possibilities of motion in all coordinate directions. The mass only accepts connected couplings of type stiffnesses. Couplings with viscous damping of type c and kc are not accepted by massless1. On definition of massless1, the surrounding masses are also checked to ensure that they are of "m_rigid_6" or "m_rigid_36b" type bodies, where the positions are integrated.

                                                                
  mass massless1  `m_name' `lsys'  (+-`)acg (+-`)bcg (+-`)hcg   
                                    r_linj  r_feps  m_loop      
                                                                

m_type = `massless12`

Mass type massless12 only exists for compatibility reasons. Please use mass type massless13 instead.

m_type = `massless12p`

Mass type massless12p only exists for compatibility reasons. Please use mass type massless13p instead.

m_type = `massless13`

Creates a mass without mass matrix, with the possibilities of motion in all coordinate directions.
The body accepts k, k_lin, c, c_lin and kc type couplings linked to it. On definition of massless13, the surrounding masses are also checked to ensure that they are of "m_rigid_6" or "m_rigid_36b" type bodies, where the positions are integrated.

                                                                
  mass massless13  `m_name' `lsys' (+-`)acg (+-`)bcg (+-`)hcg   
                                    r_linj  r_feps  m_loop      
                                                                

m_type = `massless13p`

Creates a mass without mass matrix, with the possibilities of motion in all coordinate directions.
The body accepts k, k_lin, c, c_lin and kc type couplings linked to it. On definition of massless13p, the surrounding masses are also checked to ensure that they are of m_rigid_6 or m_rigid_36b type bodies, where the positions are integrated. The difference between massless13 and massless13p, is that the tolerance r_feps is given in unbalanced position instead of unbalanced force as in massless13 above.

                                                                  
  mass massless13p  `m_name' `lsys'  (+-`)acg (+-`)bcg (+-`)hcg   
                                      r_linj  r_feps  m_loop      
                                                                  

m_type = `massless14`

Creates a one-dimensional mass without mass matrix.
In other directions the mass is connected to another mass having six degrees of freedom.

                                                                
  mass massless14  `m_name' `lsys' (+-`)acg (+-`)bcg (+-`)hcg   
                                    r_linj  r_feps  m_loop      
                                    dire    mass2               
                                                                

m_type = `massless2`

Creates a mass without mass matrix, with the possibilities of motion in all coordinate directions.
The body only accepts k or c type couplings linked to it. The body's position is integrated by differential equation of the first order. Massless2, therefore, requires that at least one viscous coupling is connected in every coordinate direction. Should there not be a viscous coupling in a certain direction, the direction must have constraints. The eigenvalue for the massless point can be calculated according to the following equation:
$\omega =\frac{k}{c}$
The equation shows that the system will have a high eigenfrequency if the stiffness is high and the damping low.

                                                        
   mass massless2 `m_name' `lsys'  (+-`)acg (+-`)bcg (+-`)hcg     
                                                        

`max_exec_time` = (+-`)value

Setting max length of execution time.
If the execution time exceeds max_exec_time the calculation will be interrupted. If max_exec_time is less or equal to 0.(zero), max_exec_time will be discarded.
Reference Manuals   Calc menu   Input Data Menu

`modal`

Order the CALC-program to perform a modal analysis.
Normally this command is given via the script modal when the modal analysis is initiated, but can also be given manually if desired.

`modal_param` = `m_method`, input(*)

Defines different parameters for the modal analysis.
If command modal_param not is given in the input data file, m_method='Schur_fact1' with it's default values will apply.
Command `modal_param` has the following subcommands:

`f_method` = `QRfact_1`

Solves all the eigenvalues in complex form by the QR method. The complex eigenvectors are then solved by the inverse shifted power method. The system of equations is linearized and the Jacobian J is calculated before the modal analysis starts.

                                                                                                         
  modal_param QRfact_1  tol_ym tol_jm linj_eps mloopm ntrimm  idof_1 leps_1  idof_2 leps_2  idof_3 etc.  
                                                                                                         

The input parameters have the following default values:

                        
  tol_ym   = 1.e-5      
  tol_jm   = 1.e-7      
  linj_eps = 1.e-4      
  mloopm   = 50         
  ntrimm   = 3          
                        

`f_method` = `Schur_fact1`

Solves all the eigenvalues in complex form with Schur factorization. Subroutines from the LAPACK library have been used, when solving the eigenvalue problem with this method. The system of equations is linearized and the Jacobian J is calculated before the modal analysis starts.

                                                                                
  modal_param Schur_fact1  linj_eps  idof_1 leps_1  idof_2 leps_2  idof_3 etc.  
                                                                                

The input parameters have the following default values:

                    
 linj_eps = 1.e-4   
                    

`no_warning`

Suppresses warning messages from command func. When the user is acquainted with the warning texts from CALC, she/he can suppress the undesired warnings by using this command. The suppressing of warning messages is only valid for the next func-command, after the no_warning-command.

`overwrite_property`

Command overwrite_property makes it possible to overwrite an existent coupling property in the main memory. In the normal case coupling properties cannot be redefined, because different properties need different amount of memory cells. If the command overwrite_property is given in the beginning of the input data file, an existing property in the memory will be overwritten by the new property, if they have the same name. Program CALC will in this case: erase all values for the old existing property in existing memory position, write the new property last in the memory, and move all references to the new location of the property.

The reason for introducing this command is to keep backward compatibility for old input data files.

`post_process`   'cmd_string'

Execute an UNIX-command after the calculation.
When the calculation is finished, program CALC will send the string 'cmd_string' to the UNIX-system. Up to ten post_process-commands can be given in the input data file for program CALC. In the post_process-command the user has access to the $IDENT-variable. The $IDENT-variable will in the post_process-command be expanded to the name of the current ident-string.

Example:
The following example shows how the post_process-command can be used for post processing the results in program MPLOT and sending the plots to your printer:

                                                                      
  if_then_char_init  CalcType .eq. TSIM  .or.                         
                     CalcType .eq. MODAL                              
   post_process= 'mplot mplotf/Tsim_Safe_OneIdent.mplotf $IDENT'      
   post_process= 'pri diags/$IDENT.ps'                                
  endif                                                               
                                                                      

`pre_process`   'cmd_string'

Execute an UNIX-command before the calculation starts.
The user can here for instance, define a pre processing activity in the KPF, NPICK or QUASI program.
In string 'cmd_string' two variables are understood:

An unlimited number of pre_process-commands can be given in the input data file for CALC.

Example:
The following example shows how the pre_process-command can be used for automatic update of modal shapes of an elastic body, and also calculates the quasistatical position before the time-domain or modal analysis begins:

                                                                                                            
  if_then_char_init  CalcType .eq. TSIM  .or.                                                               
                     CalcType .eq. MODAL                                                                    
   pre_process=  'sed s!runf/Master.runf!$CURRENT_FILE! npickf/Master.npickf > npickf/$IDENT.npickf'        
   pre_process=  'npick npickf/$IDENT.npickf'                                                               
   pre_process=  'quasi $CURRENT_FILE'                                                                      
  endif                                                                                                     
                                                                                                            

Also the following lines must be entered into the input data file in order to read the results from program NPICK and QUASI.

                                                
  if_then_char_init CalcType .ne. NPICK         
   insert file npickr/$IDENT.npickr             
  endif                                         
                                                
  if_then_char_init CalcType .eq. TSIM  .or.    
                    CalcType .eq. MODAL         
   initval read_gpdat gp/$IDENT.gp 1            
  endif                                         
                                                

`quasi`

Order the CALC-program to perform a quasistatical analysis.
Normally this command is given via the script modal when the modal analysis is initiated, but can also be given manually if desired.

`quasi_param` = `q_method`, input(*)

Defines different parameters for the quasistatical analysis.
If command quasi_param not is given in the input data file, q_method='Damped_Tens' with it's default values will apply. Command `quasi_param` has the following subcommands:

`q_method` = `LineSearch_1`

The solution of the system's state of equilibrium according to LineSearch_1 is undertaken in a combination of two methods which work in series with each other.
Method 1 is a direct method which corresponds to an integration of equations according to Euler's method. The program integrates a number of step equations in "mstepk" in the following way: y(1) = y(0) + tstep*dy(0) where both "mstepk" and "tstep" are input parameters.
Method 2 seeks the state of equilibrium by searching in the gradient's direction. After method 1 has taken the step "mstepk", method 2 starts by linearizing the system in order to calculate the direction of the gradient. During the linearization process, every degree of freedom is disturbed by an amplitude of "linj_eps". After the linearization, the program advances in the direction of the gradient in steps which are proportional to "sfact". When the minimum point has been passed, the program makes a bottom search. If the tolerance not has been met after 5 bottom searches, the program will return to method 1 again.

                                                                        
  quasi_param LineSearch_1  tol linj_eps sfact tstep max_loop mstepk    
                                                                        

The input parameters have the following default values:

                    
  tol      = 1.e-4  
  linj_eps = 1.e-6  
  sfact    = 0.02   
  tstep    = 0.001  
  max_loop = 60     
  mstepk   = 40     

`q_method` = `LineSearch_2`

The solution of the system's state of equilibrium according to LineSearch_2 is undertaken in a combination of three methods which work in series with each other.
Method 0 is a simple method which only roughly positions all degrees of freedom in the model, then method LineSearch_1 takes over for making fine adjustments of the positions of the model.
Method 1 is a direct method which corresponds to an integration of equations according to Euler's method. The program integrates a number of step equations in "mstepk" in the following way: y(1) = y(0) + tstep*dy(0) where both "mstepk" and "tstep" are input parameters.
Method 2 seeks the state of equilibrium by searching in the gradient's direction. After method 1 has taken the step "mstepk", method 2 starts by linearizing the system in order to calculate the direction of the gradient. During the linearization process, every degree of freedom is disturbed by an amplitude of "linj_eps". After the linearization, the program advances in the direction of the gradient in steps which are proportional to "sfact". When the minimum point has been passed, the program makes a bottom search. If the tolerance not has been met after 5 bottom searches, the program will return to method 1 again.

During the solution phase, the program CALC makes a continuous print out of the input data model's status on standard output, so that the user can follow the solution process. The print text contains the following information:

Line 1: the first 12 letters of the degree of freedom's name
Line 2: the last 12 letters of the degree of freedom's name
Line 3: position of the degree of freedom
Line 4: velocity of the degree of freedom
Line 5: acceleration of the degree of freedom

                                                                        
  quasi_param LineSearch_2  tol linj_eps sfact tstep max_loop mstepk    
                                                                        

The input parameters have the following default values:

                     
  tol      = 1.e-4   
  linj_eps = 1.e-6   
  sfact    = 0.02    
  tstep    = 0.001   
  max_loop = 60      
  mstepk   = 40      
                     

`q_method` = `LineSearch_3`

The solution of the system's state of equilibrium according to LineSearch_3 is undertaken in a combination of two methods which work in series with each other.
Method 1 is a direct method which corresponds to an integration of equations according to implicit Euler's method. The program integrates a number of step equations in "mstepk" in the following way: y(1) = y(0) + tstep*dy(0) where both "mstepk" and "tstep" are input parameters.
Method 2 seeks the state of equilibrium by searching in the gradient's direction. After method 1 has taken the step "mstepk", method 2 starts by linearizing the system in order to calculate the direction of the gradient. During the linearization process, every degree of freedom is disturbed by an amplitude of "linj_eps". After the linearization, the program advances in the direction of the gradient in steps which are proportional to "sfact". When the minimum point has been passed, the program makes a bottom search. If the tolerance not has been met after 5 bottom searches, the program will return to method 1 again.

                                                                        
  quasi_param LineSearch_3  tol linj_eps sfact tstep max_loop mstepk    
                                                                        

The input parameters have the following default values:

                     
  tol      = 1.e-4   
  linj_eps = 1.e-6   
  sfact    = 0.001   
  tstep    = 0.0001  
  max_loop =  50     
  mstepk   = 500     
                     

`q_method` = `m_NewRaph_1`

Solves the state of equilibrium with a modified Newton-Raphson method. The modified method includes a damping term, in order to increase the stability during the solution process.

                                                                        
    The Newton-Raphson method           The damping term                
                                                                        
                                           (afact   +sfact)             
  x(n+1) = x(n) - inv(J) * f(x(n)) * min ( ----------------  , 1.)      
                                           (error_dy+sfact)             
                                                                        

The Jacobian J is calculated by linearizing the system of equations. Afact and sfact are constants which are defined as input parameters to the quasi_param-command. Error_dy is the error in the derivative of the system equations in every iteration. The damping term entails that when error_dy is big, the iteration will take small steps towards the expected minimum point. When error_dy is smaller than afact, the iteration is carried out at full amplitude.

                                                                
  quasi_param m_NewRaph_1  tol linj_eps sfact afact max_loop    
                                                                

The input parameters have the following default values:

                     
  tol      = 1.e-4   
  linj_eps = 1.e-6   
  sfact    = 0.02    
  tstep    = 0.001   
  max_loop = 60      
                     

`q_method` = `m_NewRaph_2`

Solves the state of equilibrium with a modified Newton-Raphson method. In this method external loads are applied in several small steps, in order to ensure finding the right solution even to extremely non-linear problems. Even this method contains a damping term to increase stability during the solution process. The damping term has the same appearance as in the method `m_NewRaph_1`.

                                                                        
    The Newton-Raphson method           The damping term                
                                                                        
                                           (afact   +sfact)             
  x(n+1) = x(n) - inv(J) * f(x(n)) * min ( ----------------  , 1.)      
                                           (error_dy+sfact)             
                                                                        

The Jacobian J is calculated by linearizing the system of equations. Afact and sfact are constants which are defined as input parameters to the quasi_param-command. Error_dy is the error in the derivative of the system equations in every iteration. The damping term entails that when error_dy is big, the iteration will take small steps towards the expected minimum point. When error_dy is smaller than afact, the iteration is carried out at full amplitude.

                                                                        
  quasi_param m_NewRaph_2  nsteg tol linj_eps sfact afact max_loop      
                                                                        

The input parameters have the following default values:

                     
  nsteg    = 10      
  tol      = 1.e-4   
  linj_eps = 1.e-6   
  sfact    = 0.02    
  tstep    = 0.001   
  max_loop = 60      
                     

`q_method` = `Damped_Tens`

Solves the state of equilibrium with a tensor based method in combination with a time simulation. In the simulation phase, external damping is added to the system in order to quickly adopt the quasistatical solution.
Input data:

                                                    
  quasi_param Damped_Tens  tol fact max_loop tsim1  
                                                    

The input parameters have the following default values:

                     
  tol      = 1.e-4   
  fact     = 0.1     
  max_loop =  20     
  tsim1    =  2.     
                     

`s_var` = 's_type`, input(*)

Definition of variables to be stored for post-processing.
Command `s_var` has the following subcommands:

s_type = `force_on`

Store all forces acting on specified mass in specified direction.
This command can be used for debugging, if a mass is vibrating or moving in a unexpected way. By using the force_on-command it is quick and easy to store all forces connected to the vibrating mass, for later plotting in MPLOT. Comparing the frequencies of the forces and the motion of the mass, it is easy to find the force that is causing the vibration. The names of the forces stored by this command is written to standard output.

                               
  s_var force_on  m_name dire  
                               

s_type = `gpdat_force1`

Orders program TSIM to write the coupling forces to the GPdat-file.
In post processor GPLOT the forces will be animated together with the model. The forces are written every N*tout (where N is an arbitrary integer).

                          
  s_var gpdat_force1  var 
                          

s_type = `gpdat_r1`

Orders program TSIM and MODAL to write the motions of all masses to the GPdat-file.
These motions can be read into the post processor GPLOT for animation. The motions of all masses are written every N*tout (where N is an arbitrary integer).

                   
  s_var gpdat_r1   
                   

s_type = `gpdat_wheel_info`

Orders program TSIM to write wheel data information to the GPdat-file.
In post processor GPLOT the user has access to a plot mode Show 4 diags which shows a close-up view of the wheel profiles including the shape of the profiles, track forces, creep and contact forces, creepage and size of the contact ellipse. The wheel information will be animated together with the model. The forces are written every N*tout (where N is an arbitrary integer).

                                                           
  s_var gpdat_wheel_info  wheel_name lsys.b w_prof         
                                                           

s_type = `gpdat_rail_info_right` and `gpdat_rail_info_left`

Orders program TSIM to write rail data information to the GPdat-file.
In post processor GPLOT the user has access to a plot mode Show 4 diags which shows a close-up view of the rail profiles including the shape of the profiles, track forces, creep and contact forces, creepage and size of the contact ellipse. The rail information will be animated together with the model. The forces are written every N*tout (where N is an arbitrary integer).

                                                      
  s_var gpdat_rail_info_right  X_coord_r1  r_prof_r1  
                               X_coord_r2  r_prof_r2  
                               X_coord_r3  r_prof_r3  
                               X_coord_r4  ,,,etc.    
                                                      
  s_var gpdat_rail_info_left   X_coord_l1  r_prof_l1  
                               X_coord_l2  r_prof_l2  
                               X_coord_l3  r_prof_l3  
                               X_coord_l4  ,,,etc.    
                                                      

s_type = `scalar_0`

Orders program TSIM and QUASI to write a variable's value at time=0 as a scalar on the MPdat-file.
These scalars can be read into the post processors MPLOT, MTABLE, CATAS or CATAF for post processing and plotting.

                           
  s_var scalar_0  s_name   
                           

s_type = `sngl`

Orders program TSIM and FRESP to store a variable as a vector on the MPdat-file.
These vectors can be read into the post processors MPLOT, MTABLE, CATAS or CATAF for post processing and plotting. The variables are written every N*tout (where N is an arbitrary integer).

                        
  s_var sngl  s_name    
                        

s_type = `var_0`

Store a variable both as a vector and a scalar in the MPdat-file.
These vectors and scalars can be read into the post processors MPLOT, MTABLE, CATAS or CATAF for post processing and plotting. The variables are written every N*tout (where N is an arbitrary integer). In apart from the commands s_var sngl and s_var scalar_0 above, no error message will appear if the variable is missing.

                        
  s_var var_0 s_name    
                        

`tout`

Specifies the output steps to the MPdat-file in time integration analysis.
Tout is also stored in the main memory as a variable, which makes it possible to redefine its value in a func-command. If tout not is defined, the default value tout= 0.010 will apply.

`tsim`

Order the CALC-program to perform a time integration analysis.
Normally this command is given via the script modal when the modal analysis is initiated, but can also be given manually if desired.

`tsim_param`= `i_name`, input(*)

Defines the integrator to be used in time integration analysis.
Command `tsim_param` has the following subcommands:

                  
 tsim_param= e1   
                  

Selects an integrator which works according to Euler's explicit method. Euler's method is a one-step method with fixed step, giving an integration error of O(h). Additional input data is not available, as the time step is taken from the tstep-command.

As can be seen above, only one calculation of the integrand is needed for each timestep.
The values of the integrands is defined by the user in different input data commands, for example: mass m_rigid_1, mass m_rigid_6, mass m_rigid_36b, mass m_flex_1, mass massless2, func integ, func hpass*, func lpass*, coupl kc, coupl kckc, coupl kfrkc and coupl k_air3.

                  
 tsim_param= mp2  
                  

Selects an integrator which works according to the Midpoint Method, which is a one-step method with fixed step, giving an integration error of 0(h2). Additional input data is not available, as the time step is taken from the tstep-command.

As can be seen above, only one calculation of the integrand is needed for each timestep.
The values of the integrands is defined by the user in different input data commands, for example: mass m_rigid_1, mass m_rigid_6, mass m_rigid_36b, mass m_flex_1, mass massless2, func integ, func hpass*, func lpass*, coupl kc, coupl kckc, coupl kfrkc and coupl k_air3.

                          
 tsim_param= runge_kutta  
                          

Selects an integrator which works according to the Runge-Kuttas Method, which is a four-step method with fixed step, giving an integration error of 0(h4). Additional input data is not available, as the time step is taken from the special tstep-command.

As can be seen above, four calculations of the integrand is made for each timestep (one in the beginning, one in the end and two in the middle of each time interval).
The values of the integrands is defined by the user in different input data commands, for example: mass m_rigid_1, mass m_rigid_6, mass m_rigid_36b, mass m_flex_1, mass massless2, func integ, func hpass*, func lpass*, coupl kc, coupl kckc, coupl kfrkc and coupl k_air3.

                    
 tsim_param= heun   
                    

Selects an integrator which works according to the Heun's method, which is a two-step method with fixed step, giving an integration error of 0(h2). Additional input data is not available, as the time step is taken from the special tstep-command.

As can be seen above, two calculations of the integrand is made for each timestep (in the beginning and in the end of each time interval).
The values of the integrands is defined by the user in different input data commands, for example: mass m_rigid_1, mass m_rigid_6, mass m_rigid_36b, mass m_flex_1, mass massless2, func integ, func hpass*, func lpass*, coupl kc, coupl kckc, coupl kfrkc and coupl k_air3.

                                                            
 tsim_param= heun_u, regl, (+-`)max_tstep, (+-`)min_tstep   
                                                            

Selects an integrator which works according to a modified Heun's method. The integrator has variable steps, and the length of the step is calculated based on how fast the error increases or decreases between two consecutive time steps. The absolute error value is not calculated at every individual time step, but the sensitivity of the step selection can be controlled with the help of the regulation variable regl. Practical tests have shown that regl= 0.2-0.8 provides a suitable size for integration steps, regl= 0.4 can be given as a recommended value. The integration method heun_u has a variable called fstep which contains the average step length for calculation. There is no average step length calculated in the initial phase of the time integration, which is why the program uses the value of tstep read from the input data file. The user has the possibility, with the help of max_tstep and min_tstep, to control heun_u so that too large or too small time steps are not chosen. If max_tstep and min_tstep not are defined, the default values max_tstep = 1. and min_tstep = 1.e-7 will apply. The input data argument max_tstep is applicable in those cases where the excitation level is very low, e.g. on tangent track without any track irregularities. I these cases the regulator in heun_u have no motions from where it can regulate the size of the time step. When simulating a railway vehicle, max_tstep= 0.002 and min_tstep= 1e-7 should be a suitable choice.

Method heun_u creates a variable with the name IntegratorDebug, which contains the number of the equation which controls the size of the time step.

For more details about the Heun's method please look at heun.

                                                            
 tsim_param= heun_b, regl, (+-`)max_tstep, (+-`)min_tstep   
                                                            

Similar to heun_u but redo the time step if the tolerance not is meet. Default values for regl, max_tstep and min_tstep are 0.2, 0.0015 and 1e-9 respectively.

For more details about the Heun's method please look at heun_u.

                          
 tsim_param= dopri5, tol  
                          

Multistep explicit runge-kutta according to DORMAND & PRINCE. The source code to DOPRI5 is described in the book "SOLVING ORDINARY DIFFERENTIAL EQUATIONS I. NONSTIFF PROBLEMS", 2ND EDITION. SPRINGER SERIES IN COMPUTATIONAL MATHEMATICS, SPRINGER-VERLAG (1993), written by E. HAIRER, S.P. NORSETT and G. WANNER. A typical value for the tolerance can be 1.e-10.

                          
 tsim_param= odassl, tol  
                          

Implicit DAE-solver by Claus Fuhrer at Numerical Analysis, Lund University, based on the DASSL routine written by Linda Petzold, MIT. A typical value for the tolerance can be 1.e-5.

`tstart`

Specifies the start time in time integration analysis.

`tstep`

Specifies the size of the time step in time integration analysis.
Tstep is also stored in the main memory as a variable, which makes it possible to redefine its value in a func-command. If tstep not is defined, the default value tstep= 0.001 will apply.

`tstop`

Specifies the stop time in time integration analysis.
Tstop is also stored in the main memory as a variable, which makes it possible to redefine its value in a func-command. If tstop not is defined, the default value tstop= 0. will apply.

`wlog_beg`

Specifies start of input data which is to be logged on a log file.
All the input data commands which are given between the command wlog_beg and wlog_end will be printed out on the log file. The log file can have different extensions depending on which type of analysis is executed. Time simulation gives the extension *.tlog, frequency response analysis gives the extension *.flog, modal analysis gives the extension *.mlog and quasistatical analysis gives the extension *.qlog.

`wlog_end`

Ends the writing into a log file beginning with command wlog_beg

`wlog_store`

Specifies whether the log file will be saved or not. Wlog_store can be given the value 0 or 1. If wlog_store is set at 0, the log file will not be stored. If wlog_store is set at 1, the log file will be stored. See also command wlog_beg.
Default value for wlog_store is 1 i.e. a log file will be created.

`write_ca_file`

When command write_ca_file has been given in input data, the results are continuously written to the harddisk during the time simulation phase. This however makes the processing time longer, but it has the advantage that it is possible to restore the results if the time simulation terminates abnormally.

If command write_ca_file has been given and the simulation has terminated abnormally, the user has now the possibility to restore the results if the command conv_ca *.ca is given in the genfile- or xterm- window.

`write_id_file`

During time-domain simulations, split up the results in many id-files.
When making very long simulations it can be unpractical with very big id-files, therefore this command has been introduced. The write_id_file -command writes several id-files during a simulation. Between the ident-string and the extension ".id", command write_id_file adds an underscore plus a serial number, in order to give a uniq name to each id-file.

                            
  write_id_file No_tout     
                            

Examples.

This chapter presents a number of examples to illustrate how the program is used, and what it can be used for.

This chapter contains the following examples:

Example 1)

Create a simple sinus-variable

Example 2)

A one-dimensional mass coupled to ground via a spring

Example 3)

Model of a pendulum.

Example 4)

A mass with 6 degrees of freedom following a moving coordinate system

                                                                                         
   head 1 Generation of a sinusoidal function                                            
   head 2 with the frequency $frequency Hz.                                              
 #                                                                                       
   tsim_param= e1                        #Select integrator e1                           
   tstart= 0.  tstop= 4                  #Select start and stop times.                   
   tout= 0.04  tstep= 0.04               #Select printing and integration steps          
 #                                                                                       
   func const frequency= 2               # Define a variable named frequency for example 
   func operp sinarg=                    # Calculate the variable sinarg                 
    2 * 3.14159 * frequency * time                                                       
   func sin   sin2 sinarg                # Calculate sinus for sinarg                    
 #                                                                                       
   s_var sngl sin2                       # Order storage of variable sin2                
                                                                                         

                                                                                         
   head 1 A mass of 2(kg) connected to point with a spring of 50(N/m)                    
   head 2 Point is sinusoidally excited with a frequency of .5(Hz)                       
   head 3 The amplitude of the is increased from 0(mm) to 10(mm) in 3(s)                 
 #                                                                                       
 #                                                                                       
   tsim_param= heun_u 0.5       #Select integrator heun_u                                
   tstart= 0.  tstop= 16.       #Select start and stop times                             
   tout= 0.020 tstep= 0.001     #Select printing and initial integration step            
 #                                                                                       
 #                                                                                       
 # Create the esys and lsys coordinate systems.                                          
 #                                                                                       
 # lsys   type      name           coordinates                                           
   lsys   e_fix     esys          0. 0. 0.  0. 0. 0.                                     
   lsys   l_local   lsys   esys   0. 0. 0.                                               
 #                                                                                       
 #                                                                                       
 # Remove the gravity of earth.                                                          
 #                                                                                       
   accel  local_all  0. 0. 0.                                                            
 #                                                                                       
 #                                                                                       
 # Create a mass and a point to fasten the mass in.                                      
 #                                                                                       
 # mass   m_type      m_name   lsys   center of gravity  mass matrix' diagonal           
   mass   m_rigid_6   mass     lsys      0.  0.  0.       2 2 2  2 2 2                   
   mass   fixpoint_6  point    lsys      0.  0.  0.                                      
 #                                                                                       
 # # Create a spring between mass and point.                                             
 #                                                                                       
 # coupl  c_type    c_name  coupl    attachm.point  stiffness                            
   coupl  k_lin     kyy     point y  0.  0.  0.                                          
                            mass  y  0.  0.  0.     50                                   
 #                                                                                       
 #                                                                                       
 # Create excitation variable 1(Hz) with amplitude, which will increase to 10(mm)        
 #                                                                                       
   func mul timepi time   6.28318531                                                     
   func mul sinarg timepi .5                       #Frequency .5(Hz)                     
   func sin sinus  sinarg                                                                
 #                                                                                       
   func intpl_l  ampl  time 0 0  3 .010  50 .010   #Amplitude                            
 #                                                                                       
 #                                                                                       
 # Assign body point the sinus shaped motion in y-direction.                             
 #                                                                                       
   func mul  point.y  ampl sinus                                                         
 #                                                                                       
 #                                                                                       
 # Store variables for postprocessing                                                    
 #                                                                                       
   s_var sngl point.y                                                                    
   s_var sngl massa.y                                                                    
                                                                                         

                                                                                     
   head 1 A body of 2(kg), excited by acceleration due to gravity                    
   head 2 Coupled to point by a spring of 50e3[N/m] and the length 1[m]              
   head 3 At start the mass is extended 1[m] in the x-direction                      
 #                                                                                   
 #                                                                                   
   tsim_param= e1             #Select integrator                                     
   tstart= 0.  tstop= 3.      #Select start and stop.                                
   tout= 0.020 tstep= 0.001   #Select printing steps and integration start steps     
 #                                                                                   
 #                                                                                   
 # Create esys and lsys coordinate systems.                                          
 #                                                                                   
 # lsys   type      name           coordinate                                        
   lsys   e_fix     esys          0. 0. 0.  0. 0. 0.                                 
   lsys   l_local   lsys   esys   0. 0. 0.                                           
 #                                                                                   
 #                                                                                   
 # Create a mass and a point to attach the mass to.                                  
 #                                                                                   
 # mass   m_type       m_name   lsys   center of gravity  mass matrix' diagonal      
   mass   m_rigid_6    mass     lsys   1.  0.  0.            2 2 2  2 2 2            
   mass   fixpoint_6   point    lsys   0.  0.  0.                                    
 #                                                                                   
 #                                                                                   
 # Create spring and small damper between body and point.                            
 #                                                                                   
   coupl  p_lin  stiff   0.   10e3                                                   
   coupl  p_lin  damper  0.   10                                                     
   coupl  k      kstiff  point 0 0 0  massa 1 0 0  stiff  esys cu                    
   coupl  c      cdamper point 0 0 0  massa 1 0 0  damper esys cu                    
 #                                                                                   
 #                                                                                   
 # Store variables for postprocessing                                                
 #                                                                                   
   s_var sngl massa.x       #Motion of the mass                                      
   s_var sngl massa.y                                                                
   s_var sngl massa.z                                                                
   s_var sngl massa.f                                                                
   s_var sngl massa.k                                                                
   s_var sngl massa.p                                                                
 #                                                                                   
   s_var sngl kstiff.d      #Force and displacement in the direction of the spring   
   s_var sngl kstiff.F                                                               
 #                                                                                   
   s_var sngl kstiff.F2x    #Force from the spring acting on the mass.               
   s_var sngl kstiff.F2z                                                             
                                                                                     

                                                                                     
   head 1 A body of 2(kg), with a speed of 30(m/s), at a height of 1(m)              
   head 2 Attached to point via springs 1200(N/m) and dampers 150(Ns/m)              
   head 3 Enters a curve of 1000(m) radius and a cant of .06(rad)                    
 #                                                                                   
 #                                                                                   
   tsim_param= heun_u 0.5        #Select an integrator with variable step            
   tstart= 0.  tstop= 2.         #Select start and stop times.                       
   tout= 0.020 tstep= 0.001      #Select storing step and initial integration step   
 #                                                                                   
   func  const    speed 30     #Create a variable containing the speed.              
   func  mul dist speed time   #Create a variable containing the position.           
 #                                                                                   
 #                                                                                   
 # Create esys- and lsys- coordinate system, and vectors which control the curve.    
 #                                                                                   
   func  intpl_r   krok_R   0 0   5 0  10  .001  30  .001                            
   func  intpl_r   krok_fi  0 0   5 0  10  .060  30  .060                            
   func  intpl_r   krok_z   0 0   5 0  10 -.045  30 -.045                            
 #                                                                                   
   lsys  e_abs_bend esys0  speed  0. krok_R krok_fi krok_z                           
   lsys  l_local    lsys0  esys0     0  0  0                                         
 #                                                                                   
 #                                                                                   
 # Create a mass and a point to attach the mass to.                                  
 #                                                                                   
 # mass   m_type       m_name   lsys   center of gravity  mass matrix' diagonal      
   mass   m_rigid_6    massa    lsys0  0.  0. -1.          2 2 2  2 2 2              
   mass   fixpoint_6   point    lsys0  0.  0.  0.                                    
 #                                                                                   
 #                                                                                   
 # Create springs and dampers.                                                       
 #                                                                                   
   coupl  p_lin  stiff    0.   1200                                                  
   coupl  k      stiff.x  point 0 0 0  massa 0 0 0  stiff esys0 x                    
   coupl  k      stiff.y  point 0 0 0  massa 0 0 0  stiff esys0 y                    
   coupl  k      stiff.z  point 0 0 0  massa 0 0 0  stiff esys0 z                    
   coupl  k      stiff.f  point 0 0 0  massa 0 0 0  stiff esys0 f                    
   coupl  k      stiff.k  point 0 0 0  massa 0 0 0  stiff esys0 k                    
   coupl  k      stiff.p  point 0 0 0  massa 0 0 0  stiff esys0 p                    
   coupl  p_lin  damper   0.     50                                                  
   coupl  c      damper.x  point 0 0 0  massa 0 0 0  damper esys0 x                  
   coupl  c      damper.y  point 0 0 0  massa 0 0 0  damper esys0 y                  
   coupl  c      damper.z  point 0 0 0  massa 0 0 0  damper esys0 z                  
   coupl  c      damper.f  point 0 0 0  massa 0 0 0  damper esys0 f                  
   coupl  c      damper.k  point 0 0 0  massa 0 0 0  damper esys0 k                  
   coupl  c      damper.p  point 0 0 0  massa 0 0 0  damper esys0 p                  
 #                                                                                   
 #                                                                                   
 # Store variables for postprocessing                                                
 #                                                                                   
 #                                                                                   
   s_var sngl esys0.x    s_var sngl lsys0.x   # Motions of lsys and esys             
   s_var sngl esys0.y    s_var sngl lsys0.y                                          
   s_var sngl esys0.z    s_var sngl lsys0.z                                          
   s_var sngl esys0.f    s_var sngl lsys0.f                                          
   s_var sngl esys0.k    s_var sngl lsys0.k                                          
   s_var sngl esys0.p    s_var sngl lsys0.p                                          
   s_var sngl esys0.vx   s_var sngl lsys0.vx                                         
   s_var sngl esys0.vy   s_var sngl lsys0.vy                                         
   s_var sngl esys0.vz   s_var sngl lsys0.vz                                         
   s_var sngl esys0.vf   s_var sngl lsys0.vf                                         
   s_var sngl esys0.vk   s_var sngl lsys0.vk                                         
   s_var sngl esys0.vp   s_var sngl lsys0.vp                                         
   s_var sngl esys0.ax   s_var sngl lsys0.ax                                         
   s_var sngl esys0.ay   s_var sngl lsys0.ay                                         
   s_var sngl esys0.az   s_var sngl lsys0.az                                         
   s_var sngl esys0.af   s_var sngl lsys0.af                                         
   s_var sngl esys0.ak   s_var sngl lsys0.ak                                         
   s_var sngl esys0.ap   s_var sngl lsys0.ap                                         
 #                                                                                   
 #                                                                                   
 #            position            speed                                              
   s_var sngl massa.x  s_var sngl massa.vx   # Motions and speed of the mass         
   s_var sngl massa.y  s_var sngl massa.vy                                           
   s_var sngl massa.z  s_var sngl massa.vz                                           
   s_var sngl massa.f  s_var sngl massa.vx                                           
   s_var sngl massa.k  s_var sngl massa.vy                                           
   s_var sngl massa.p  s_var sngl massa.vz                                           
 #                                                                                   
 #  Sum of external force's acting on the mass                                       
   s_var sngl massa.Fx                                                               
   s_var sngl massa.Fy                                                               
   s_var sngl massa.Fz                                                               
   s_var sngl massa.Fx                                                               
   s_var sngl massa.Fy                                                               
   s_var sngl massa.Fz                                                               
 #                                                                                   
 #  Acceleration of inertia, due to accelerating coordinate systems                  
   s_var sngl massa.Ax                                                               
   s_var sngl massa.Ay                                                               
   s_var sngl massa.Az                                                               
   s_var sngl massa.Af                                                               
   s_var sngl massa.Ak                                                               
   s_var sngl massa.Ap                                                               
                                                                                     

Export of results

The results from a calculation is stored in two binary files in directory id id/$ident.id and id/$ident.id2. File id/$ident.id2 contains all time-steps from all variables. File id/$ident.id is a smaller file only containing the names of all variables inclusive their addresses in the dircet access file id/$ident.id2.
Results from the id-files can be exported with the following programs/scripts:

cataf	Writes all results into an ASCII-file.
catas	Writes a minor dump into an ASCII-file.
read_id_file.m	A matlab-script which reads id-files directly. Located in directory $gensys/source/download/octave/m/gensys