IRIS user manual

Table of Contents

IRIS is a general purpose program developed with the purpose of providing a flexible, easy to understand, and extensible framework for research in Computational Solid, Fluid, and Structural Mechanics.

The motivation for writing this code was, and still is, to provide a tool to learn and work with the finite element method — and similar methods — allowing researchers to develop specific parts of the method without the need to modify the rest of it. In this way, someone could develop a new equation solver, other a new material model, yet another some type of error estimator, and all of them find that their code will still work together at the end. At this moment, this goal has not been fully attained but special effort has been put in maintaining the structure of the code and the interfaces of the different modules as clear as possible.

The main parts of the code were written in a couple of years of part time dedication. In the last years, the program has been enhanced to include several types of elements, of solvers, of matrix formats, etc. Still, cleaning and documenting is in progress. It is a formidable tasks and both time and people resources are scarce.

The philosophy of the code has always been to favor clarity over speed, yet to render a final code that is fast enough to deal with moderately large problems (in the order of tens of thousands of equations). To achieve this goal the most time consuming part of the solution in large problems — solving large systems of linear equations — employs “high performance” libraries programmed by somebody else, and taken from the internet. The same principle applies to other CPU intensive linear algebra computations (eigenvalue computation, preconditioning, etc). In this way, IRIS developers can concentrate in writing, and maintaining, the tasks more directly related to the finite element method.

The program has been written with the programmer, as well as the user, in mind. Hence, many tools are available for debugging and testing the code as it is written. In particular, problems can be run in “interactive” mode, where the programmer can request specific information from the code at run time.

IRIS started as a pure C code but it grew up to a point where data structures were becoming so complex that it was becoming difficult to understand, which clearly invalidated the original goals. In 2005, the code started to have C structures which contained pointers to functions whose arguments were pointers to structures and pointers to functions too. At this moment, it became clear that the programming language was not suitable for the things that the code wanted to accomplish. And so the code was re-written in C++. Again this major transformation took more than two years and was done in such a way that a working version had to exist at all times. The code was not written from scratch, and some C parts were reused. The outcome is a smaller code, much cleaner, clearer, understandable, maintainable, and extensible. Some of the features of the “old” IRIS have not been ported to the “new” one yet, but most have.

As of today, IRIS can solve a wide variety of problems. Some of its salient features are:

As explained above, the code makes use of open source libraries. These include:

As for the rest, all the code is original and has been written from scratch mainly by the author and students of his research groups at UPM and IMDEA Materials Institute.

1. Installing IRIS

IRIS is a medium-sized program which depends on several libraries for complex operations in numerical algebra. To build a fully operational binary, one must link at least some of these libraries; the remaining ones can be added for additional features or improved performance. Since the code is designed to take advantage of shared-memory multi-core microprocessors, special (external) libraries must be linked to harness this feature. In addition, IRIS may be compiled to run on distributed memory computers, and this requires a special installation.

1.1. External libraries

As explained above, IRIS depends on several external — some of them optional — libraries which enable special type of computations. We describe each of them indicating what type of capabilities they enable and some instructions for their installation. The source files for the libraries are not distributed with IRIS, but mut be downloaded directly from the internet and installed in user-readable directories. It is not easy to explain all the possible solution for different machines and operating systems: IRIS makefile is simple enough to allow for customization.

The following table summarizes the requirements for external libraries

Name Mandatory / optional Tested version
BLAS Mandatory  
GMSH Optional (reduced functionality) 4.11
HSL Optional 1.02
Intel TBB Optional 4.0
LDL Optional 2.1
LAPACK Mandatory  
MUESLI Mandatory 2025
Pardiso Optional 6.0.0
PETSC Optional  
SuperLU Mandatory MT 3.1
WSMP Optional  

1.1.1. BLAS and LAPACK

The standard Basic Linear Algebra Subroutines (BLAS) and Linear Algebra Package (LAPACK) can be downloaded from the netlib repository in the internet, where instructions for their installation are provided. Given they widespread usage, most operating systems provide pre-compiled libraries, or even optimized ones. For Linux, there is a precompiled library for rpm-based distributions. For Mac OS X, the framework Accelerate contains all BLAS and LAPACK functions so there is no need to install from scratch the library for either operating system.

1.1.2. Intel TBB

This is a library of C++ classes that simplifies the implementation of multi-threading code. It can be downloaded from https://www.threadingbuildingblocks.org. In the case of Linux or MacOs operating systems, it can be installed using apt-get and brew, respectively.

Since 2025, IRIS does not require the Intel TBB library to carry out multi-threaded computations. Leveraging on the C++11 multi-threading standard library, IRIS is fully functional without Intel TBB, at the expense of some performance. This is because Intel TBB library is highly efficient and still faster than the standard multi-threading implementation. However, in the future the Intel TBB library will be removed from IRIS because it is difficult to install and link with the main code.

1.1.3. SuperLU

This is a free general purpose direct linear solver for unsymmetric sparse systems (See = http://crd-legacy.lbl.gov/~xiaoye/SuperLU=). At the current moment, the shared memory, multithreaded version of this solver is employed in IRIS.

1.1.4. LDL

This is another linear solver for general sparse systems of equations that has the virtue of being very compact. It is not extremely efficient, however.

1.1.5. WSMP

This an extremely fast library for sparse systems of equations that takes advantage of multi-processor computers. It includes specific Cholesky, symmetric, and unsymmetric solvers. Developed at IBM, it is non-free software. To include it in IRIS, and compile the necessary code to interface with it, an option needs to be set in the makefile.

1.1.6. Pardiso

Simiarly to the WSMP, this library is extremely fast and takes advantage of share-memory parallelism, providing a wide range of specialized solvers. At this moment it is not free software and no included by default in IRIS. A single option in the makefile can be set to link the library and compile the interface.

1.1.7. HSL solvers

This is a suite of sparse linear solvers developed at the Science and Technology Facilities Council of the UK that offers a free, non-commercial library to academic/research institutions. We have obtained one and its source code is currently shipped with IRIS.

1.1.8. MUESLI

This is a library that includes the most common material models for continuum problems and was developed side by side with IRIS. It can be downloaded from http://www.materials.imdea.org/Muesli.

1.1.9. GMSH

The software Gmsh is a freely available, open-source, pre- and post-processor for finite element models (web page). IRIS can take advantage of its capabilities to create solid models from a scripting language that allows for parametric mesh generation.

1.1.10. PETSC

Petsc is a very large library for serial and parallel numerical computations. It is written in C, but its interface with C++ is simple, providing access to many linear direct and sparse linear solvers, nonlinear solvers, preconditioners, ODE integrators, etc. It can be downloaded form http://www.mcs.anl.gov/petsc/. Petsc can be built in serial and parallel fashion, and has many options which are explained in its web page. Four our purposes, a simple configuration script is provided in the directory Blue/Makefiles/buildpetsc64. To use it, uncompress Petsc in, for example, usr/local/petsc. Then, copy buildpetsc64 to this directory and execute buildpetsc64 serial to build the serial version of the library or buildpetsc64 parallel, for the parallel version. We note that, in the configuration file provided, the Superlu library is downloaded, so that this step is simplified. The user might need to tweak this configuration file for his/her own specific system.

1.2. Building IRIS

The final stage consists in building the finite element code IRIS and linking it with all the external libraries. The code ships with a makefile that should take care of all the building process (see the Appendix).

The building process starts by selected which optional modules should be linked with the code.

After uncompressing the files, issuing the command make should take care of everything and build the final binary. If the building process fails, one should look into the makefile, and modify it to suit the computer needs.

If the building process completes, a binary iris will be created. The user then needs to move it to a directory in the correct path, such as /usr/local/bin.

2. IRIS basics

IRIS is a simulation code that an carry out a wide variety of simulation types, for many different materials, under many conditions. The definition of these problems is performed using a plain text input file that provides all the necessary details for describing the model and the analysis. The input files use, by default, the extension .iris; the code however, if instructed, can run files with any name.

2.1. Invoking IRIS

IRIS is started from a terminal by the command:

iris [--help] [–-debug] [--save] [-–test] [-–threads t]
     [-–version] [filename]

The arguments can be entered in any order and are all optional. Their use is as follows:

  • filename is the name (and path) of the analysis file, can be avoided if there is only one file with extension .iris in the directory where IRIS is run.
  • help: Displays the complete list of (optional) arguments to the IRIS command.
  • debug: Activates debug messages in runtime. This option is useful to track the flow of the program and help to identify possible errors. In addition, when the debug option is activated, the amount of data written in the IRISlog file will be increased.
  • save: saves the log file of the previous IRIS run so that it is not overwritten when running again.
  • test: forces IRIS to run a suite of tests that verifies element, materials, mesh functions, etc. The full syntaxis of the command is:
iris –-test all | cad | elements | materials | solvers |
       topology | math | meshing

Errors in the tests are shown in the console and no messages are dumped if all the tests are passed.

  • threads: IRIS is designed to run in multiprocessor computers. By default, the code selects an optimal number of threads into which the processing effort is split. However, the user might want to limit the resources available to the code by using this option. If t is larger than the number of cores available at runtime, this option is ignored.
  • version: IRIS shows its version and exits.

2.2. The input file

The input file describes the fundamental characteristics of the analysis such as its name, its type, the integrator, the solver, the materials, the element types, etc. Each of these options is defined through lines of commands, which are just assignments separated by commas: 

<command> [, <command>] [, <command>] [, <command>] [, ...]

Each <command> is an expression of the form: 

<keyword> = <value>

where <keyword> is an alphanumeric string without quotes and <value> might be numeric, alphanumeric or a string delimited by single or double quotes. Symbolic expressions can be given within quotes, such as in 

radius = "sin(4.0*_pi)+log(43.25*sqrt(10.0))"

A line ending with a backslash character \ indicates that the command is continued in the following line. A command can span as many lines as needed, as long as each line (except the last one) is terminated with the continuation character. The program does not distinguishes lower or upper case, except for data in strings. The character #, and everything coming after it until the end of the line, is ignored, thus serving to introduce comments in the input file.

A command line is recognized by its first keyword. In most cases, the order in which the remaining commands are input is not relevant. A few exceptions exist, mostly due to the need to introduce pairs of data. For example, in the tabular scaling factors, a sequence of pairs \((t_i,f_i)\) might be given to indicate the time evolution of a function in tabular form. In this case, and in some others, the value of the function is linked to the time instant prior to it.

Some of the commands are mandatory and some are optional. Generally speaking, the input file serves to create the model, run some type of analysis on it, and finally generate output data than can be postprocessed using external software (more on this later). Strictly speaking, the ordering of the commands is irrelevant since IRIS first reads all of them and later process them according to the most logical order (fist the geometry, then mechanics, finally the output).

The program IRIS is distributed with a directory of examples that illustrate all the capacities of the code. In this directory, subdirectories are included whose names refer to the commands or facilities illustrated by the specific example.

2.3. IRIS process in a nutshell

IRIS is a command-line code that takes a text file as input, creates a model and runs an analysis based on it. The code provides a log file with all the details of the analysis and — optionally — creates all the necessary files for the graphical postprocessing of the results and additional text files with specific output data of the solution. Figure 1 illustrates this overall structure in its simplest form.

./figures/flow-1.pdf

2.4. The input file

As previously indicated, the input file is responsible for describing completely the analysis that IRIS must perform when executed. It is based on a language that has been evolving through the years to include, at the moment, a wide range of possibilities as we will describe in subsequent chapters. The IRIS parser reads the input file and the sorts its content to obtain all the information required to run the analysis. Hence, there is a fair amount of freedom in the order with which the analysis is described. Figure 2 describes the main sections of the input file, ordered in a standard fashion.

./figures/input-1.pdf

In the following chapters, each of these blocks will be described with detail

3. Ancillary commands

Before describing the main commands that serve to precisely define the model that is run in IRIS, let us explain some auxiliary commands that might be useful to use at some point in the .iris file, usually to make it more clear or give it a better structure.

3.1. Comments

Let us start by mentioning, once again, that comments are available in the IRIS input file: everything after the character ’\’ is ignored by IRIS parser and does not even appear in the log file. For this reason, many input files — for instance, the ones in the examples directory of IRIS’ distribution — start with a block of the form 

# block.iris
# Transient simulation of a hyperelastic block
# author: i. romero
# creation date: 1/7/2022

3.2. Global parameters

In addition to choosing the type of analysis that IRIS must run, users may define global parameters that can be later employed in the input file. By using the command constants, new alphanumeric paramters can be introduced that can later be used as arguments for other commands such as material contants, mesh dimensions, time step size, etc. The syntax of these definitions is 

constants, <name> = <value> [, <name> = <value> ] [...]

Like everything other command in IRIS, constant names are case-insensitive. Values can be numeric or symbolic; in the latter case, the symbolic expression must be enclosed in quotes and may contain previously defined constants. The constants command can be used as many times as desired, and in any place of the input file.

3.3. Runtime messages

In some instances, it might be useful to output messages to the screen while running IRIS. The command echo provides precisely this functionality and its syntax is: 

echo, <string>

3.4. Including files

IRIS allows users to split the input file among several text files. The main file, the one that is sent in the command line to IRIS, can include all the necessary blocks by using the include command. Its syntax is: 

include, file = <string>

4. The analysis

The most fundamental command in an IRIS input file is the one that selects the type of analysis to be executed and it is often the first line of the .iris file, below some comments and text that (optionally) describes the analysis, identifies the author, date, etc.

The command line that selects the type of analysis is of the form: 

analysis, type = [controlled | dispersion | eigenvalue
    | harmonic | infsup | spectral | staggered | stationary
    | topopt | transient ] [, options]

where the [options] depend on the type.

In fact, it is possible to define more than one analysis type in a single input file. In this case, after one analysis is concluded, the next one starts using as initial data the output of the previous one.

4.1. Controlled analysis

4.2. Dispersion analysis

This analysis type allows to calculate the dispersion diagram of a periodic domain along a curve in wave-number space.

4.3. Eigenvalue analysis

This analysis type calculates the eigenvalues and eigenvector of a stiffness or the generalized eigenvalues for a dynamical problem. The commands in the command line are:

keyword Data type Default value
nmin <integer> 0
generalized <boolean> False
shift <double> 0.0
solver <keyword> subspace

In this analysis, IRIS finds the nmin smallest eigenvalues and eigenvectors of the stiffness matrix using the subspace iteration method. When the keyword generalized is included, this type of eigenpairs are calculated instead of the standard ones.

4.4. Harmonic analysis

4.5. Inf-sup analysis

IRIS can be employed to ascertain the well-posedness of a discretization by calculating and writing to disk the main operators that define the problem and its norms. The command line of this type of analysis is of the form 

analysis, type = infsup, primal = <string>, dual = <string>

To understand what the analysis does, consider first a irreducible formulation of small strain solid mechanics in which the only variable is, for example, the displacements u. Then, the inf-sup analysis will be launched with the command line 

analysis, type = infsup, primal = "u"

The analysis will calculate the stiffness matrix of the problem and write it on the file K.hwb, a sparse storage format known as Harwell-Boeing. The natural norm of this problem is the \(H^1\) norm and one has that \(\|u_h\|_{H^1} = U\cdot N U\), where \(U\) are the nodal values of the displacement field \(u_h\). The inf-sup analysis writes to disk the matrix \(N\) as well.

Consider next a mixed formulation. For example, one could analyze Stokes problem with primal variable v and dual p. The inf-sup analysis of this problem would be defined with the command 

analysis, type = infsup, primal = "v", dual = "p"

The analysis will write to disk K.hwb, the global stiffness matrix. However, in this case the stiffness matrix has a block structure \(K=[A B^T; B C]\) and the three blocks will be also written to disk in the files A.hwb, B.hwb and C.hwb. Also, in addition to the natural norm for the velocities which is the \(H^1\) norm, the natural norm for the dual variables is the \(L^2\) norm. The inf-sup analysis will write to disk these two norms with the names PN.hwb and DN.hwb which correspond to the primal norm and dual norm.

4.6. Spectral analysis

4.7. Staggered analysis

4.8. Stationary analysis

A stationary analysis is one where all rate effects are ignored (this includes damping or inertial contributions). These analyses include those in which the loading is applied slowly, meaning precisely that the rate effect have a negligible effect on the solution.

In stationary analyses time must be understood as a dimensionless parameter that indicates how the solution evolves as the loading is (“slowly”) applied. The precise term for this kind of analyses is “quasistatic”

The optional commands that can be provided in a stationary analysis are:

keyword Data type Default value
final_time double 1.0

4.9. Topology optimization analysis

4.10. Transient analysis

Transient analysis are designed to solve initial boundary value problems. The equations can be of order 1 or 2 in time. The optional commands that might be given in the analysis command line are:

keyword Data type Default value
final_time double 1.0

One should ensure that in a transient analysis the correct integrator is provided. In fact, this choise sets the order of the time derivatives as explained below.

5. Defining the model

An analysis runs always on a model that combines geometry and mechanics. The first step is thus the definition of one or more modelparts, that is, geometrical entities, whose mechanical behavior will be specified later in the input file. These parts are purely geometrical entities: the have (possibly) volume, surfaces, edges, vertices, that live in \(\mathbb{R}^3\) and can be generated with a CAD program. In order to solve boundary value problems defined on them, at some point a spatial discretization will have to be introduced: maybe the bodies are partitioned into disjoint polyhedra, or maybe filled with particles. In either case, there is no mechanics nor equation on these entities.

There are two ways of defining modelparts. In the first type, simple bodies can be used that are internally built and meshed in IRIS; in the second type, input files from external pre-processing software can be imported. In either case, the modelpart is not only responsible for creating nodes and elements (or particles, in a meshless method), but also all the necessary manifolds where boundary conditions and/or loads might be later applied. Manifolds are named sets of dimension 0 (vertices), 1 (edges), 2 (surfaces), or 3 (volumes). Depending on the shape of the body, the number of manifolds of a particular dimension changes. In some cases, there might not even be a single manifold for a given body (for instance, a sphere has no edges nor vertices).

The available template solids are described next.

5.1. Pre-defined bodies

5.1.1. The brick

This body is a parallelepiped or the image of one of this bodies by a smooth map. Like any other body, it is mandatory to indicate its name and the integer label eltype for the type of elements that it will generate. The name is a string that will identify the body when applying, for example, boundary conditions, or loads on it. 

modelpart, type = body, shape =  brick,
   name = <string>, eltype = <integer>,
   [, lx = <double>] [, ly = <double>] [, lz = <double>]
   [, divx = <integer>] [, divy = <integer>] [, divz = <integer>]
   [, centerx = <double>] [, centery = <double>] [, centerz = <double>]
   [, rotx = <double>] [, roty = <double>] [, rotz = <double>]
   [, xuvw = <string>] [, yuvw = <string>][, zuvw = <string>]
   [, subdivisions = <integer>]
   [, interpolation = p1 | p1p0 | p2 | p2p0 | p2p1 ]

By default, the body has dimensions \(1\times1\times1\), however, these three lengths can be modified with the optional commands lx, ly, lz. The number of divisions along each of the three axes are given by divx,divy,divz. The center of the body can be shifted using the optional parameters centerx, centery, centerz; also, the body is oriented with its axes parallel to the cartesian ones, but this orientation can also be modified by rotating the body with the optional vector rotx, roty, rotz. As indicated before, the parallelepiped can be mapped smoothly to another solid by using the parametric equations

where the three maps are given with the commands xuvw, yuvw, zuvw. The brick generates the following named manifolds:

Dimension Name
0 vertex0 .. vertex7
1 edge0 .. edge11
2 surface0 .. surface5
3 volume0

If the interpolation is selected to be p1 or if it is not used, the brick will generate a mesh of tetrahedra. If other interpolation options are provided, mixed-type meshes will be created. Notice that when a mixed method ( p2p0 or p2p1 ) is selected, a nodeset with name pressurenode will be automatically created that is linked to a pressure node.

cube.png

Figure 1: A brick generated by IRIS

5.1.2. The qbrick

The parallelepided of the previous section can be meshed with quadrilateral elements simply by replacing the shape brick with qbrick. The options for this new body are identical to those of the brick and are not explained here. Also, the vertices, edges and surfaces are the same.

5.1.3. The qdome

A spherical dome can be generated and meshed with quadrilateral elements. The syntax for creating such a body is: 

modelpart, type = body, shape =  qdome,
   name = <string>, eltype = <integer>,
   [, radius = <double>],
   [, centerx = <double>] [, centery = <double>] [, centerz = <double>]
   [, rotx = <double>] [, roty = <double>] [, rotz = <double>]
   [, subdivisions = <integer>]

By default, the body has radius \(1\), but there is an option to modify it. The center of the body can be shifted using the optional parameters centerx, centery, centerz; also, the body is oriented with its axes parallel to the Cartesian ones, but this orientation can also be modified by rotating the body with the optional vector rotx, roty, rotz. The surface has the following named sets defined:

Dimension Name
1 edge0
2 surface0

dome.png

Figure 2: A spherical dome generated by IRIS

5.1.4. The cylinder

This body is a cylinder with default height 1 and radius \(1/2\), meshed with tetrahedra. Like any other body, it is mandatory to indicate its name and the integer label eltype for the type of elements that it will generate. The commandline for this body is: 

modelpart, type = body, shape = cylinder,
   name = <string>, eltype = <integer>
   [, radius = <double>] [, height = <double>]\
   [, centerx = <double>] [, centery = <double>] [, centerz = <double>]\
   [, rotx = <double>][, roty = <double>][, rotz = <double>]\
   [, subdivisions  = <integer>]

The cylinder generates the following named manifolds:

Dimension Name
1 edge0, edge1
2 surface0, surface1, surface2
3 volume0

cylinder.png

Figure 3: A cylinder generated by IRIS

5.1.5. The spherical cap

This body is one eighth of a hollow sphere. More precisely, it is the fraction of the hollow sphere in the positive orthant and it is meshed with tetrahedra. The commandline for this body is: 

modelpart, type = body, shape = cap,
   name = <string>, eltype = <integer>
   [, rint = <double>] [, rext = <double>]\
   [, centerx = <double>] [, centery = <double>] [, centerz = <double>]\
   [, rotx = <double>][, roty = <double>][, rotz = <double>]\
   [, subdivisions  = <integer>]

The code is set to generate \(6*n\) elements subdivisions along the \(\phi\) and \(\theta\) directions, where \(n\) is the number of subdivisions. The cap has the following named manifolds:

Dimension Name
0 vertex0, … , vertex 5
1 edge0, …, edge8
2 surface0 \((r=r_{int})\)
2 surface1 \((r=r_{ext})\)
2 surface2 \((\phi=\pi/2)\)
2 surface3 \((\phi=0)\)
2 surface4 \((\theta=0)\)
3 volume0

cap.png

Figure 4: A spherical cap generated by IRIS

5.1.6. The polycrystal

In IRIS, a polycrystal refers to a parallelepiped with some internal structure, meshed with regular tetrahedra. Similarly, the modelpart qpolycrystal refers to the same type of solid, now meshed with regular hexahedra. These two bodies have the same manifolds of the brick and the qbrick, respectively, and are designed to work with periodic boundary conditions. See the example files 3115_Polyhedra and 3116_Polyhedra2.

The general syntax of this body is similar to that of the brick, but some options have been removed. Specifically, the polycrystal is defined by: 

modelpart, type = body, shape = polycrystal, geometry = <string>,
   name = <string>,
   [, lx = <double>] [, ly = <double>] [, lz = <double>]
   [, divx = <integer>] [, divy = <integer>] [, divz = <integer>]
   [, subdivisions = <integer>]

There are several types of polycrystals, and selected with the option geometry. Each of them may require additional input data to be provided. This is summarized in the following table:

geometry Description
spheres Box with a periodic spherical inclusions, each of a different eltype
blocks Box consisting of brick-shaped blocks, each one of a different eltype

The geometries have options that can be used to tailor the “microstructure” of the polycrystal. In the case of the spheres geometry, the user must define, one by one, the center, radius and eltype of each of the included spheres as in 

modelpart, type = body, shape = polycrystal, geometry = spheres,
   name = <string>,
   ...
   [, centerx = <double>] [, centery = <double>] [, centerx = <double>], radius = <double>, eltype = <int>,
   [, centerx = <double>] [, centery = <double>] [, centerx = <double>], radius = <double>, eltype = <int>,
Parameter Default Description
centerx 0.0 x-coordinate of the sphere center
centery 0.0 y-coordinate of the sphere center
centerz 0.0 z-coordinate of the sphere center
radius - Radius of the spherical inclusion
eltype - Element type for the inclusion (\(\ge1\))

In this polycrystal, the element type with label 1 is reserved for the matrix, and must be defined in the element type list. Note that all data must be defined for each spherical inclusion and also that the eltype might be shared among two or more inclusions.

For the blocks microstructure, the additional option is

Parameter Default Description
ncrystals 1 Cubic root of the number of crystals

At the moment, the polycrystal does not generate the element types that are required to generate all the elements in the polycrystal. For that, the user is responsible for adding them to the analysis file beforehand.

5.1.7. The sphere

A sphere is, by default, a solid body of radius 1 and it is meshed with tetrahedra. The syntax for including a sphere in IRIS is: 

modelpart, type = body, shape = sphere,
   name = <string>, eltype = <integer>
   [, radius = <double>]
   [, centerx = <double>] [, centery = <double>] [, centerz = <double>]\
   [, rotx = <double>][, roty = <double>][, rotz = <double>]\
   [, subdivisions  = <integer>]

The manifolds that are automatically generated for the sphere are:

Dimension Name
2 surface0
3 volume0

5.1.8. The torus

5.1.9. The rectangle

5.2. Interactions

After two or more model parts have been defined, interactions can be introduced among them. These include contact pairs, glueing parts, embedding parts, etc.

The contact interaction has the following syntax: 

contact, penalty = <double>, type = mebody_to_plane, body = <string>,
   [, pi0 = <double>] [, pi1 = <double>] [, pi2 = <double>] [, pi3 = <double>]

contact, penalty = <double>, type = nodeset_to_plane, nodeset = <string>,
   [, pi0 = <double>] [, pi1 = <double>] [, pi2 = <double>] [, pi3 = <double>]

contact, penalty = <double>, type = nodeset_to_elset, nodeset = <string>, elset = <string>

contact, penalty = <double>, type = elset_to_elset, elset1 = <string>, elset2 = <string>

contact, penalty = <double>, type = body_to_body, body = <string>,
    body = <string> [, body = <string>, ...]

contact, penalty = <double>, type = all_bodies

contact, penalty = <double>, type = rigid_wall

5.3. Nodesets and elsets

As its name indicates, nodesets and elsets are collections of nodes and elements, respectively. They enables the use of functions that operate on sets, enormously simplifying the manipulation of large sets of objects.

There are two ways to define a nodeset. First, in some low-level mesh files, nodesets are defined by providing lists of nodes. This includes the imf mesh files and also the meshes imported from Abaqus, gmsh, etc.

Second, in the .iris files one can extract sets of nodes from existing parts and give them a unique name. For example, one can create a Cartesian coordinate system and the select all nodes whose value of one or more coordinates is fixed, or whose value is within a given range (modulo some tolerance). Specifically, the nodeset selection would be obtained by issueing: 

nodeset, name = <string>, modelpart = <string>, select = cartesian
   [, tolerance = <double>]
   [, centerx = <double>] [, centery = <double>] [, centerz = <double>]
   [, x = <double>] [, y = <double>] [, z = <double>]
   [, minx = <double>] [, miny = <double>] [, minz = <double>]
   [, maxx = <double>] [, maxy = <double>] [, maxz = <double>]

The default values for centerx, centery, centerz are \((0,0,0)\). Similarly, one can select nodes based on their cylindrical coordinates. 

nodeset, name = <string>, modelpart = <string>, select = cylindrical
   [, tolerance = <double>]
   [, r = <double>] [, theta = <double>] [, z = <double>]
   [, centerr = <double>] [, centert = <double>] [, centerz = <double>]
   [, minr = <double>] [, mint = <double>] [, minz = <double>]
   [, maxr = <double>] [, maxt = <double>] [, maxz = <double>]

Also, one can also select the nodes on a plane with the command 

nodeset, name = <string>, modelpart = <string>, select = plane
 [, tolerance = <double>]
 [, pi0 = <double>] [, pi1 = <double>] [, pi2 = <double>] [, pi3 = <double>]

Finally, one can define a nodeset directly by providing the node labels. This is not the most desirable strategy because node labels change when the mesh is refined, but can be nevertheless be useful sometimes. The syntax is: 

nodeset, name = <string>, modelpart = <string>, select = labels
   [, label = <integer>] [, label = <integer>] [, label = <integer>]

Elsets are less used in IRIS at, at the moment, can only be defined in mesh files.

5.4. Creating finite element models from mesh files

IRIS can create parts from (low level) mesh files containing only geometrical information of the model and following a syntax originally designed for IRIS in its first versions. The way to import such parts is using the command: 

modelpart, type = mesh, filename = <string>, name = <string>, dimension = <integer>

In this type of input, the filename has node positions, elements, nodeset and elset and the maximum dimension of the modelpart is also indicated. This way of describing parts is still operational but is too poor for more advanced applications so it is being superseded by the new format, referred to as imf, or IRIS mesh format, described below.

The imf syntax has the following commands:

  • nodes : this part of the file lists all the nodes in the part, giving each one a label and its coordinates.
  • elements : describing groups of similar elements.

  • nodeset : collecting nodes in such a way that they can be later used for boundary conditions or other needs.

    We describe next with more detail each of the parts.

5.4.1. Nodes

Each modelpart must include a list of nodes, where the degrees of freedom of the problem will be stored. These could be used to generate nodes in a finite element discretization or particles, in a particle-based method. In all cases, nodes can be input in one or more blocks, each of them of the form 

nodes
 label1 x1 y1 z1
 label2 x2 y2 z2
 ...
 labeln xn yn zn
 <empty line>

In each of the lines, the first integer is the label. Then, three decimal numbers indicate its coordinates. The node labels must be unique in the model part, although there can be defined in arbitrary order and need not be sequential. Between numbers the imf format uses one or more spaces.

5.4.2. Element

Parts can have elements of many different types, all of them connecting one or more nodes. Each element block must be of the form 

elements, geometry = volume | surface | curve | point, setname = <string>,
   eltype = <integer>, [other commands]
label1 nodelabel11 nodelabel12 nodelabel13 ...
label2 nodelabel21 nodelabel22 nodelabel23 ...
label3 nodelabel31 nodelabel32 nodelabel33 ...
<empty line>

Following the keyword elements, the rest of the options can be given in any order. Since the number of nodes does not determine whether the element is a surface one, a line, etc., the geometry indicates this, and its value must be one of volume, surface, curve, point. The setname is a string that might allow in the future to refer to the whole set of elements; the eltype is a non-negative integer that corresponds to IRIS eltype numbering. Finally, other keywords can be used with any value that will help the importer deal with the peculiarities of the mesh file used as input for the imf format. For example, the Abaqus importer creates command lines that have the additional keyword abaqustype = <string>.

After the header, one line of data is provided for each element. The first integer is the element label; then, the node labels for this element follow. Since all the elements in the block are of the same type, all the lines in this block should have the same number of nodes. Finally, the block closes with an empty line.

The element labels must be unique for the whole part, although they need not be consecutively defined and might be given in an arbitrary order.

The number of element blocks is, in the new imf data structure, important. For every part that describes a finite element model, the highest dimension among all element blocks determines the type or part, whether it is a volume, a surface, a curve, o simply a point. Once this set is defined, the sets of lower dimensions are used to describe its boundaries. For example, if the set of the highest dimension is a volume, the remaining sets can be used to describe the elements on the external surfaces, the edges between two surfaces, the vertices at the intersection of edges, etc. Similarly, if the set of the highest dimension is a surface, then the remaining element blocks would allow the definition of the edges and vertices.

5.4.3. Nodesets

Finally, the nodeset blocks allow to collect a group of nodes under a common name that can be used later to refer to them and apply boundary conditions, contact conditions, etc. Several ways are provided to define a node set. The simplest syntax is 

nodeset, name = <string>, type = list
   label1 label2 label3
   label4 label5
   label6 label7:label8 label9 ...
   <empty line>

Except for the first keyword, the remaining fields can be provided in an arbitrary order. For a nodeset of type list, the node labels are given in one or more lines separated by spaces and the block ends with an empty line. Also, the notation i:j, with \(i\le j\), selects all nodes with labels numbers between \(i\) and \(j\), both included.

There is a second type of nodeset blocks that can be defined by selecting those nodes already defined in the part that verify certain geometric conditions. For example, in order to select nodes using their cartesian coordinates the following command can be used 

nodeset, name = <string>, type = cartesian,
   centerx = <double>, centery = <double>, centerz = <double>
   [, x = <double>] [, y = <double>] [, z  <double>]

Likewise, to select nodes using cylindrical coordinates we use 

nodeset, name = <string>, type = cylindrical,
   centerx = <double>, centery = <double>, centerz = <double>
   [, r = <double>] [, theta = <double>] [, z = <double>]

5.5. Importing meshes from external other programs

IRIS has also a few importers. Each of them can take input files for other codes, such as Ansys or Abaqus, and generate an intermediate mesh file that can be later read by IRIS. In the past, the intermediate file generated by the importer had the old mesh format; in the future, these auxiliary files should adhere to the new imf syntax.

To import models from other codes IRIS still employs the command modelpart but now with the following syntax 

modelpart, type = [abaqus | geo | tecplot | xml], filename = <string>,
   name = <string>, dimension = <integer>

The name is the tag employed later in the loading and boundary conditions to refer to this model. The filename is a text file with the native format of either of these codes. IRIS will process the input file, create a new imf file, and the use the latter as the input file. The dimension indicates the largest dimension of the manifold of the model part (3 for a volume, 2 for a surface, 1 for a curve), even if all nodes must be in three-dimensional space.

5.5.1. Using Gmsh to generate mesh files

Gmsh is a powerful, open-source, free software for the pre- and post-processing of finite element models. It has a powerful scripting language that can generate meshes from high-level primitives. IRIS can read these Gmsh files, send them to this program, generate a mesh file, and finally import it. To enable this feature, IRIS must be linked with the gmsh library. 

modelpart, type = geo, filename = <string>, name = <string>

5.5.2. Importing Abaqus mesh files

Abaqus analyses can be run either from a script file (a files with the extension .inp) or from the graphical user interface (GUI). In the latter case, Abaqus creates the script file and it is always the latter what gets analyzed ultimately and the GUI can then be understood as a tool to generate input files in a convenient way.

In IRIS, when a model part is imported form Abaqus, an .inp text file is expected and then converted to the imf format.

IRIS does not process all the information contained in the inp file. Instead, it extracts from it the nodes coordinates, the elements sets (ELSET), and the node sets (NSET). To be compatible with IRIS, it is important that the Abaqus input file describes element sets for all the volumes, surfaces, edges, and vertices that will be later required for the mesh and the boundary conditions. Since the modelpart command line in IRIS includes a dimension option, only one element set with maximal dimension should be defined in the input file.

6. Describing the solution

Once the model has been described, the features of the mechanical problem can be assigned to it and the controls of the analysis, determined.

6.1. Scaling factors

Before defining how boundary conditions and loads can be input into IRIS, let us introduce the concept of scaling functions and their implementation within the input file language. The code allows to introduce both of these in a way that they vary in time. For example, this would allow to shake the supports of a structure or to apply wind loads whose value and direction depend on time.

A scaling function is thus a scalar-valued function \(F\) that depends on time and space. IRIS allows to define as many as desired, even if they are never used. These functions have all additive form: they are built by simpler contributions \(f_i\) that are added before evaluation. In this way,

In IRIS, we define a scaling function by describing its elementary contributions as in 

scaling, combination = <integer>,
    type = constant | gaussian | linear | sine | symbolic | tablefile | tabular | triangle 
    [,options]

Here, the combination refers to the label of the scaling function \(F\), since the individual components can not be used by themselves. Each type of scaling factor has different options as described in the table

Scaling type option default option default option default option default
constant value 1.0            
gaussian mean 1.0 variance 1.0        
linear initial 0.0 slope 1.0        
sine amplitude 1.0 frequency 0.0 period 0.0 phase 0.0
symbolic value “t”            
tablefile filename -            
tabular time   value          
triangular peak   height 1.0        
laguerre lambda0 1.0 n 1        

All the scaling contributions, in addition, have two common options

option default value
start 0.0
end infinite

The tabular scaling factor is slightly different to the rest and its syntax is: 

scaling, combination = <integer>, type = tabular, [time = <double>, value = <double>]
     [, time = <double>, value = <double>]
     [, time = <double>, value = <double>] ...

With this syntax, the user can introduce pairs of time value \((t_i,v_i)\) and the tabular factor will interpolate in intermediate instants.

The tablefile uses an external file that has two columns, the first one for the time, the second one for the value of the scaling factor. Optionally, the file might have comment lines that start with the character “\#”. The syntax of this scaling factor is 

scaling, combination = <integer>, type = tablefile, filename = <string>

The symbolic scaling factor allows the user to define analytical expressions of the variables \((t,x,y,z,\phi,\theta,r,\rho)\) that are evaluated at every point of space and instant of time in the simulation. Here, \((x,y,z)\) are the Cartesian coordinates, \((\rho,\phi,z)\) are the cylindrical coordinates, and \((r,\phi,\theta)\) refer to the spherical coordinates. This is a very powerful command that can be used, for example, to create filters. Using the C if block syntax, one can apply loads only on certain regions of the space without the need to define new element set nor manifolds. For example, the command 

scaling, combination = 1, type = symbolic, value = "x*y > 0 ? t : 0.0"

defines the scaling combination number 1 to be proportional to time in the region \(xy>0\) and zero elsewhere. The variables phi,theta,r correspond to the three spherical coordinates.

By default, IRIS creates the scaling factor with label 0, a linear factor whose value is identical to the time variable.

6.2. Boundary and initial conditions

Boundary conditions for initial and boundary value problems are defined with the command bc. There exist severa ways to use it for reasons of backward compatibility. A major difficulty derives from the fact that IRIS now can work with multi-field problems and the name of the degree of freedom changes from problem to problem, precisely to allow combinations.

The preferable way to use bc is on manifolds. As described before, every part has manifolds defined precisely for this purpose. By using manifolds, the user does not need to know about node numbering or any other detail of the discretization but can, instead, focus on the true geometrical aspects of the model. The syntax of this version of the command is: 

bc, [part | body] = <string>, setname = <string>,
    variable = <char> [, value = <double>]
    [, valuex = <double>] [, valuey = <double>] [, valuez = <double>]
    [, scaling = <integer>]

In this command, first the model part is seleted; then, the manifold is selected using the name with which each of them were defined. Then, the letter of the variable on which the boundary condition is to be applied must be given. If the varible is scalar, is suffices to give its value. If, instead, it is a vector field, then its values on the \(x,y,z\) directions can be given independently. Finally, the scaling factor can be added. If the latter is not given, it is assumed that the boundary condition is scaled by the default scaling factor (with label 0).

Boundary conditions can also be applied directly to nodesets. The syntax in this case is as follows: 

bc, nodeset = <string>
   [, ux = <double>] [, uy = <double>] [, uz = <double>]
   [, p = <double>] [, e = <double>]
   [, rotx = <double>] [, roty = <double>] [, rotz = <double>]
   [, dirx = <double>] [, diry = <double>]
   [, scaling = <integer>]

This old way of applying initial conditions has an important limitation: it only works with mechanical problems in which the unknown fields have names u, p, e, are rotations or directors. It should be avoided when possible.

Initial conditions are applied on the model in a similar fashion. The syntax is 

ic, [part | body] = <string>, setname = <string>,
    variable = <char> [, value = <double>]
    [, valuex = <double>] [, valuey = <double>] [, valuez = <double>]
    [, filter = <option>] [, filtertype = <option>]
    [, noise = <double>] [, noisevariance = <double>]

Alternatively, the initial condition can be given, but on a nodeset directly using 

ic, nodeset = <string>,
    variable = <char> [, value = <double>]
    [, valuex = <double>] [, valuey = <double>] [, valuez = <double>]
    [, filter = <option>] [, filtertype = <option>]
    [, noise = <double>] [, noisevariance = <double>]

Finally, for second order problems, initial rates can be set using the same syntax, just modifying the keyword. Specifically, we must employ the following: 

initialrate, [part | body] = <string>, setname = <string>,
    variable = <char> [, value = <double>]
    [, valuex = <double>] [, valuey = <double>] [, valuez = <double>]
    [, filter = <option>] [, filtertype = <option>]

or 

initialrate, nodeset = <string>,
    variable = <char> [, value = <double>]
    [, valuex = <double>] [, valuey = <double>] [, valuez = <double>]
    [, filter = <option>] [, filtertype = <option>]

The option for the keyword filter is a symbolic expression in terms of the Cartesian coordinates \((x,y,z)\) , the cylindrical coordinates \((\rho,\phi,z)\) or the spherical ones \((r,\phi,\theta)\). The noise add a Gaussian noise on the initial condition that proportional noise, has a zero mean and variance noisevariance.

6.3. Linear multipoint constraints

Linear multi-point constraints (MPC) allow to link the displacement degrees of freedom of different nodes with linear relations. These constraints do not reduce the number of degrees of freedom of the problem; on the contrary, each of them adds one Lagrange multiplier to the global problem, so they should be used with care.

The syntax is as follows. Given some nodes with labels \(\mathcal{L}=\{l\}\), with \(\dim(\mathcal{L})=n\), and parameters \(\{\alpha_i,\beta_i,\gamma_i \}_{i=1}^n\), the linear constraint

\begin{equation*} \mbs{\phi}(\{\mbs{u}_i\}_{i\in \mathcal{L}}) \equiv \sum_{i\in \mathcal{L}} \mbs{w}_i\cdot \mbs{u}_i - C(t) = 0\ , \qquad\mathrm{with weights}\qquad \mbs{w}_i = \langle \alpha_i , \beta_i , \gamma_i \rangle^{T} \end{equation*}

is imposed using the command line: 

linmpc, node = l0, [, alpha = <double>] [, beta = <double>] [, gamma = <double>]
       [, node = l1, , alpha = <double>   , beta = <double>   , gamma = <double>]
       [, node = l2, , alpha = <double>   , beta = <double>   , gamma = <double>]
       [, c= <double>] [, scaling = <int>]

The scaling option allows to use a pre-defined scaling factor to multiply the constant c so that, in the constraint, \(C(t) = c\; S_i(t)\), where \(i\) is the index of the scaling function. If no scaling is provided, it is assumed that \(S_i(t)\equiv 1\).

The user is cautioned not to constrain degrees of freedom that are already constrained with the standard boundary conditions.

See example 51_Constraints/5109_linmpc.

6.4. Periodic boundary conditions

IRIS includes some facilities to impose periodic boundary conditions, but they can only be used with prismatic blocks. To impose them, one starts by defining a model part of type brick or qbrick, as usual. Then, the following command line identifies the faces that have periodic boundary conditions 

periodic, body = <string>,
     master = <string>, slave = <string>
     [, master = <string>, slave = <string>]
     [, master = <string>, slave = <string>]
     , epsxx = <double>, epsxy = <double>, epsxz = <double>
     , epsyx = <double>, epsyy = <double>, epsyz = <double>
     , epszx = <double>, epszy = <double>, epszz = <double>, \
     scaling = <int>, preconditioner = <double>

The periodic boundary conditions can be applied (on the brick surfaces) onto one, two or three face pairs. These pairs are identified by the sequence master / slave keywords. Then, at most six components of the strain operator can be defined . Finally, the scaling refers to a scaling factor that can be employed to impose gradually the deformation. If the scaling keyword is not employed, the deformation is imposed at time \(t=0\).

For other bodies, IRIS allows to impose periodic boundary conditions, although this feature should be handled with care. The user is required to define six nodesets and then use the slightly modified command: 

periodic, body = <string>,
     master = <string>, slave = <string>
     [, masternodeset = <string>, slavenodeset = <string>]
     [, masternodeset = <string>, slavenodeset = <string>]
     , epsxx = <double>, epsxy = <double>, epsxz = <double>
     , epsyx = <double>, epsyy = <double>, epsyz = <double>
     , epszx = <double>, epszy = <double>, epszz = <double>, \
     scaling = <int>, preconditioner = <double>

As in the case of the master/slave surfaces, the nodesets defined above must be paired by opposing ones, and should include nodes that are exactly symmetric to each other.

The periodic boundary conditions define a Neumann problem. To make it well-posed, infinitesimal rigid body modes need to be constrained. To to so, one option is to select six degrees of freedom that are independent, and constrain them. Another option is to use the perturbed technique proposed by Kaleen and Romero. See the solid element.

The condition number of the stiffness of a mechanical problem with the periodic boundary conditions just described is not good. A remarkable improvement can be obtained if a preconditioner is employed of the order of \(E\,h\). If employed, the condition number improves significantly at the expense of the multipliers losing their physical interpretation: instead of forces, they will have dimension of length, so they need to be scaled back by \(E\,h\) to recover their physical meaning.

See example 51_Constraints/5110_periodic.

6.5. Applying loads

The way loads can be applied on IRIS has also evolved during the years and two methods currently co-exist. In the old, low-level, scheme, loads can be applied on nodesets, which can be selected either by their name or by the manifold that contain them. In the first case, the syntax is 

loading, nodeset = <string> [,fx = <double>] [,fy = <double>] [,fz = <double>]
    [,f = <double>] [,frotx = <double>] [,froty = <double>] [,frotz = <double>]
    [,scaling = <integer>]

Here, the nodal forces \(f_x,f_y,f_z\) are conjugate to the degrees of freedom \(u_x,u_y,u_z\), while the loads \(frot_x,frot_y,frot_z\) are the moments conjugate to the rotational degrees of freedom. This command is too limited because it does not accept loads on general degrees of freedom. Alternatively, the following command can also be employed: 

loading, nodeset = <string> variable = <char>] [,value = <double>]
    [,value0 = <double>] [,value1 = <double>] [,value2 = <double>]
    [,scaling = <integer>]

This latter form is more general and allows to apply loads on scalar and vector degrees of freedom, following the same syntax as the boundary conditions. Similarly, one can replace the nodeset option with the name of a model part and the manifold on which the load has to be applied. The syntax is thus 

loading, [part | body] = <string>, vertex | edge | surface | volume = <integer>,
    variable = <char>] [,value = <double>]
    [,value0 = <double>] [,value1 = <double>] [,value2 = <double>]
    [,scaling = <integer>]

The previous commands apply on the nodes of the selected nodeset identical loads. This is inconsisent with variational methods where loads must be distributed according to the measure assigned to each node. For example, if a uniform load is applied to a surface, nodes on the edges and the corners should be loaded with a smaller load. To accommodate this general loading type, IRIS has a more advanced loading command with the following syntax 

superloading, [part | body] = <string>, setname = <string>
    [, eltype = <int>]
    variable = <char>] [,scaling = <integer>]
    [,option = <double>] ...

In this, preferable, command, the manifold where the load has to be applied is the given by the setname on a particular body or part. The option(s) keyword(s) depends on the analysis (mechanical, thermal, fluid, etc.) as described in the appendix.

6.6. Elements and materials

In a finite element analysis, every element has a type and a material. A model part can have elements of a single type, although it is possible to mix types. Each type must be defined with a command such as 

