The parametric input capability allows you to create an
Abaqus
input file in which:
Any number of input parameters is defined by assigning a value to each
one of them.
The parameters defined in the input file are used in place of input
quantities.
The parameters are evaluated according to their definition and are
substituted for the parametrized input quantities before an analysis is run.
Parametric input allows greater flexibility in building and manipulating
models. The different kinds of parameters and the different ways of
parametrizing the
Abaqus
input quantities are discussed in this section.
You must define all the parameters you wish to use in an analysis by
assigning a value to them. The Python language (Lutz,
1999) is used to perform parameter evaluation and substitution; hence,
parameter definitions are required to follow the Python syntax rules discussed
later in this section. These parameters can then be used in place of input
quantities.
In this simple example models with beams
of different cross-sections can be obtained simply by changing the values of
the parameters.
Parameters
Parameters are user-named variables to which you assign values. When a
parameter is used instead of a value, the value of that parameter is
substituted. There are two basic types of parameters: independent parameters
and dependent parameters.
Independent Parameters
Independent parameters are those that do not depend on any other parameters.
The following are examples of independent parameters:
thickness = 10.0
area = 5.0**2
length = 3.0*sin(45*pi/180.0) # convert degrees to radians
Python expressions using numbers and numerical operations (such as addition,
multiplication, and exponentiation) can be used to define independent
parameters. Arithmetic support in Python is discussed later in this section.
Dependent Parameters
Dependent parameters are those that depend on other parameters (dependent or
independent). Dependent parameters can be defined in one of two ways: using a
mathematical expression or using a tabular dependence.
Expressional Dependence
Python parametric expressions involving operations between numbers and
parameters are used to define expressionally dependent parameters. In the
following example area and
mom_inertia are dependent parameters:
Tabular dependence between parameters is defined by specifying the
dependent and independent parameters as well as a dependence table. The table
that defines the dependence between the parameters must have as many values per
line as the number of dependent parameters plus the number of independent
parameters for which it is going to be used. The table must contain only real
values; dependent parameter values are given first, followed by independent
parameter values. Parameter names and character strings cannot be used in a
table.
The evaluation of tabularly dependent parameters by interpolation between
values in a table will result in these parameters being assigned real values.
If it is necessary that the tabularly dependent parameters be integer numbers,
the real numbers must be converted to integer numbers as described later in the
Python language section.
When the tabularly dependent parameters are functions of only one
independent parameter, the tabular data must be given in order of increasing
values of the independent parameter.
Abaqus
then interpolates linearly for values between those given. The dependent
parameters are assumed to be constant outside the range of the independent
parameters used in a table. When the tabularly dependent parameters depend on
several independent parameters, the variation of the dependent parameters with
respect to the first independent parameter must be given at fixed values of the
other independent parameters, in ascending values of the second independent
parameter, then of the third independent parameter, and so on. The table lines
must always be ordered so that the independent parameters are given increasing
values. This process ensures that the value of each dependent parameter is
completely and uniquely defined for all values of the independent parameters.
The fact that the definition of the dependence table is separate from the
assignment of the dependence to particular parameters means that the same table
can be used for multiple sets of dependent/independent parameters. This is
useful when there are different instances of the same kind of input data; for
example, multiple material definitions that use the same dependence but
different sets of parameters.
Because the evaluation of parameters is procedural (see
Parameter Evaluation
below), a parameter dependence table must always be defined before it is used
to specify tabular parameter dependencies.
Independent parameters in tabular dependence definitions are treated as
independent for the purpose of defining this dependency; however, these
“independent” parameters can be defined to depend on other parameters in a
preceding parameter definition.
Input File Usage
Use the following option to define a parameter dependence
table:
is flagged as an error because y cannot
be evaluated by ordered execution of the input. In other words, there is no
deferred execution of the parameter definitions.
It is possible to define parameters anywhere in the input file, even after
parameters have been used in place of input quantities, since the parameter
definitions are always processed before any other input options are processed.
Parameters can also be defined and used in place of input quantities in an
input file used for a restart analysis. However, parameters defined in the
input file for the original analysis (from which the restart run is continued)
are not available in the restart analysis.
Parameter Substitution
When the parameterized data are processed,
Abaqus
assigns the parameter values as determined at the end of parameter evaluation.
An error is reported if a parameter used in place of input quantities has not
been assigned a value. Later, the
analysis input file processor
performs its usual checks on the validity of the parameter values with respect
to the options in which they are being used.
Data given to define a parameter, a parameter dependence table, or a
parameter shape variation cannot be parameterized. For example, the input
is not valid; however, the
analysis input file processor
will not report an error for this input.
Data Types
The data type of a parameter is deduced from its definition. An integer
parameter results from assigning an integer literal value to the parameter.
Similarly, a real parameter arises from assigning a real literal value to the
parameter. Integers are promoted to reals if they are used in operations
containing reals. A character string parameter results from assigning a
character string literal value to the parameter.
The input option context in which the parameter is used dictates the data
type that the parameter must have. Parameters of real data type should be used
in place of real
Abaqus
input quantities. Parameters of integer (or character string) type should be
used in place of integer (or character string) type input quantities,
respectively. In some instances, mismatches between the input context and the
type of the substituted parameter will cause the
analysis input file processor
to flag these instances as input errors. For example, the input
will cause the
analysis input file processor
to report an error because the number of integration points specified for a
shell section must be an integer. However, the input
will be accepted by the
analysis input file processor
without a warning being flagged; as a result of doing integer division, this
input gives a shell thickness of 1 (not 1.25). In conclusion, you can rely on
the
analysis input file processor
to catch only some data type errors.
Continuous and Discrete Parameters
From the point of view of design activities (sensitivity analysis,
parametric studies, etc.) parameters can be continuous valued or discrete
valued. A continuous-valued parameter is differentiable and can, thus, be used
for design sensitivity analysis purposes. A discrete-valued parameter is not
differentiable and can, thus, not be used for design sensitivity analysis
purposes; however, it can be used for parametric studies. Examples of
continuous-valued parameters may be a shell thickness or a material property.
Examples of discrete-valued parameters may be the number of integration points
through the thickness of a shell, or an element type. Continuous-valued
parameters generally coincide with physical (design) input quantities, while
discrete-valued parameters generally coincide with finite element (numerical
approximation) input quantities.
Auxiliary Input Files
Parameters can be defined in INCLUDE input files but not in
any other auxiliary input files. If you define parameters in an
INCLUDE input file, you must also include
the PARAMETER option in the
INCLUDE input file. For information on how
the parameters are interpreted, see Execution of Parametrized Input.
Names of auxiliary input files can be parameterized, except those used in the INCLUDE option.
Parametrization of Input Quantities
Abaqus
treats parametrization of “size” and “shape” quantities somewhat differently.
Parametrization of shape input quantities is discussed in a separate section
(see
Parametric Shape Variation).
Size input quantities are understood to include all
Abaqus
input quantities except those that relate to shape. Size input quantities
include section properties, material properties, orientation properties,
prescribed conditions, interaction definitions and properties, and analysis
procedure data.
Parametrizing Individual Input Quantities
The following example shows the parametrization of shell section input using
three independent parameters of differing data types:
Parametrizing Groups of Input Quantities (Expressional Dependence)
The following example shows the parametrization of a three-layer composite
shell section using expressional-dependent parameters. In this example the
thickness parameter can be used to change the
thickness of the layers of the composite section uniformly.
PARAMETER
thickness = 10.
layer1_thick = 0.15*thickness
layer2_thick = 0.6*thickness
layer3_thick = 0.25*thickness
SHELL SECTION, ELSET=, COMPOSITE
<layer1_thick>,num int pts, material name, orientation
<layer2_thick>,num int pts, material name, orientation
<layer3_thick>,num int pts, material name, orientation
This parametrization requires that dependent parameters be created for the
three input quantities (layer1_thick,
layer2_thick,
layer3_thick) that each depend on the
independent parameter (thickness).
Parametrizing Groups of Input Quantities (Tabular Dependence)
The following example shows the parametrization of the section properties of
a box beam. The height and wall thicknesses of the beam section are parameters
that depend tabularly on the section width.
The above parametrization creates dependent parameters
(b, t1,
t2, t3,
t4) that each depend on the independent
parameter (a). Usage of tabular dependence
allows the definition of the dependencies of input quantities on parameters to
be confined to the parameter definitions; i.e., separate from the options where
parametrization of input quantities is done. An advantage of this method of
parametrization is that the same parameter dependence table can be used for
different parameters in different input options. For example, you may wish to
use beams of different cross-section dimensions in different parts of the
structure being modeled. The parameter dependence table can be reused with new
dependent (bb,
tt1, tt2,
tt3, tt4) and
independent (aa) parameters.
In options where predefined field variable dependence is supported, this
method of parametrization provides a clear separation between predefined field
variable dependence and parameter dependence; therefore, field variable and
parameter dependence can never be confused. Consider, for example, the case of
perfect plasticity properties for a metal where the yield stress depends on a
field variable and is also parametrized to depend tabularly on the carbon
content of the metal alloy.
PARAMETER
carbon = 0.01
PARAMETER DEPENDENCE, TABLE=yield_data, NUMBER=4ys_fv1 val 1, ys_fv2 val 1, ys_fv3 val 1, carbon val 1ys_fv1 val 2, ys_fv2 val 2, ys_fv3 val 2, carbon val 2ys_fv1 val 3, ys_fv2 val 3, ys_fv3 val 3, carbon val 3ys_fv1 val 4, ys_fv2 val 4, ys_fv3 val 4, carbon val 4PARAMETER, TABLE=yield_data, DEPENDENT=(ys_fv1, ys_fv2, ys_fv3),
INDEPENDENT=(carbon)MATERIAL, NAME=alloyPLASTIC, DEPENDENCIES=1
<ys_fv1>, , , fv val 1
<ys_fv2>, , , fv val 2
<ys_fv3>, , , fv val 3
Consider, for example, the case of metal creep properties where the creep
material data are parameters that depend tabularly on the carbon content of the
metal alloy. In addition, one of the creep parameters,
A, also depends on a predefined field variable.
PARAMETER
carbon = 0.01
PARAMETER DEPENDENCE, TABLE=creepdata, NUMBER=6A_fv1 val 1, A_fv2 val 1, A_fv3 val 1, n val 1, m val 1, carbon val 1A_fv1 val 2, A_fv2 val 2, A_fv3 val 2, n val 2, m val 2, carbon val 2A_fv1 val 3, A_fv2 val 3, A_fv3 val 3, n val 3, m val 3, carbon val 3A_fv1 val 4, A_fv2 val 4, A_fv3 val 4, n val 4, m val 4, carbon val 4PARAMETER, TABLE=creepdata, DEPENDENT=(A_fv1, A_fv2, A_fv3,
n, m), INDEPENDENT=(carbon)MATERIAL, NAME=alloyCREEP, DEPENDENCIES=1
<A_fv1>, <n>, <m>, , fv val 1
<A_fv2>, <n>, <m>, , fv val 2
<A_fv3>, <n>, <m>, , fv val 3
This example shows that any combination of dependencies on predefined field
variables and/or dependent parameters can be defined.
Python Language
Parameter statements in parameter definitions are required to follow the
syntax and semantics of the Python language (note that the parameter dependence
table and parameter shape variation definitions follow the usual
Abaqus
input syntax rules). The subset of the Python language that is endorsed is
documented here.
Statement Length and Continuation Lines
Python statements in parameter definitions can be continued over multiple
lines by terminating each line with a backslash character (\). The
PARAMETER keyword lines can be continued onto the following line
using a trailing comma since they are treated like other
Abaqus
keyword lines.
Comments
Comments in a parameter definition start with the number character (#) and
continue to the end of the line. However, comments in a parameter dependence
table or parameter shape variation definition are indicated by the usual
Abaqus
input syntax convention (**).
Parameter Names
Parameter names must begin with a letter and can contain the underscore
character (_) and numbers. Parameter names are case sensitive.
Data Types
Data types are limited to character strings, integers, and reals.
Strings are delimited with single or double quotation marks (' ' or ” ”).
Backward single quotation marks (` `) are not permitted. Character strings
should not contain the backslash character (\).
Integers are created by assignment to integer literals (for example,
aInt = 2).
Reals are created by assignment to real literals (for example,
aReal = 1.0). Real numbers can be given with or
without an exponent. Any exponent must be preceded by
E or e. The
following line shows five acceptable ways of entering the same real number:
(allowed elsewhere in the
Abaqus
input file) is not valid in Python.
Type Conversion
If integers and reals are mixed in expressions, integers are promoted
automatically to reals. Explicit type conversion can be obtained using:
int(aReal)
aReal converted to integer type
float(anInt)
anInt converted to real type (float is the same
as real)
str(anIntOrReal)
anIntOrReal converted to character string type
'anIntOrReal'
anIntOrReal converted to character string type
Numeric Operators
Standard support for operators is provided:
− x
x negated
+ x
x unchanged
x + y
sum of x and y
x − y
difference of x and y
x * y
product of x and y
x / y
quotient of x and y
x**y
x to the power y
Functions
The following utility functions are supported:
abs(x)
absolute value of x
acos(x)
arc cosine of x (result is in radians)
asin(x)
arc sine of x (result is in radians)
atan(x)
arc tangent of x (result is in radians)
cos(x)
cosine of x (x is in radians)
log(x)
natural logarithm of x
log10(x)
base 10 logarithm of x
pow(x,y)
x to the power y (equivalent to x**y)
sin(x)
sine of x (x is in radians)
sqrt(x)
square root of x
tan(x)
tangent of x (x is in radians)
Character String Operators
'abc' + 'def'
concatenation of character string 'abc' and character string 'def'
Execution of Parametrized Input
Jobs with parametrized input files are submitted to
Abaqus
in the usual way; for example,
abaqusjob=job-nameinput=input-file
where it is assumed that an input file named
input-file.inp exists.
Abaqus searches input-file.inp and any INCLUDE input files for parameter,
parameter dependence table, and parameter shape variation (Parametric Shape Variation) definitions, as well as parameter names inside <
> that may have been used in place of input quantities. You can define parameters in both
the input-file.inp and INCLUDE input files. You must
include the PARAMETER option in any file where
you define parameters. If any of the above are found, Abaqus interprets the parametrized input file and performs the tasks of parameter evaluation and
substitution.
As a result, a modified input file that is free of parameter and parameter dependence table
definitions and <parameter> instances is produced. This
file is named job-name.pes and is
subsequently submitted for execution of an analysis. The execution procedure of a
parametrized input file, except for the additional processing of parameter shape variation
definitions in the analysis input file processor, does not differ from that of a nonparametrized input file. All the files generated by
the parametrized input job are named job-name with the
appropriate extension appended to it.
Parameter Check Jobs
You can specify an execution mode in which only parameter processing
(evaluation and substitution) is carried out. The parameter check execution
mode is mutually exclusive of other execution modes, such as complete analysis,
data check, continuation of a data check, conversion of results, or recovery
(see
Abaqus/Standard and Abaqus/Explicit Execution).
A parameter check run is useful in situations where you have defined complex
parametrization in the input. In these cases you may want to study the results
of parameter evaluation and substitution before proceeding further.
A parameter check run does not permit continuation of the execution in a
subsequent run; the job must be rerun from the beginning.
Input File Usage
Enter the following input on the command line:
abaqusjob=job-nameinput=input-fileparametercheck
Display of Parametric Input
Display of the results of parameter evaluation and substitution in the data
file is described in this section. Visualization of parameter shape variations
is described in
Parametric Shape Variation.
Data File Display
The data (.dat) file contains information about the
model definition generated by the
analysis input file processor.
You can control the amount of output generated by the
analysis input file processor;
see
Controlling the Amount of analysis input file processor Information Written to the Data File
for details. In particular, you can specify whether or not the original input
(.inp) file is echoed to the data file (by default, it is
not).
In the case of parametric input this file will generally contain a number of
parameter, parameter dependence table, and parameter shape variation
definitions, as well as a number of
<parameter> instances. To verify the
definition of parametric input, you can create a modified version of the
original input file showing the parameters and their values (this file is named
job-name.par). You can also
create the job-name.pes file,
which is the modified version of the original input file that is free of
parameter and parameter dependence table definitions, as well as
<parameter> instances.
Input File Usage
Use the following option to print the contents of the
job-name.par file to the data
file: