Parametric Modeling

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 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.

width = 2.0
height = 5.0
area = width*height
mom_inertia = area*height**2/12.0

PARAMETER DEPENDENCE, TABLE=name, NUMBER VALUES=n
table with n values per line

PARAMETER, TABLE=name, DEPENDENT=(parList), INDEPENDENT=(parList)

Some general rules apply to all parameters used in Abaqus input files. These rules are described in the following subsections.

PARAMETER
x = 2
y = x + 3
x = 4

PARAMETER
y = x + 3
x = 4

PARAMETER SHAPE VARIATION
<x>

PARAMETER
int_pts = 5.0
SHELL SECTION
10.0, <int_pts>

PARAMETER
thick = 5/4
SHELL SECTION
<thick>,

The following example shows the parametrization of shell section input using three independent parameters of differing data types:

ELSET, ELSET=<shell_set>, GEN
1, 111, 10
PARAMETER
shell_set = 'lining'
shell_thick = 1.E2
num_int_pts = 5
SHELL SECTION, ELSET=<shell_set>, MATERIAL=name
<shell_thick>, <num_int_pts>

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).

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.

PARAMETER
a = 60.
PARAMETER DEPENDENCE, TABLE=sectprop, NUMBER VALUES=6
25.0, 1.04,  1.04, 1.04, 1.04, 50.0
50.0, 4.17,  3.13, 2.08, 2.50, 100.0
75.0, 9.38,  6.24, 3.13, 4.90, 150.0
PARAMETER, TABLE=sectprop, DEPENDENT=(b, t1, t2, t3, t4),
INDEPENDENT=(a)
BEAM SECTION, SECTION=BOX, ELSET=beams, MATERIAL=steel
<a>, <b>, <t1>, <t2>, <t3>, <t4>

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.

PARAMETER
aa = 65.
PARAMETER, TABLE=sectprop, DEPENDENT=(bb, tt1, tt2, tt3, tt4),
INDEPENDENT=(aa)
BEAM SECTION, SECTION=BOX, ELSET=columns, MATERIAL=steel
<aa>, <bb>, <tt1>, <tt2>, <tt3>, <tt4>

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=4 
ys_fv1 val 1, ys_fv2 val 1, ys_fv3 val 1, carbon val 1 
ys_fv1 val 2, ys_fv2 val 2, ys_fv3 val 2, carbon val 2 
ys_fv1 val 3, ys_fv2 val 3, ys_fv3 val 3, carbon val 3 
ys_fv1 val 4, ys_fv2 val 4, ys_fv3 val 4, carbon val 4 
PARAMETER, TABLE=yield_data, DEPENDENT=(ys_fv1, ys_fv2, ys_fv3),
INDEPENDENT=(carbon) 
MATERIAL, NAME=alloy 
PLASTIC, 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=6
A_fv1 val 1, A_fv2 val 1, A_fv3 val 1, n val 1, m val 1, carbon val 1
A_fv1 val 2, A_fv2 val 2, A_fv3 val 2, n val 2, m val 2, carbon val 2
A_fv1 val 3, A_fv2 val 3, A_fv3 val 3, n val 3, m val 3, carbon val 3
A_fv1 val 4, A_fv2 val 4, A_fv3 val 4, n val 4, m val 4, carbon val 4
PARAMETER, TABLE=creepdata, DEPENDENT=(A_fv1, A_fv2, A_fv3,
n, m), INDEPENDENT=(carbon) 
MATERIAL, NAME=alloy 
CREEP, 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 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 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 must begin with a letter and can contain the underscore character (_) and numbers. Parameter names are case sensitive.

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:

-12.345, -1234.5E-2, -0.12345E+2, -0.12345E2, -0.12345e2

The syntax

-0.12345D+2

(allowed elsewhere in the Abaqus input file) is not valid in Python.

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

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

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)

'abc' + 'def'

concatenation of character string 'abc' and character string 'def'

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.

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.

PREPRINT, PARVALUES=YES

PREPRINT, PARSUBSTITUTION=YES