eltype, label = <integer>, type = <keyword> [, material = <integer>] [, <command>] [, <command>] ...

The label is a unique integer label that is used, for example, in the model part definition or in the mesh files. Often the element types are linked to a material which itself is assigned to a unique label and referenced with the command material = <integer>. Element types might possess other commands that are appended to the list. Each element type is slightly different. We refer to the Appendix for the specific options of each type.

A material is defined in a similar fashion. A command line is used that gives the material a name, a label, a type, and potentially other parameters as in: 

material, label = <integer>, name = <string>, type = <keyword>, [, <command>] [, <command>] ...

6.7. Step solvers

Depending on the analysis type, it might be the case that the solution is obtained in a step-by-step fashion. This is true for quasistatic, transient, staggered and topology optimization problems. For the solution of each step, there exist several methods where IRIS can choose from. The command line that takes care of this is: 

stepsolver, type = [adr | arclength | explicit | fractional | linear | newton |
   nlcg | quasinewton]  [, <command>] [...]

The keywords correspond to the following methds

Keyword Method name
adr Adaptive dynamic relaxation
explicit Explicit solver
fraction Fractional step solver
linear Solver of linear equations
newton Newton-Raphson
nlcg Nonlinear conjugate gradient
quasinewton Quasi-Newton nonlinear solver

