- Akademische Forschung und Lehre
- Geräte des KIT
- Mitarbeiter des KIT
- siehe Lizenzbedingungen
-
ABAQUS
-
ABAQUS is a finite element program for solving structural mechanics and thermal problems with special application focus.
- Contact Person:
- Services:
- Links:ABAQUS Homepage
*** Information: new license server scclic7.scc.kit.edu ***
ABAQUS is a finite element program for solving structural mechanics problems with special application focus on
- forming technology
- large displacements and rotations
- large strains
- buckling
- fracture mechanics
- contact problems
- coupled heat and stress analyses
- Acoustics
- ABAQUS/Standard ABAQUS/Explicit Cosimulation
- Coupled Euler-Lagrange (CEL) calculations
- and much more.
ABAQUS is organized in different modules:
- ABAQUS/Standard solves many problems from structural mechanics and thermal problems.
- ABAQUS/Explicit solves short-time dynamic processes or problems with large deformations
- ABAQUS/CAE is the interactive pre/post processor
- ABAQUS/Viewer is the interactive postprocessor
- ABAQUS/Design allows to parameterize the ABAQUS input file and also to perform parameter studies
ABAQUS is available for many operating systems and is installed centrally at SCC on the Linux cluster bwUniCluster.
There are interfaces to the pre and post processors HyperWorks and EnSight. ABAQUS can be downloaded from the FTP serverftp://ftp.scc.kit.edu/pub/campus/ABAQUS/ (or http://ftp.scc.kit.edu/pub/campus/ABAQUS/). Here you can also find a README file with a short installation guide.
Students receive a free ABAQUS student version including tutorials and documentation for the "Introduction to ABAQUS" at https://edu.3ds.com/en/get-software. The use of the ABAQUS student version is KIT network independent.
INTEL C++ and Fortran compilers are available at SCC. These can be downloaded from the FTP server ftp://ftp.scc.kit.edu/pub/campus/Intel(or http://ftp.scc.kit.edu/pub/campus/INTEL). With these compilers user subroutines can be integrated into ABAQUS. With the installation under Windows however a somewhat larger expenditure is necessary. Here first the version of Microsoft Visual Studio specified by ABAQUS must be installed (for more information see System Requirements from the installation files of ABAQUS). A description of the installation can be found on the FTP server in the file Intel_Compiler_Windows_Anleitung.pdf.
The SCC has extended the Abaqus licenses to SIMULIA Extended Token licenses. This allows the use of the SIMULIA products Isight, Tosca and fe-safe independently of ABAQUS. For further information, please contact the responsible supervisor.
Important!
For your legal security, be sure to read the terms of use.
Excerpt from the ABAQUS License Agreement
The SCC has purchased an academic license from ABAQUS. This academic license permits only academic use of ABAQUS. Dassault Systemes Simulia GmbH understands by. academic use The following:
- The use of Abaqus on academic terms is reserved for institutions
that offer courses and award academic degrees (Diplom, Bachelor,
Master, etc.). - Within these institutions the use of Abaqus at academic conditions is
is limited to teaching purposes and to purposes of pure research. - The use of the academic license is allowed for non-commercial research projects without industrial participation, which are exclusively publicly funded and whose results are freely published.
- For other purposes, commercial licenses must be used.
Details can be found in the following excerpt from the ABAQUS license agreement, which defines the terms of use.
terms of use. The complete contract can be found on the FTP server
ftp://ftp.scc.kit.edu/pub/campus/ABAQUS.
4 Restrictions on Use
Each Abaqus Program may be used only by Institute's faculty, staff and enrolled students while
they are at, or by remote access to, a Designated Facility.
An Abaqus Program shall only be used at any time, (i) on uniquely identified computer
processors, and/or (ii) by no more than a maximum number of simultaneous users, and/or (iii)
on no more computer processors on a network than the maximum processing capacity
measured by the maximum number of simultaneous usage tokens, as specified in the
applicable License Supplement.
Each Abaqus Program shall be used by Institute only for Institute's internal purposes. In no
event shall Institute make all or any part of any Abaqus Program available to any third person as
part of a data services operation or otherwise.
All use of any Abaqus Program shall be under the direct supervision and control of a
Responsible Person. Institute hereby asserts that each Responsible Person is fully cognizant of
the terms and conditions of this Agreement, and has the authority to exercise such supervision
and control.
Institute shall not reverse compile, disassemble, or otherwise reverse engineer any Abaqus
Program, or allow anyone else to do so (except only to the extent that such prohibition is
contrary to applicable law), as SIMULIA offers alternatives to facilitate interoperability. Institute
agrees not to remove or destroy any proprietary markings or legends or any encrypted license
keys or similar security devices placed upon or contained within any Abaqus Program.
The Abaqus Programs are made available to Institute under this Agreement at discounted
license fees for academic purposes. Institute shall not use any Abaqus Program for a
commercial purpose or to produce calculations having commercial value, including any project
or calculation of a type performed in the normal course of a business or a professional practice
except during any period for which Institute shall pay non-discounted license fees to SIMULIA
as provided in Section 6.
Institute shall: (i) utilize its best efforts to prevent unauthorized disclosure or use of any Abaqus
Program; (ii) treat all Abaqus Programs with the same degree of care as it treats like information
of its own which it does not want to be publicly disclosed or the subject of unauthorized access
or use; and (iii) not make or permit to be made any more copies of any Abaqus Program than
are necessary for the Institute's internal use as permitted by this Agreement.
Quick guide
Contents
1. introduction
2. ABAQUS files
3. ABAQUS on the workstations
4. ABAQUS on the Linux clusters
5. pre- and postprocessing
6. ABAQUS/Explicit
7. ABAQUS/Design
8. documentation and examples
1. introduction
ABAQUS is a finite element program for the analysis of structural mechanics, thermal and acoustic problems and is particularly suitable for geometric and physical nonlinear problems. The program is under continuous development by Dassault Systemes Simulia Corp, USA.
The ABAQUS system can be outlined as follows:
Element libraries
Element library for structural mechanics:
- 2- or 3-node beam elements
- two-dimensional triangles and quadrilaterals for plane stress and strain state and for axisymmetric problems
- three-dimensional tetrahedra, cuboids and prisms
- straight and curved beams with two or three nodes and different cross sections
- tubes
- thick and thin shells
- continuous shells
- elbows
- Line Spring elements for modeling of cracked shell structures
Element library for heat conduction calculations:
- one-dimensional heat couplers
- two- and three-dimensional elements
- shells
- Element library for acoustic problems:
- one, two and three dimensional elements
element library for coupled temperature/stress problems
Element library for contact problems:
- planar, cylindrical and spherical gap elements and
- interface elements for small and large slip paths, slip line and slip surface elements
- Interface elements for coupled problems
- Elements for hydrostatic fluids
Continuum elements exist in different forms, as
- hybrid elements
- reduced integrated elements and
- incompatible elements
Special modeling options
- linear and nonlinear springs and dampers
- mass terms also beside the diagonal
- input in different coordinate systems
- linear and nonlinear constraints (also via user interface)
- combination of stiffening elements with arbitrary others
- emulation of singularity of crack tips by means of isoparametric elements
Furthermore, the modeling of special problems in pipelines and the off-shore area is possible.
Substructures
In ABAQUS substructures are possible and are managed in library files.
Material definitions
ABAQUS provides a wide range of material properties, some of which are mentioned briefly:
- Material parameters can be temperature dependent. Many parameters can also be defined as functions of field quantities.
- local material coordinate system
- Elasticity - plasticity, creep, volume increase and extended Mohr-Coulomb model
- Tensile stress or compressive stress without transmission
- Concrete
- Permeability
- Thermal conductivity, specific heat, latent heat
- Thermal conduction and radiation across interstices
- User interface for own material definitions
Analyses
- static and dynamic stress-strain analyses, linear and nonlinear
- eigenmodes, response spectra and random response
- creep and threshold analysis
- Addition and removal of elements
- Transient and steady-state heat conduction
- Buckling
- coupled temperature/displacement analysis
- coupled temperature/thermal stress analysis
- coupled acoustic/structural vibration analysis
- Mass diffusion
- Heat-current coupling
- ABAQUS/Standard ABAQUS/Explicit Co-Simulation
- Multiphysics: coupled Euler-Lagrange calculations (CEL)
- Multiphysics: fluid-structure coupling with FLUENT, ANSYS CFX, STAR-CD and others via the coupling software MpCCI
Loads
Each load can be applied linearly over the time step or according to an arbitrarily specified amplitude.
Nodal loads:
- Single forces and moments
- Displacements, rotations and accelerations
- Temperature and other field quantities
Element-related loads:
- Uniform and non-uniform volume forces, pressure distributions
- hydrostatic pressures
- centrifugal and Coriolis forces
- elastic bedding
- Consequential loads
For solution techniques and further details, please refer to the manuals.
ABAQUS consists of several modules, of which the following are licensed at the computer center:
ABAQUS/Standard solves many problems from the structural mechanics and thermal problem area.
ABAQUS/Explicit solves short-time dynamic processes or problems with large deformations
ABAQUS/CAE is the interactive pre/post processor
ABAQUS/Viewer is the interactive postprocessor
ABAQUS/Design allows to parameterize the ABAQUS input file and also to perform parameter studies
ABAQUS is installed at SCC on the Linux cluster cluster bwUniCluster. ABAQUS can also be
be run on workstations under Linux and Windows.
An ABAQUS job consists of 2 parts:
Preprocessing: The data is read in by the input file processor ABAQUS-Pre and a database is generated.
Execution: The program is executed.
If there are interfaces programmed by the user, there is a compile link part between the preprocessing and the execution.
2. ABAQUS files
Both ABAQUS/Pre and ABAQUS/Standard need a number of files. The names have the form
id.ext
where id is a user-assignable identifier and ext is a name extension assigned by ABAQUS to reflect the purpose of the file.
ABAQUS/Pre files:
.inp | input file for ABAQUS/Pre |
.com | Python script to control the ABAQUS job |
.oldres | Restart read file from a previous ABAQUS run and therefore with a different identifier |
.dat | Output file |
.res | Restart-Read-File |
.023 | ABAQUS database, generated by Pre and read by Standard (mostly temporary) |
.f | User Subroutine |
ABAQUS MAIN files:
.dat | Output file |
.res | Restart-Write-File |
.mdl | Model File |
.stt | State File |
.prt | Part File |
.fil | Output file of the *FILE command |
.odb | Output Database, for postprocessing with the ABAQUS/Viewer |
.sta | Status File |
.msg | Message File |
.023 | ABAQUS database, generated by PRE and read by Standard (mostly temporary) |
.sdb | Sparse Solver Database (mostly temporary) |
There are also a number of other scratch files, both in Pre and Standard.
In ABAQUS/Explicit there are also some other files
.abq | Status file |
.pac | Package file |
.sel | Selected Results |
The log of the ABAQUS run is written to the id.log file. Some parameters can also be set in the ABAQUS environment file by the user (see following section).
3. ABAQUS at the workstations
ABAQUS call
ABAQUS is started by the user calling the execution procedure. This searches and evaluates up to 3 environment files in which the system parameters are set. Some of the parameters can also be specified directly in the ABAQUS call. More details can be found in the following section.
The ABAQUS execution routine generates a Python script
id.com
which initiates and executes the individual steps of an ABAQUS job.
In this section, we describe the standard ABAQUS call. The call with the most important parameters is:
abaqus | job=id [analysis|datacheck|parametercheck|continue| information={environment|local|release|all}] [input=input-file] [user={source-file|object-file}] [oldjob=old-jobname] [fil={append|new}] [memory=memory-size] [cpus=number-of-cpus] [parallel={loop|tree}] [mp_mode={mpi|threads}] [interactive|background|queue=queue-name] [output_precision={single|full}] |
A complete description of the parameters can be found in the ABAQUS Analysis User's Manual chap. 3, so here are only the most important ones:
job | contains the job identification and is the first name component of the generated ABAQUS files; if the input parameter is not specified, ABAQUS expects the input in the file id.inp. |
analysis | the complete ABAQUS run is performed (default) |
datacheck | only a data check is performed |
parametercheck | a check is performed on parameterized input file |
continue | after a datacheck run was successful the ABAQUS run can be continued with continue |
information | writes information to the standard output or to the id.log file, depending on the option, if the job parameter is set |
local | local information |
release | information about the current ABAQUS release |
environment | outputs the current ABAQUS environment |
status | Information about the ABAQUS status |
input | contains the name of an input file if its name is not of the form id.inp |
user | contains the name of the file which contains the user subroutines and should be included in the ABAQUS executable |
oldjob | contains the job id of a previous ABAQUS run which is to be used here. This parameter is always required if the *RESTART, *POST OUTPUT or *POST FILE option occurs in the input file. old-jobname must be different from id. |
fil | if a restart run is performed, it must be decided whether it should append its results to an already existing old-jobname.fil file, or create a new result file. Default: fil=append. In both cases a new file id.fil will be created, where in the first case the file old-jobname.fil will be copied to id.fil and then results of the restart run will be appended. |
memory | Size of the main memory in 64-bit words (default: 33554432 equals 256 MByte) |
cpus | number of CPUs, if the job is to be calculated in parallel |
parallel |
Parallelization strategy, default: tree; s. ch. 8.1.1 in the User's Manual |
mp_mode | Parallel model: mpi (default) for message passing, threads for thread based parallelization |
interactive/background | the job is calculated in the foreground/background; default: background |
queue | if a queue manager is active and a queue named queue-name exists, the job will be placed in this queue |
output_precision | precision to be written to the output database file with the node variable; def.: single |
The log of the ABAQUS run is written to the id.log file. Some parameters can also be set in the ABAQUS environment file by the user (see following section).
Environment file
after the call of ABAQUS, up to three so called environmentfiles are searched and evaluated in the following order:
- the standard file abaqus_v6.env in the installation file system; this file is necessary and is created by the program maintainer and its content is defined.
- abaqus_v6.env in the $HOME directory of the user; this is optional and overwrites possibly entries of the standard environment file
- abaqus_v6.env in the user's working directory; this is also optional and may overwrite entries of the other two files.
Entries in the environment file are of the form
parameter = "value
A list of parameters and allowed values can be found in the ABAQUS User Manual, Vol. I, Section 3.4. The current occupation can also be obtained with
abaqus job=id information=environment
In the default environment file the following occupations are active:
memory="90 %"
scratch=os.environ['TMP']
cpus=1
The meaning is as follows:
memory | (90% of the available) memory |
scratch | directory for the scratch files |
cpus | number of processors on which the ABAQUS job should run in parallel |
4. ABAQUS on the Linux clusters
On the SCC Linux cluster bwUniCluster a modular concept is used. Before you can work with the ABAQUS product, you must first load the appropriate module. You can get all available software modules by selecting
module avail
type in the module. For example, to load the module of the current version of ABAQUS, type the following on the bwUniCluster (UC2):
module load cae/abaqus/2023
On the Linux clusters of the SCC, the execution of ABAQUS should take place under the control of a job management system that provides the computing resources for the ABAQUS job. To simplify the use of ABAQUS on these clusters, the startup script 'abqjob' was provided. The call to the solver for the bwUniCluster is thus:
abqjob |
-j id |
The meaning of the parameters related to ABAQUS is consistent with those of the other calls. There are specific parameters that refer to the computing environment:
-t CPU-Time (min) | specifies the CPU time in minutes that the job may consume |
-m Memory(MByte) | specifies the main memory area that the job is allowed to consume |
-I Selection of the iterative solver (only for ABAQUS/Standard) |
y the iterative solver is requested;it must be specified in the ABAQUS input file SOLVER=ITERATIVE must be set in the *STEP line. n the direct solver is requested (= default); |
-s text string | here further ABAQUS parameters can be entered enclosed in quotation marks (") e.g. "information=environment". |
Here is an example to run an Abaqus standard computation in parallel on two nodes with 4 processors each and 90,000 MB main memory requirements for 30 minutes:
abqjob -j test -t 30 -n 2 -p 4 -m 90000 -X n
Instead of the Abaqus startup script 'abqjob', the call of Abaqus can also be done by a self-made script. Here are two examples "abaqus_singlenode.sh" and "abaqus_multinode.sh" :
abaqus_singlenode.sh:
#!/bin/sh
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=4
#SBATCH --partition=single
#SBATCH --time=0:30:00
#SBATCH --mem=90000mb
module load cae/abaqus/2023
source abaqus.init
abaqus queue=hold job=test cpus=${JOB_ALL_CPUS}
abaqus python ./test.com
wait
abaqus_multinode.sh:
#!/bin/sh
#SBATCH --nodes=2
#SBATCH --ntasks-per-node=4
#SBATCH --partition=multiple
#SBATCH --time=0:30:00
#SBATCH --mem=90000mb
module load cae/abaqus/2023
source abaqus.init
abaqus queue=hold job=test cpus=${JOB_ALL_CPUS}
abaqus python ./test.com
wait
To submit the script to the job management system, run the following
sbatch abaqus_singlenode.sh
or
sbatch abaqus_multinode.sh
For more information about the batch system, see these links:
Batch Job Management System of the bwUniCluster.
The environment variables are set as follows:
memory="90 %"
mp_file_system=(SHARED,LOCAL)
import os
scratch=os.environ['TMP']
ABAQUS can compute in parallel, computing on processors within a node in SMP mode and across nodes in MPI mode.
The abqjob copies at the beginning a possibly existing abaqus_v6.env in the working directory into abaqus_v6.env.orig and supplements abqus_v6.env by the variable mp_hosts_list, which contains the list of the nodes. At the end the environment file is deleted again and abaqus_v6.env.orig is renamed to abaqus_v6.env.
Notes
1. the iterative solver can only be used for static, quasistatic and thermal problems. More details can be found in the ABAQUS documentation ( Analysis User's Manual).
2. the scratch directory points by default to the environment variable $TMP. Nodes "know" only their own local file systems, so they cannot access the $TMP of another node. With parallelizations uaf Multinodes one can announce however in the ABAQUS-Environmentfile that it concerns local filesystems with the Scratchfilesystem:
mp_file_system=(SHARED,LOCAL)
The first parameter in the parenthesis means that the working directory is a shared filesystem.
file system, the second parameter means that the scratch file system is a local system.
In the batch job system it can lead to the following error messages in the standard output and in the standard error file, which can be ignored:
...slurmstepd: error: couldn't chdir to `/scratch/slurm_tmpdir/job_xxx....
5. pre- and postprocessing
ABAQUS models can be generated in the simplest case by writing the input file with a text editor. This is a tedious way for complex problems, so that a more suitable tool should be used. The following alternatives are available, among others:
ABAQUS/CAE
is the proprietary preprocessor, which is exactly tailored to the requirements of ABAQUS models. The module contains the postprocessor ABAQUS/Viewer, which can also be called as a stand-alone module.
Call:
abaqus cae
HyperWorks
Likewise ABAQUS input files can be generated with the net generator HyperWorks.
ABAQUS results can be post-processed and visualized with various tools:
ABAQUS/Viewer
is the suitable postprocessor, which is also integrated in ABAQUS/CAE. Prerequisite for postprocessing with ABAQUS/Viewer is the Output Database (the .odb file), which is requested in the ABAQUS input file by *OUTPUT.
Call:
abaqus viewer
HyperWorks
is also postprocessor, which works on the basis of ABAQUS result file id.fil.
EnSight
is a program that is excellent for visualizing and animating results of FE calculations. The basis for working with EnSight and ABAQUS are the result files id.fil and id.dat.
6 ABAQUS/Explicit
For ABAQUS/Explicit the same applies as for ABAQUS/Standard, only some parameters in the call and files are added.
The Explicit module of ABAQUS is started by the procedure in the step
*DYNAMIC,EXPLICIT
as a procedure in the step, which activates the explicit time integration, or with
*ANNEAL
In addition to the files listed in the 2nd section, ABAQUS/Explicit generates some further files
(see ABAQUS Analysis User's Manual, Vol. I, Chap. 3).
.abq .pac |
These two files are generated by ABAQUS/Explicit. They are necessary if a restart file readable by ABAQUS/Standard is to be generated. |
.sel | Selected Resultsfile; in this file results are written, which are selected by the different options like *FILE OUTPUT in combination with *EL FILE, *NODE FILE and *ENERGY FILE resp. *HISTORY OUTPUT in combination with *EL HISTORY, *NODE HISTORY and *ENERGY HISTORY. The file is not compatible with the File Output of ABAQUS/ Standard. |
The Selected Resultsfile corresponds to the File Output of ABAQUS/Standard(id.fil), but is different from it, so it cannot be used for postprocessing with Patran, HyperWorks and EnSight.
Therefore, options are provided in the call procedure of ABAQUS to convert the above files to ABAQUS/Standard or ABAQUS/Post readable form.
Additional options in the call for ABAQUS are:
for interactive calls:
convert={restart|select|all}
[analysis|datacheck|continue|recover]
in batch jobs handled by the Job Management System:
[-s "{restart|select|all}"]
[-s "{analysis|datacheck|continue|recover}"]
Most of the options were explained in chapter 3, so here are only the new ones:
recover | starts a restart run based on the last possible valid step and increment. This is important if the restart file did not complete properly due to a system error. |
convert | specifies which of the above files are to be converted. If the option is set at the same time as the analysis parameter, the conversion will take place immediately after the actual ABAQUS/Explicit run has finished. |
all | corresponds to both parameters |
More information can be found in the ABAQUS Analysis User's Manual.
7. ABAQUS/Design
ABAQUS/Design allows to define in the ABAQUS input file
- define parameters, i.e. assign names to input variables
- perform parameter studies based on Python.
Parameterization
Parameters or variables are defined by the *PARAMETER option. A complete description can be found in the ABAQUS Analysis User's Manual.
A parameterized input file is executed like an ordinary input file:
abaqus job=id.inp
Then a file id.pes is generated, which corresponds to the input file, in which all parameters are replaced by the current values. This file is then read in and executed.
Parameter studies
If one wants to perform parameter studies, i.e. let one or more parameters vary and perform an ABAQUS run for each value or combination of values, a script must be generated,
- which defines the parameter space,
- that defines the parameter variation,
- which generates and executes an ABAQUS input file for each parameter or parameter combination
- which collects and outputs the results from the individual runs.
The name of the script file is of the form study.psf, and the parameter study is represented by
abaqus job=bla script=study
is started. A series of input files named id_aStudy_*.inp are then generated from the parameterized ABAQUS input file id.inp. aStudy is the name of the parmater study assigned in the script file. The * stands for a numbering which is assigned automatically depending on the type of parameter combination. The input file id.inp is referenced in the script file.
From the script file study.psf a script file study_X.psf is generated, which executes the single ABAQUS jobs. For each parameter or parameter combination a file id_aStudy_*.pse is generated from id_aStudy_*.inp, which is executed. Consequently, there may be a set of files as a result, i.e.
id_aStudy_*.dat, id_aStudy_*.fil, id_aStudy_*.log, id_aStudy_*.msg, id_aStudy_*.sta and id_aStudy_*.res.
A file study.var contains all parameter variations that are calculated. Files id_aStudy_*.pes and id_aStudy_*.pmg are also created. The result of the parameter study is in a file of the form study_nnn.psr. nnn is a letter-number combination.
It is also possible to control the parameter study interactively. This and other possibilities can be found in the User's Manual.
8. documentation, examples
The ABAQUS manuals are completely available as online documentation. By calling
abaqus doc
you have access to
ABAQUS Analysis User's Manual
ABAQUS/CAE User's Manual
ABAQUS Theory Manual
ABAQUS Verification Manual
ABAQUS Example Problems Manual
ABAQUS Benchmark Problems
ABAQUS Keywords Manual
ABAQUS Release Notes
Getting Started with ABAQUS
Getting Started with ABAQUS/Standard
Getting Started with ABAQUS/Explicit
and many more.
The examples from the Example Manuals are also available as input files. For downloading use the fetch module of ABAQUS.
abaqus fetch job=Input-File
The name of the input file obeys a convention which is explained in the introduction chapter of the Example Manuals.