6.7.1. Adaptive dynamic relaxation

6.7.2. The Newton-Raphson method

The Newton-Raphson method is the most common solution strategy for nonlinear problems. It is so common that in IRIS it is programmed with a certain amount of complexity to encompass different situations.

Fist, let us recall the complete syntax for its definition, before explaining in detail how the solver works: 

stepsolver, type = newton [, maxiterations = <integer>]
    [, maxtrials = <integer>] [, update = <integer>]
    [, tolerance = <double>] [, abstolerance = <double>]

The Newton-Raphson attempts to solve a nonlinear problem by iterating until the energy error in the (residual) equation is below certain value (abstlerance) or it is reduced from its initial value to a relative number (tolerance). The method will attempt to converge in a number of iterations that is, at most, maxiterations. If the procedure fails, the time step control is automatic, then the method will restart, now with a smaller time step size. This restarting strategy can be performed, at most, maxtrials times.

6.8. Linear solvers

In many of the analyses that IRIS can carry out there will be, at some point, a large system of linear equations that needs to be solved. The following command selects which of the available solvers will be used for this task: 

linsolver, type = [superlu | hsl | pcg | ldl | wsmp | pardiso] [, <command>] [...]

6.8.1. SuperLU solver

The SuperLU solver is a direct solver for sparse systems of equations. Currently, the shared-memory version of the library is employed. For this library, there are keywords that activate options in the solver. For example, the nopivoting keyword blocks all pivoting in the factorization, nprocs can modulate the number of threads opened for the solution of the system of equations, the keywords unsymmetric/symmetric select what type of profile the matrix has, the keyword printinfo activates writing information about the matrix on IRIS log file; finally, the dumpmatrix keyword, when present, forces the matrix to be written in a file for latter postprocessing. The keyword printinfo activates some output messages, such as the condition number (written to the log file).

The solver works in symmetric and unsymmetric modes.

keyword Data type Default
nopivoting - -
nprocs <integer> max in computer
unsymmetric - -
symmetric - -
printinfo - -
dumpmatrix - -

6.8.2. HSL solver

The HSL family of solvers includes several multithreaded specific solutions that are suited to special matrix types. In the input file, the syntax should be: 

linsolver, type = hsl, subtype = [cholesky | symmetric | unsymmetric | indefinite]

By default, if no subtype is selected, the unsymmetric solver will be selected. The sparse matrix can be written to a file using the dumpmatrix option.

keyword Data type Default
subtype <keyword> unsymmetric
dumpmatrix    
subtype Matrix type
cholesky Symmetric, positive definite matrix
symmetric Symmetric, indefinite matrix
unsymmetric General matrix
indefinite  

6.9. Time integration method

In step-by-step solution, in addition to the solver, a time integration method must be provided. This is the algorithm that will take care of integrating the equations in time (for a transient problem) or in pseudo-time for a stationary problem. The command line to drive this option is 

integrator, type = [quasistatic | cd | newmark | hht | midpoint] [, <command>] ...

Time stepping methods are responsible for updating the state variables after every iteration — if the step solver is nonlinear — and after the end of a time step, before starting a new one. The keywords in the command line correspond to the following methods

Keyword Method’s name Time order
backwardeuler Backward Euler One
cd Central differences method Second
forwardeuler Forward Euler One
hyperpara Hyperbolic/parabolic One + two
newmark Newmark’s method for second order equations Second
hht Hilber, Hughes & Taylor Second
midpoint Midpoint rule One/two
quasistatic Quasistatic integrator Zero
verlet Verlet method Two

6.9.1. Quasistatic

The quasistatic integrator is really not a time integrator; it is just the standard method to push the degrees of freedom during iterations and steps in a quasistatic solution. This method has no options.

6.9.2. Newmark method

Newmark’s method is the most common integration scheme for solid and structural mechanics (Newmark, N M., 1956). The method has two parameters, usually referred to as \(\beta,\gamma\) that determine the stability, accuracy, artificial damping of each of the members of the family. The options of the method in IRIS are

Keyword Value
beta double
gamma double
predictor integer in \([1,2]\)

The most common algorithm within the Newmark’s family is the trapezoidal rule, as second order accurate method that is unconditionally stable for linear problems and has no algorithmic damping. It corresponds to \(\gamma = 2\beta = 1/2\). In IRIS, when the integrator command line selects the Newmark’s method and no additional options are given, the code chooses the parameters of the trapezoidal rule.

When \(\gamma>1/2\) is given, IRIS selects automatically the parameter \(\beta\) so that the resulting method has maximum algorithmic dissipation while preserving the unconditional stability for linear problems. As a drawback, the method becomes only first order accurate.

In nonlinear problems, the choice of predictor in a solution step might have a non-negligible effect. By default, IRIS chooses as predictor for the displacements field the one obtained in the last converged solution, effectively setting the velocity to zero. If predictor is set to 2, the velocity at the beginning of the step is set fixed, and thus the initial displacement does not corresponds to the previously converged one.

6.9.3. The HHT method

The Hilber-Hughes-Taylor method is a second order implicit method for structural dynamics that possesses controllable artificial dissipation (Hilber, H. M. and Hughes, T. J. R. and Taylor, R. L., 1977). The options of the method are:

Parameter Value
alpha double in \([0.7,1]\)

When the parameter alpha is set equal to 1, the method will be identical to the trapezoidal rule and thus it will add not high-frequency damping. The amount of dissipation increases monotonically while alpha is reduced until 0.7.

6.10. Time stepping control

An important ingredient of a step-by-step is the selection of the time step size. In IRIS, this quantity can be fixed by the user, or allow the code to select it adaptatively. 

tscontrol, type = [automatic | cfl | fixed] [, <command>] [...]

If a time step control is not provided, the default fixed will be employed.

6.10.1. Automatic time step selection

keyword Data type Default value
dt <double> 1.0
maxdt <double> Infinite
mindt <double 0.0
target <integer> 8

6.10.2. CFL selection

In this method, the time step size is selected according to the Courant, Friedrich, Levy’s bound (CFL) for explicit methods

keyword Data type Default value
dt <double> 1.0
scaledt <double> 1.0
update <int> 100

6.10.3. Fixed time step

This is the most basic time stepping control in which the user sets the value of the time step and the code keeps it constant during the whole analysis. The syntax of options for this control is

keyword Data type Default value
dt <double> 1.0

It must be noted that if the analysis is nonlinear and IRIS is unable to converge to a solution during a step, the code will exit since, under this control, the time step size can not be modified.

7. Controlling the output

IRIS produces three types of outputs:

  • Log files with information about the progress of the analysis.
  • Postprocessing information for graphical output.
  • Results files with data obtained in the analysis.

7.1. The log files

IRIS generates a few files automaticall. These are

  • iris.log: This is the main log file of the code. IRIS writes here all the information generated at runtime. First, IRIS writes all the information gathered from the input file (the characteristics of the analysis and the parts, the boundary conditions, the loading, materials, etc.). Then it gives information about the progress of the analysis (convergence, errors, etc.). This file is key to understand the sucdess or failure of an analysis.
  • iris.warnings

Every time the code is run, it looks for the files iris.log and iris.warnings in the directory where it is being executed and deletes them if they exist. If, for any reason, the user wants to preserve the log file, IRIS should be run with the flag --save.

7.2. The postprocessing files

IRIS has the ability to dump the results obtained to files that can later be read by specialized postprocessing software. This is accomplished with the command line 

postprocessor, type = [paraview | gmsh ] [, compress = <yes|no>] [, frequency = <double>]
    [smoother = <lumped|leastsquares>] [, result = <keyword>], [, result = <keyword>] [, ...],
    [,elementresult = <keyword>] [,elementresult = <keyword>] [...]

First, the user might select if the format of the postprocessing files is the one required by either Paraview or Gmsh, two programs capable of displaying graphically complex finite element solutions and related ones. The user can select as well if the output files are to be written in compressed (gzipped) format and the frequency in which the code will dump them (by default, they will be written at the end of every solution step).

The postprocessor commands writes to files the values of the degrees of freedom of them. Additionally, the user might want to obtain other results (stresses, heat fluxes, etc.) that are smoothed to the nodes or left (unsmoothed) in the elements. The commands result and elementresult serve this purpose and there can be as many as desired.

7.3. The results files

IRIS allows the user to write results obtained from the solution to text files. The syntax that needs to be employed to generate these reports is: 

logger, variable = [dof | mass | reaction | bodies | stress | gradient | rate | velo | acce | energy | scaling],
    settype = [element | elset | node | nodeset],
    [, nodeset = <string> | body = <string>, setname = <string>]
    [, varlabel = <integer>]
    [, filename = <string>] [, frequency = <double>]
    [, droptol = <double>] [, precision = <integer>]

The command variable selects which information should be dumped in the log file. In case the information is a degree of freedom, the variable label varlabel should be provided. The information will be extracted from a set selected using either a settype/setlabel pair or, alternatively, a named setname from a body. In the latter case the two strings should be provided.

A report will have a default name that will be replaced if a filename is provided. The data will be written to a file at every step of the solution, unless a frequency is indicated. Values smaller than droptol will be written as zero. The precission of the output can be controlled with the option that has that name.

In the case of scaling log files, they record the value in time of a given scaling combination. The syntax is as follows: 

logger, variable = scaling, label = <integer>, [, filename = <string>] [, frequency = <double>]
    [, droptol = <double>] [, precision = <integer>]

and the value of the scaling combination with number label will be output to a file.

7.3.1. Reaction logs

IRIS can save the sum of the reactions on a group of nodes. The syntax for this output file is one of these two: 

logger, variable = reaction, body = <string>, setname = <string> [, <options>]

or 

logger, variable = reaction, nodeset = <string> [, <options>]

8. The makefile











9. Element types





Element types define the equations that are solved by the code. They must select a unique label that will be referenced by the modelpart and the superloading. The syntax for all element types is as follows:






eltype, label = <integer> [, options ...]







We describe next each of the element types as well as their options.







9.1. Type advectiondiffusion





This element type implements the equations of the linear advection-diffusion problem. The options of the type are

















Option
Value type
Explanation






ax
double
\(x\) component of advection





ay
double
\(y\) component of advection





az
double
\(z\) component of advection





supg
 
activate SUPG formulation





gls
 
activate GLS formulation





vms
 
activate VMS formulation





oss
 
activate OSS formulation





heatsupply
double
source term








It is known that the advection-diffusion problem is prone to instabilities and special formulations must be employed to ensure the well-posedness of the discrete problem. In particular, this implementation includes several stabilized methods, more precisely,

















keyword
Name
Reference






supg
Streamline Upwind Petrov Galerkin
(Brooks, A N and Hughes, T. J. R., 1982)





gls
Galerkin Least Squares
(Hughes, T. J. R. and Franca, L. P. and Hulbert, G. M., 1988)





vms
Variational Multiscale
(Hughes, T. J. R. and Feijoo, G. R. and Mazzei, L. and Quincy, J.-B., 1998)





oss
Orthogonal Subgrid Scales
(Codina, R., 2000)












9.2. Type bar






9.3. Type beam







9.4. Type drod







9.5. Type dummy







9.6. Type euler







9.7. Type fmembrane







9.8. Type fpoisson







9.9. Type frod







9.10. Type fshell






9.11. Type fsolid







9.12. Type ftcm







9.13. Type fthermorod







9.14. Type fthermoelerod







9.15. Type ftm







9.16. Type ftmc







9.17. Type fmm







9.18. Type fmechmass







9.19. Type hydrogen







9.20. Type lagfluid







9.21. Type lineardiffusion







9.22. Type macro







9.23. Type mixed





The mixed formulation of small strain solid mechanics provides a stable formulation for incompressible and quasi-incompressible materials, both with simplicial as well as tensor-product elements. As a result of its mixed character every node would have the following degrees of freedom:

















Symbol
Meaning
Dimension






u
Displacement
3





p
Pressure
1








At the moment, the formulation works only for linear tetrahedra and tri-linear hexahedra. The input record is simple and include only the options















Option
Value type






material
integer








The loading for this element type includes volumetric loading and surface loading. Note that pressure should be applied by selecting a value of the pressure variable, not by a loading. The options for the superloading on this element type are






superloading, body = <string>, setname = <string>
    [, fx = <double>] [, fy = <double>] [, fz = <double>]
    [, scaling = <integer>]

superloading, body = <string>, setname = <string>
    [, tx = <double>] [, ty = <double>] [, tz = <double>]
    [, scaling = <integer>]

















label
explanation






fx
force/volume direction x





fy
force/volume direction y





fz
force/volume direction z





tx
force/area direction x





ty
force/area direction y





tz
force/area direction z












9.24. Type navierstokes






9.25. Type nonlineardiffusion






9.26. Type pointmass






9.27. Type poisson





This element type is designed to model continuum thermal problems. It works with stationary as well as transient solutions. The command line can have the following options:















Option
Value type






material
integer





tref
double





lumped
double in \([0,1]\)








The solution to this problem is a temperature increment field but the material properties might depend on the absolute temperature. For this reason a reference temperature might be provided and otherwise set to 0. The element allows to use a high-order mass matrix by combining a consistent mass matrix (\(lumped=0\)), with a completely lumped mass (\(lumped=1\)) or intermediate values.





The only degree of freedom of this element type is indicated as h.





The kind of volumetric and surface heat supply that element accepts is given by the following keywords:






superloading, body = <string>, setname = <string>
    [, q = <double>] [, h = <double>] [, convection = <double>]
    [, radiation = <double>]
    [, scaling = <integer>]

















label
explanation






q
volumetric heat supply





h
surface heat supply





convection
convection coefficient





radiation
radiation coefficient












9.28. Type smm






9.29. Type phasefield






9.30. Type phasefracture






9.31. Type rigidlink






9.32. Type rigidbody






9.33. Type slave






9.34. Type solid





Elements of type solid are designed to model three-dimensional small strain solid mechanics. Currently they work with tetrahera and hexahedra. The following options are available:

















Option
Value type
Explanation






material
integer
 





formulation
string
 





quadpoints
integer
 





alpha
double
Stabilization parameter





epsilon
double
Regularization for Neumann problems








Most element types, although not all, are linked to a material with its label. The formulation can be standard, mixed, stabilized, or bbar. The first one, selected also if the keyword formulation is not included, corresponds to the isoparametric formualation of the primal form of the problem. The second one uses a Q1/P0 interpolation for displacement and pressure and is only available for hexahedra. The third one is a stablized U/P formulation where alpha is the stabilization parameter. The bbar option implements the assumed strain method of Hughes. The degrees of freedom in all the formulation are just the nodal displacements u, except for the stabilized case, that has both displacements u as well as pressures p.















Formulation
Dof






standard
u





mixed
u





stabilized
u,p





bbar
u










Volumetric and surface loading can be applied on solid with the superloading command. In the case of volume loads, the syntax is as follows:





superloading, body = <string>, setname = <string>
    [, fx = <double>] [, fy = <double>] [, fz = <double>]
    [, scaling = <integer>]






If the loads are defined per unit mass, the syntax changes to





superloading, body = <string>, setname = <string>
    [, bx = <double>] [, by = <double>] [, bz = <double>]
    [, scaling = <integer>]






Surface loads can also be applied with the superloading command. The syntax in this case is





superloading, body = <string>, setname = <string>
    [, tx = <double>] [, ty = <double>] [, tz = <double>]
    [, scaling = <integer>]






where tx,ty,tz are the cartesian components of the taraction vector field. Finally, a pressure can be directly applied to a surface with the command





superloading, body = <string>, setname = <string>
    [, pressure = <double>] [, scaling = <integer>]







To sum up, these are the possible superloading options for the solid element:















label
explanation






fx
force/volume direction x





fy
force/volume direction y





fz
force/volume direction z





bx
force/mass direction x





by
force/mass direction y





bz
force/mass direction z





tx
force/area direction x





ty
force/area direction y





tz
force/area direction z





pressure
normal force/area (inwards)












9.35. Type spring






9.36. Type stm





This is the element type for small strain thermomechanical simulations. The degrees of freedom are the corresponding problems are, thus, the displacement u and the temperature m . The mechanical problem can be formulation in standard (isoparametric) form or using the bbar assumed strain form.















Formulation
Dof






standard
u, m





bbar
u, m








Surface and volume loading can be applied on solids describe with stm equations. The syntax is similar to the one of the solid element types but has, additionally, volumetric heating and surface heat flux. The commands for the volumetric loads are:





superloading, body = <string>, setname = <string>
    [, fx = <double>] [, fy = <double>] [, fz = <double>]
    [, bx = <double>] [, by = <double>] [, bz = <double>]
    [, hvol = <double>
    [, scaling = <integer>]






where hvol refers to the supplied heat per unit volume and time. The surface loads are given by





superloading, body = <string>, setname = <string>
    [, tx = <double>] [, ty = <double>] [, tz = <double>]
    [, hsurf = <double>]
    [, pressure = <double>]
    [, scaling = <integer>]






where tx,ty,tz are the cartesian components of the traction vector field, hsurf is the heat flux applied through the surface, and pressure is, as in the solid element type the (inward) pressure.









9.37. Type stokes






9.38. Type taylorhood





This element implements mixed formulation of the Stokes flow. As such, it employs different interpolation spaces for the velocity and pressure fields. Right now, this is provided by both the brick and the qbrick mesh generators, but might be extended in the future. The command line can have the following options:















Option
Value type






material
integer





stabilization
double





bx
body force/mass in x direction





by
body force/mass in y direction





bz
body force/mass in z direction








The formulation uses a weak penalty for the pressure term so that no pressure needs to be imposed to avoid the pressure lack of uniqueness. If the user does not provide a stabilization value, a default small parameter is used.









9.39. Type thermalwire






9.40. Type trlink








10. Material types





Material types select constitutive behaviors from the available models in MUESLI. The syntax of these commands is always of the form:





material, label = <integer>, type = <string> [, options ...]






We summarize next the available material models and the parameters that need to be defined (with defaults)







10.1. Type elastic





This model represents the elastic, isotropic behavior for small strain mechanics.

















Option
Meaning
Default






young
Young’s modulus
0.0





poisson
Poisson’s ratio
0.0





lambda
Lamé parameter
0.0





mu
Lamé parameter
0.0





density
 
1.0





tref
Reference temperature
273.0












10.2. Type splastic





This is the model for small strain elastoplastic behavior

















Option
Meaning
Default






young
Young’s modulus
0.0





poisson
Poisson’s ratio
0.0





lambda
Lamé parameter
0.0





mu
Lamé parameter
0.0





isotropich
Isotrophic hardening par
0.0





kinematich
Kinematic hardening par
0.0





yieldstress
 
0.0





density
 
1.0





model
von_mises or tresca or drucker
von_mises





alphac
drucker’s cone semiangle
0.0





tref
Reference temperature
273.0












10.3. Type conductor





Conductor materials are employed in thermal calculations. More precisely, the condutor defines a Fourier’s type relationship between heat flux and temperature gradient which is isotropic. The options are:

















Option
Meaning
Default






conductivity
(isotropic) conductivity
0.0





capacity
Heat capacity
0.0














11. An input file





We include here, as an example, the quasistatic analysis of the mechanical response of a cube-shaped body.






#
# Analysis file for IRIS
#
# Description: a simple cube
#
# Author: i. romero
# Date:   jul 2006
#

#----------------------------------------------------------------------------
#
#   1 - Basic description of the analysis
#
#----------------------------------------------------------------------------
analysis, type = static, final_time = 1.0
modelpart, type = body, shape = qcube, name = "mycube", eltype = 1, \
  centerx = 0.2, centery = 0.3, centerz = -0.1, \
  lx = 1.1, ly = 0.9, lz = 0.7, \
  rotz = 0.2, roty = 0.1, rotz = -0.3, \
  divx = 5, divy = 4, divz = 5


#----------------------------------------------------------------------------
#
#   2 - Integrator and solver
#
#----------------------------------------------------------------------------
integrator, type = quasistatic
stepsolver, type = newton
linsolver,  type  = pcg
stepping, type = fixed, dt=0.2

superloading, body = mycube, surface = 5, tx = 200.0, ty = 300.00, tz = 400.0





#----------------------------------------------------------------------------
#
#   3 - Element types and materials
#
#----------------------------------------------------------------------------
material, label = 1, type = neohookean, young = 1e4, poisson = 0.3, density = 4241.0
eltype, label = 1, type = fsolid, material = 1



bc, body = mycube, surface = 4, variable=u, ux = 0.0, uy = 0.0, uz = 0.0



#----------------------------------------------------------------------------
#
#  6 - Output data
#
#----------------------------------------------------------------------------
#postprocessor, type = paraview
output, variable = energy











12. A log file





We show in this appendix one example of a log file obtained after running a simulation in IRIS. The file shows, first, the information that the code obtains or generates from the input file. If some aspects of the analysis are not provided, the code supplements the information with default procedures. Then, the output of the analysis is reported illustrating the convergence in the nonlinear procedure.






=============================================================================
|                                                                           |
|                              I    R    I    S                             |
|                                                                           |
=============================================================================

             A general purpose finite element analysis program             

              Copyright Ignacio Romero, ignacio.romero@upm.es              
                      Universidad Politecnica de Madrid                    
                          IMDEA Materials Institute                        
                       version  9.1  (November 2023)



                    R u n t i m e   o p t i o n s                    

   Available threads   : 10
   Activated threads   : 10
   Debug mode          : inactive

   [ Model checked ]
   [ Stepsolver checked ]
   [ Stepsize control checked ]



               A n a l y s i s    i n f o r m a t i o n               

 General properties:
   Name                : cube.iris
   Analysis type       : Quasistatic analysis
   Final time          : 1
   Started on          : Fri Dec 22 15:10:38 2023
   Hostname            : IROMERO.local
   Username            : ignacio



                        S t e p   S o l v e r                        

 Remesh after steps                      : Never
 Newton-Raphson non-linear solver
 Maximum number of iterations allowed    : 10
 Recompute tangent frequency             : 1
 Relative energy error for convergence   : 1e-16
 Absolute value of energy for convergence: 1e-20
 Number of pre-iterations                : 0
 Maximum number of allowed trials        : 4
 Linesearch                              : false



            T i m e   s t e p s i z e   s e l e c t i o n            

 No time step adaptation.
 The first failure in a NR solution will cause the analysis to halt.
 Time step size : 2.000000e-01



        S o l v e r   f o r   l i n e a r   e q u a t i o n s        

 Preconditioned conjugate gradient solver.
 Iterative solver for symmetric positive definte systems.
 Diagonal preconditioner.
 Relative tolerance for convergence = 1.000000e-10
 Absolute tolerance for convergence = 1.000000e-14




                  S c a l i n g   f a c t o r s  (1)                  

 Scaling factor number 0: 1 component(s)
  +linear factor active in (0.000000e+00, infinite]
   initial value = 0.000000e+00,  slope = 1.000000e+00



                      V a r i a b l e    L o g s                      

 Variable logger information
   Var type      : Energy, entropy, and volume.
   In set        : the whole domain.
   Filename      : iris_energy.vlog
   Log frequency : every time step
   Last log time : 0.000000e+00
   Precision     : 4
   Drop tolerance: 1.000000e-08
   Graphic output: none.



                S y s t e m   o f   e q u a t i o n s                

Sparse matrix
    Format                     : Symmetric Compressed Sparse Column (SCSC)
    Number of rows             : 450
    Number of columns          : 450
    Number of profile terms    : 12393
    Band size                  : 42
    Condition number           : 0.000000e+00
    Factorized                 : 0
    Data type                  : double
    Incorrect format (try hb or mm)



                         I n t e g r a t o r                         

 Incremental quasistatic integrator.
 Time is only a parameter to describe the progress of the analysis.



                    E l e m e n t   T y p e s  (1)                    

Element type   1 : FSOLID
 Degrees of freedom:
 Variable name : u, type : vector
 Linked to material with label 1
 Finite strain, deformable solid model.
 Implementation : convected
 Finite strain, standard displacement formulation.



                M a t e r i a l s  (1)

Material #1: 
   Elastic Neo-Hookean material for finite deformation analysis
   Stored energy function:
            W(I1,J) = U(J) + mu/2 ( I1_C - 3) - mu log J
            U(J)    = lambda/2 * (log J)^2

   Young modulus:  E      = 1.000000e+04
   Poisson ratio:  nu     = 3.000000e-01
   Lame constants: Lambda = 5.769231e+03
                   Mu     = 3.846154e+03
   Bulk modulus:   k      = 8.333333e+03
   Density                = 4.241000e+03
   Wave velocities C_p    = 1.781612e+00
                   C_s    = 9.523119e-01




                  M o d e l    i n f o r m a t i o n                  

   Number of bodies           :      1
   Number of raw meshes       :      0
   Number of meshlessbodies   :      0
   Number of control volumes  :      0
   Number of crystals         :      0
   Number of interactions     :      0
   Number of elements         :    100
   Number of evalspots        :      0
   Number of nodes            :    180
   Number of slave nodes      :      0
   Number of elsets           :      0
   Number of nodesets         :      1
   Number of point loads      :      0
   Number of constraints      :      1
   Number of unknowns         :    450
   Max. dofs/node             :      3

   Dofset dictionary: 
     Variable name: u, type: vector



                          B o d i e s   (1)                          

    Body name          : mycube
    Manifold dimension : 3
    Center             : (2.000000e-01, 3.000000e-01, -1.000000e-01)
    Orientation        : (0.000000e+00, 1.000000e-01, -3.000000e-01)
    Number of elements : 100
    Number of nodes    : 180
    Number of spots    : 0
    Type               : Brick with hexahedral elements
    Name               : mycube
    Dimension          : 3
    Subdivisions x     : 5
    Subdivisions y     : 4
    Subdivisions z     : 5
    Length x           : 1.100000e+00
    Length y           : 9.000000e-01
    Length z           : 7.000000e-01
    Center             : 2.0000000000e-01 3.0000000000e-01 -1.0000000000e-01
    Orientation        : 0.0000000000e+00 1.0000000000e-01 -3.0000000000e-01
    distorted          : no

    Named sets of dimension 0:
      vertex0,  vertex1,  vertex2,  vertex3,  vertex4,  
      vertex5,  vertex6,  vertex7,  

    Named sets of dimension 1:
      edge0,  edge1,  edge10,  edge11,  edge2,  
      edge3,  edge4,  edge5,  edge6,  edge7,  
      edge8,  edge9,  

    Named sets of dimension 2:
      surface0,  surface1,  surface2,  surface3,  surface4,  
      surface5,  

    Named sets of dimension 3:
      volume0,  




                       N o d e    S e t s   (1)                       

 Nodeset : a_brick_external_nodes (0 nodes) (internal)



                     C o n s t r a i n t s   (1)                     

 Constraint on a body boundary
 Name of the body   : mycube
 Boundary dimension : 2
 Boundary label     : 4
 Number of nodes    : 30
 variable u[0]      : 0.0000000000e+00
 variable u[1]      : 0.0000000000e+00
 variable u[2]      : 0.0000000000e+00
       scaling      : 0  (default)



                       S u p e r L o a d s  (1)                       

* Loading on body mycube
    Manifold dimension   : 2
    Manifold label       : 5
    Eltype label         : 0
    Scaling factor label : 0
    Number of elements:  : 20




                S t a r t i n g    A n a l y s i s
                ----------------------------------



Solution at (pseudo) time = 2.000000e-01, dt = 2.000000e-01, Step = 1
 Scaling factor 0  = +2.000000e-01
    [ System Size: 450
    [ PCG Iteration 117  , residual: +1.4942e-09, rel: +7.0623e-11, PCG total_time: +1.3e-02
 Opt: -4.6456e+01, Res: 2.1158e+01, EErr: 2.0947e+00 (1.0000e+00), Mflps: 283  
    [ System Size: 450
    [ PCG Iteration 128  , residual: 2.7530e-10, rel: 9.4898e-11, PCG total_time: 1.4e-02
 Opt: -4.7489e+01, Res: 2.9010e+00, EErr: 3.5563e-03 (1.6978e-03), Mflps: 287  
    [ System Size: 450
    [ PCG Iteration 134  , residual: 1.5069e-13, rel: 7.1394e-11, PCG total_time: 1.4e-02
 Opt: -4.7490e+01, Res: 2.1107e-03, EErr: 1.8973e-08 (9.0578e-09), Mflps: 286  
    [ System Size: 450
    [ PCG Iteration 86   , residual: 9.5341e-15, rel: 1.4094e-07, PCG total_time: 9.1e-03
 Opt: -4.7490e+01, Res: 6.7648e-08, EErr: 1.2756e-18 (6.0897e-19), Mflps: 290  

Solution at (pseudo) time = 4.000000e-01, dt = 2.000000e-01, Step = 2
 Scaling factor 0  = +4.000000e-01
    [ System Size: 450
    [ PCG Iteration 131  , residual: +2.1151e-09, rel: +9.9965e-11, PCG total_time: +1.4e-02
 Opt: -9.6002e+01, Res: 2.1158e+01, EErr: 2.0166e+00 (1.0000e+00), Mflps: 285  
    [ System Size: 450
    [ PCG Iteration 126  , residual: 2.3666e-10, rel: 9.2062e-11, PCG total_time: 1.3e-02
 Opt: -9.6996e+01, Res: 2.5707e+00, EErr: 2.9055e-03 (1.4408e-03), Mflps: 286  
    [ System Size: 450
    [ PCG Iteration 131  , residual: 1.6833e-13, rel: 9.5683e-11, PCG total_time: 1.4e-02
 Opt: -9.6998e+01, Res: 1.7592e-03, EErr: 1.2883e-08 (6.3888e-09), Mflps: 286  
    [ System Size: 450
    [ PCG Iteration 84   , residual: 8.1029e-15, rel: 1.8650e-07, PCG total_time: 8.9e-03
 Opt: -9.6998e+01, Res: 4.3447e-08, EErr: 5.3771e-19 (2.6665e-19), Mflps: 288  

Solution at (pseudo) time = 6.000000e-01, dt = 2.000000e-01, Step = 3
 Scaling factor 0  = +6.000000e-01
    [ System Size: 450
    [ PCG Iteration 130  , residual: +2.0613e-09, rel: +9.7422e-11, PCG total_time: +1.4e-02
 Opt: -1.4749e+02, Res: 2.1158e+01, EErr: 1.9449e+00 (1.0000e+00), Mflps: 284  
    [ System Size: 450
    [ PCG Iteration 126  , residual: 2.0611e-10, rel: 9.0541e-11, PCG total_time: 1.4e-02
 Opt: -1.4845e+02, Res: 2.2764e+00, EErr: 2.3792e-03 (1.2233e-03), Mflps: 286  
    [ System Size: 450
    [ PCG Iteration 130  , residual: 1.3530e-13, rel: 9.1245e-11, PCG total_time: 1.4e-02
 Opt: -1.4845e+02, Res: 1.4828e-03, EErr: 8.7881e-09 (4.5186e-09), Mflps: 287  
    [ System Size: 450
    [ PCG Iteration 80   , residual: 9.6738e-15, rel: 3.4211e-07, PCG total_time: 8.5e-03
 Opt: -1.4845e+02, Res: 2.8277e-08, EErr: 2.3287e-19 (1.1973e-19), Mflps: 288  

Solution at (pseudo) time = 8.000000e-01, dt = 2.000000e-01, Step = 4
 Scaling factor 0  = +8.000000e-01
    [ System Size: 450
    [ PCG Iteration 130  , residual: +1.5216e-09, rel: +7.1918e-11, PCG total_time: +1.4e-02
 Opt: -2.0085e+02, Res: 2.1158e+01, EErr: 1.8792e+00 (1.0000e+00), Mflps: 284  
    [ System Size: 450
    [ PCG Iteration 125  , residual: 1.9420e-10, rel: 9.6413e-11, PCG total_time: 1.4e-02
 Opt: -2.0178e+02, Res: 2.0143e+00, EErr: 1.9528e-03 (1.0391e-03), Mflps: 284  
    [ System Size: 450
    [ PCG Iteration 130  , residual: 1.1979e-13, rel: 9.4827e-11, PCG total_time: 1.4e-02
 Opt: -2.0178e+02, Res: 1.2632e-03, EErr: 6.0123e-09 (3.1994e-09), Mflps: 286  
    [ System Size: 450
    [ PCG Iteration 79   , residual: 8.5411e-15, rel: 4.5973e-07, PCG total_time: 8.4e-03
 Opt: -2.0178e+02, Res: 1.8578e-08, EErr: 1.0305e-19 (5.4839e-20), Mflps: 289  

Solution at (pseudo) time = 1.000000e+00, dt = 2.000000e-01, Step = 5
 Scaling factor 0  = +1.000000e+00
    [ System Size: 450
    [ PCG Iteration 129  , residual: +1.9586e-09, rel: +9.2570e-11, PCG total_time: +1.4e-02
 Opt: -2.5604e+02, Res: 2.1158e+01, EErr: 1.8192e+00 (1.0000e+00), Mflps: 284  
    [ System Size: 450
    [ PCG Iteration 124  , residual: 1.6665e-10, rel: 9.3584e-11, PCG total_time: 1.3e-02
 Opt: -2.5693e+02, Res: 1.7808e+00, EErr: 1.6067e-03 (8.8318e-04), Mflps: 284  
    [ System Size: 450
    [ PCG Iteration 130  , residual: 9.4280e-14, rel: 8.6776e-11, PCG total_time: 1.4e-02
 Opt: -2.5694e+02, Res: 1.0865e-03, EErr: 4.1197e-09 (2.2645e-09), Mflps: 286  
    [ System Size: 450
    [ PCG Iteration 78   , residual: 8.6368e-15, rel: 7.0408e-07, PCG total_time: 8.3e-03
 Opt: -2.5694e+02, Res: 1.2267e-08, EErr: 4.6308e-20 (2.5455e-20), Mflps: 287  


 End of computations.
 Analysis finished correctly.



-----------------------------------------------------------------------------
                 Solver report
-----------------------------------------------------------------------------

 Total number of solution steps  : 5
 Total time in solver            : 0
 Total number of iterations      : 20
 Total number of solution steps  : 5
 Average iterations/step         : 4
 Setup time (wall)               : 0.000 seconds
 Preprocess time (wall)          : 0.010 seconds
 Parsing time                    : 0.000 seconds
 Postprocessing time (wall | CPU): 0.000 seconds ||0.000 seconds
 Solution time (wall | CPU)      : 0.263 seconds (71.9%) || 0.263 seconds
 Assembler time (wall | CPU)     : 0.1 seconds (23.0%) || 0.085 seconds
 Total wall time                 : 0.366 seconds

 Analysis finished on Fri Dec 22 15:10:39 2023











13. Bibliography





Brooks, A N and Hughes, T. J. R. (1982). Streamline upwind/Petrov-Galerkin formulations for convection dominated flows with particular emphasis in the incompressible Navier-Stokes equations, Computer Methods in Applied Mechanics and Engineering.




Codina, R. (2000). Stabilization of incompressibility and convection through orthogonal sub-scales in finite element methods, Computer Methods in Applied Mechanics and Engineering.




Hilber, H. M. and Hughes, T. J. R. and Taylor, R. L. (1977). Improved numerical dissipation for time integration algorithms in structural dynamics.




Hughes, T. J. R. and Feijoo, G. R. and Mazzei, L. and Quincy, J.-B. (1998). The variational multiscale method — a paradigm for computational mechanics, Computer Methods in Applied Mechanics and Engineering.




Hughes, T. J. R. and Franca, L. P. and Hulbert, G. M. (1988). A new finite element formulation for computational fluid mechanics: VIII. The Galerkin/Least-Squares method for advective-diffusive equations, Computer Methods in Applied Mechanics and Engineering.




Newmark, N M. (1956). A method of computation for structural dynamics, Journal of the Engineering Mechanics division. ASCE.










Date: 19-01-2024


Author: Ignacio Romero


Created: 2026-03-08 Sun 12:32


Validate