### UMAT Subroutine (VUMAT Subroutine) introduction

[optin-monster slug="khin3hlh6o8vag5wx9gj" followrules="true"]This package is usable when the material model is not available in ABAQUS software. If you follow this tutorial package, including standard and explicit solver, you will have the ability to write, debug and verify your subroutine based on customized material to use this in complex structures. These lectures are an introduction to write advanced UMAT and VUMAT subroutines in hyperelastic Martials, Composites and Metal and so on.

**Watch Demo**

### Advanced UMAT Subroutine (VUMAT Subroutine) – Abaqus UMAT tutorial

**Watch Demo**

### 3D continuum Abaqus HASHIN progressive Damage for composite materials (VUMAT Subroutine)

### UMAT Subroutine (VUMAT Subroutine) in ABAQUS-Free Version- UMAT Abaqus example

"**UMAT Subroutine (VUMAT Subroutine) introduction"** is used when the material model is not available in ABAQUS software. If you follow this tutorial package, including standard and explicit solver, you will have the ability to write, debug and verify your subroutine based on customized material to use this in complex structures. These lectures are the introduction to writing advanced UMAT and VUMAT subroutines in hyperelastic Martials, Composites, and Metal, and so on. **Watch Demo**

**"Advanced UMAT Subroutine (VUMAT Subroutine)"**training package helps Abaqus users to prepare complex UMAT and VUMAT subroutines. This training package is suitable for those who are familiar with subroutine or want to learn UMAT/VUMAT subroutine Professionally. Equations for computational plasticity based on kinematic stiffness are also discussed. In addition, metal damage has been implemented based on Johnson Cook's model.

**Watch Demo**

**UMAT Subroutine (VUMAT Subroutine) introduction**

+160 min Video tutorial

-Standard and explicit solver

-workshops: hyperelastic Martials, Composites, Metal

-Language: English

**Advanced UMAT Subroutine (VUMAT Subroutine)**

+140 min Video tutorial

-Standard and explicit solver

-damage in non-metallic materials such as composites and adhesives

-English subtitle

**3D continuum HASHIN progressive Damage for composite**

+160 min. Video tutorial

-Hashin damage initiation, gradual progressive damage based on the energy method

-usable for static and dynamic problems

**UMAT Subroutine in ABAQUS / Free Version**

+60 min Video tutorial

-Basics of writing UMAT

– Workshop: Writing UMAT for Non-Isothermal Elasticity

– Language: English

## Start writing your 1st Abaqus UMAT

Here our focus is on UMAT Abaqus or Abaqus Umat subroutine, an advanced subroutine we use to include desired material behavior in simulations. However, the use of the UMAT subroutine generally requires considerable expertise.

In this step-by-step guide, I just want to show how to get started with using/writing a UMAT in Abaqus by one of the simplest possible examples for this purpose, an elastic material.

First, I strongly recommend reading this article first to get familiar with the process of writing a subroutine in Abaqus:

Start Writing a Subroutine in Abaqus: Basics and Recommendations

UMAT stands for User MATerial. Remember, we use UMAT when none of the existing material models included in the ABAQUS material library accurately represents the behavior of the material to be modeled.

**What does the UMAT Abaqus do?**

Obviously, the philosophy behind the UMAT Abaqus subroutine is that the material model developer should be concerned only with the development of the material model and not the development and maintenance of the FE model.

Referring to the article How to start writing a subroutine (Section 3), you can see we use a UMAT in the stress calculation step.

So, the main output of a UMAT subroutine is the stress tensor. In the process, Abaqus also need to define the (consistent) Jacobian to continue its incremental scheme.

(Since we assumed this is the first time you start writing a UMAT, we start from the simplest one and present our step-by-step example in a pure elastic material, precisely called an isotropic linear elastic material model. For more advanced material models (plasticity, failure, element removal, brittle materials, etc.) I refer you to UMAT Subroutine (VUMAT Subroutine) introduction package)

**NOTE**: Although this article will help you to start writing UMAT Abaqus, this subroutine is a little complicated and based on our feedback from hundreds of students and researchers during the last 3 years, **UMAT Subroutine (VUMAT Subroutine) introduction **training package has saved a lot of time when writing UMAT in Abaqus, and prepared codes in this package without any bugs or errors can speed up your UMAT writing for simulation.

#### What is the use of the UMAT subroutine?

UMAT stands for User Material. We use User Material when none of the existing material models included in the ABAQUS material library accurately represents the behavior of the material to be modeled. We use a UMAT in the stress calculation step to obtain the stress tensor. In the process, Abaqus also need to define the (consistent) Jacobian to continue its incremental scheme.

#### What steps should be taken to prepare the UMAT subroutine?

Generally, to write a newly developed UMAT, you should first master all the aspects of the constitutive model for your material. Then, get Familiar with UMAT Abaqus parameters (Inputs/Outputs). In the next step, develop and implement the FORTRAN code of the UMAT in Abaqus. At last, the UMAT subroutine should be tested and debugged to find accurate UMAT results.

#### What kind of parameters are there in a UMAT subroutine?

All parameters for a UMAT are divided into 4 distinguished groups:

Parameters that are available by Abaqus like STRESS, STRAN, DSTRAN, TIME, and DTIME.

Parameters that are calculated and updated by UMAT, like STRESS and DDSDDE.

Parameters are entered through the Abaqus model definition and sent to UMAT. These parameters are indicated by PROPS.

Solution-Dependent State Variables Parameters that require to be stored. These parameters are indicated by PROPS STATEV.

#### How can I use a UMAT subroutine in Abaqus/CAE?

After normally defining your FEM model in Abaqus/CAE, you need to define a User Material in the Property module. Then, Type under Mechanical Constants the values you want to pass into written UMAT to define inputs. These values will then be accessible through UMAT via the **PROPS** array (PROPS(1), PROPS(2),…). After that, if the mechanical constitutive model needs the storage of solution-dependent state variables, select the required quantity in the number of SDV. At last, Give the Path of UMAT to Abaqus.

#### How can we verify the results of UMAT?

Always start verifying the UMAT with a small model to study quality in the developed material model. You can run a couple of examples to verify the compiled UMAT in Abaqus and compare the results against analytical, experiment or semi-analytical (predicted) results.

Generally, to write a newly developed UMAT, you should follow these steps:

**1. Knowing well the material model theory for our UMAT Abaqus**

You should master all the aspects of the constitutive model for your material. In this step, the material model is represented in concise mathematical equations.

### EXAMPLE: Isotropic Linear Elastic Material (Theory)

**Isotropic** simply means the properties of the material are same in all directions. And, **Elastic** simply means that when the material is unloaded, it will return to its original (undeformed) state. In addition, **Linear** means that the relation between mechanical load and deformation of a material can be described by **Hooke’s law**. In a stress-strain literature we can state Hook’s law as:

**Stress = [Constant] × Strain**

For our case (isotropic linear elastic material), we need two independent material parameters to define the state:

**1.** Constant that measures the resistance in the direction of load **»** **Young’s modulus** (**E**)

**2.** Constant measures how much the material is dragged sideways for a vertical (perpendicular) load **»** **Poisson’s ratio** (** v**).

Eventually, Hooke’s law in the form of these two elastic constants is,

And that is enough for writing our simple subroutine. The matrix **C** is the proportional factor that convert strain to stress. It is called stiffness matrix, i.e. how the material resists deformation.

You can see more details about the theory and equations in Workshop 1: Writing UMAT Subroutine for Isotropic Isothermal Elasticity of our UMAT training package:

**2. ****Getting Familiar with UMAT Abaqus parameters (Inputs/Outputs)**

We should restate our material model in UMAT language. So, you need to understand parameters name and their structures (are they scalar, vector or matrix? their dimension?).

As we talked in the article How to start writing a subroutine, the first step in writing any subroutine will be referring to the Abaqus Documentation. Therefore, you should find the UMAT section and review the guide to have a know-how of UMAT parameters.

Here, in a most general way, I sort all parameters for a UMAT in 4 distinguished groups:

**A.** Parameters that are available by Abaqus to our UMAT

You can see all the parameters passed into UMAT in the documentation. The most important and practical ones are:

**Reminder ………………………………………………………………………………………………………………………….**

In FORTRAN, we define **scalars** as single names, like ALPHA, SDV, etc. **Vectors** are defined by a name and their dimensions, like DMGQ(3), STRE(5), etc. For 2D **matrices**, the No. of rows and columns should be clarified when defining these variables: STRM(6,6), DDSDDL (4,4), …

**…………………………………………………………………………………………………………………………………………**

#### 1) NTENS

This is the size of the stress or strain component array and reflects the overall dimension of the Abaqus model into UMAT. For example, that is 6 for a general 3D and 4 for a simplified plane strain (2D) model.

In the stress and strain arrays and in the DDSDDE (discuss soon), direct components are stored first, followed by shear components. There are NDI direct and NSHR engineering shear components. So,

**NTENS = NDI + NSHR**

#### 2) STRESS(NTENS)

A vector form of stress tensor at the start of increment.

It has NTENS elements. For a general 3D model, we need 6 values for stress (3 normal and 3 shear) so this vector will have 6 elements.

#### 3) STRAN(NTENS), DSTRAN(NTENS)

STRAN is a vector form of strain tensor at the start of increment. DSTRAN is the increment (variation) of strain ( ).

#### 4) TIME(2), DTIME

Respectively, total and incremental values of time. TIME is a 2-element vector; the first element, i.e. TIME(1) states the value of step time and the second, i.e. TIME(2), is the value of total time, both at the beginning of the current increment.

**Note.** There are many other variables that Abaqus pass into UMAT and are not discussed here, like **COORDS** (An array containing the coordinates of the point of calculation). According to your material, you may need to use them either. For example, if you are working on a FGM (Functionally Graded Material: material whose properties change gradually with respect to its dimensions) you need to use COORDS(3) parameter too.

Ok, guys, here in the following video, you can see some basics about writing UMAT Abaqus in the first lesson of the UMAT subroutine video training package; do not miss this useful 25-minutes video:

It seems you have enjoyed the video; if you want to see more chapters of this training package, you can check and click on the Umat subroutine introduction (VUMAT Subroutine).

### B. Parameters must be calculated and updated by UMAT Abaqus (outputs)

In a simple UMAT, these parameters are

**1)** STRESS(NTENS)

A vector form of stress tensor with **NTENS** elements. The dimension (NTENS) comes from the dimension of the model. For a general 3D model, we need 6 values for stress (3 normal and 3 shear) so this vector will have 6 elements.

At the first, **STRESS** is the stress tensor at the beginning of the increment. Then, we update it as the stress tensor at the end of the increment.

#### 2) DDSDDE(NTENS,NTENS)

A 2D format of **Jacobian** matrix with **NTENS** row and **NTENS** column.

For small-deformation problems (e.g., linear elasticity) or large-deformation problems with small volume changes (e.g., metal plasticity), the consistent Jacobian can be calculated as:

Where, **∆σ** is the increment in (Cauchy) stress and **∆ε** is the increment in strain.

As you may guess, calculation of the consistent Jacobian can be the main challenge in writing a UMAT.

**Note. **There are other variables that Abaqus can get from a UMAT and we did not discuss here, like **RPL** (Volumetric heat generation caused by mechanical working in a thermo-mechanical material model). According to your material you may need to use them either.

### C. Parameters entered through Abaqus model definition & sent to UMAT

**PROPS (NPROPS)**

User-specified array of material constants associated with this user material with **NPROPS** (number of material constants) elements.

When defining our model through Abaqus/CAE, we enter these parameters in Property module (we will discuss more, later).

### D. Parameters defined by user that is needed in next increments or we want Abaqus to save their values and later can be seen in results

**STATEV(NSTATV)**

An array containing the **Solution-Dependent state Variables** (**SDV**). Abaqus pass in these parameters as the values at the beginning of the increment and at the end, return them as the values at the end of the increment. **NSTATV** (number of solution-dependent state variables associating with this material type) define the size of the array.

We should specify the number of needed state variable (if any) when defining our model through Abaqus/CAE in Property module (we will discuss more, later).

After completing the analysis, Abaqus can visualize the values of state variables (named as SDV1, SDV2, … in Abaqus/CAE) calculated during increments.

### EXAMPLE: Isotropic Linear Elastic Material (Required Outputs/inputs)

Here we will only use **DDSDDE**, **STRESS** and **STRAN**. The STRAN matrix is an input to the UMAT. Then, UMAT updates the STRESS matrix (using DDSDDE and STRAN matrices) and returns it as an output.

In this simple problem, we can easily find Jacobian from elastic stress-strain relation:

So, here we can use a single notation and use Jacobian or DDSDDE matrix to find STRESS too.

In addition, we use PROPS(1) and PROPS(2) as Young’s modulus I and Poisson’s ratio (*v*), respectively. For that, we will enter the values when defining the material in Abaqus/CAE later. See figure **4. Implementation in Abaqus & Compilation**.

Ok, the main parameters of input and output of UMAT subroutine is introduced now, but there are lots of points to writing a correct and complete UMAT subroutine; especially if you need to write a VUMAT, take a look at our comprehensive training package for UMAT/VUMAT:

**3. Developing FORTRAN code of the UMAT in Abaqus**

In this step, the theoretical model for our material is implemented in Fortran. We will pass the .for file generated in the next step to Abaqus to be compiled and then used in Abaqus/Standard analysis.

As we explained before, in **How to start writing subroutines…,** the header part of UMAT in Abaqus, which is a template from documentation, remains unchanged. We need to define our main outputs (STRESS, DDSDDE Abaqus) or any other mandatory outputs for the considered material model.

### EXAMPLE: Isotropic Linear Elastic Material (Fortran code) – DDSDDE Abaqus

In this material model UMAT, we just define elements of DDSDDE Abaqus and calculate STRESS elements using STRAND and DDSDDE Abaqus:

This piece of code will replace the “*user coding to define* DDSDDE, STRESS,…” part of the template from the documentation. See the article How to start writing subroutines (Section 5) again.

You can download the complete UMAT file to check by yourself from here.

Save this UMAT. The path to this file will be later entered in the **Abaqus Job** settings.

**4. Implementation in Abaqus & Compilation**

After successfully developing the UMAT, the code must be incorporated into Abaqus to correctly compile a working Abaqus analysis. When defining the Abaqus job, you can add the developed UMAT. After Submitting the job, the UMAT will be compiled into a working executable by Abaqus automatically and can then be used to run the FEA simulation. After normally defining your FEM model in Abaqus/CAE, generally, you need to pass 4 more steps within Abaqus/CAE to incorporate a UMAT in your analysis:

### i. Define a User Material

Say Abaqus that you will use a UMAT as a material model. You can also use other material models of Abaqus if there is no intervention. For example, you can use Abaqus’s own model for elasticity but develop a UMAT to model a very specific plasticity model.

From **Property** module, when defining a material, from **General** tab select **User Material**. That is all you should do.

### ii. Define inputs (Mechanical Constants) for UMAT in Abaqus

When you select **User Material** as a material model for your problem, you can add as many constants as you wish in **Data** section. Type under **Mechanical Constants** the values you want to pass into written UMAT. After entering any data, you can press Enter to add a new row. These values then will be accessible through UMAT via **PROPS** array (PROPS(1), PROPS(2),…).

**NOTE**: Before continuing to the third part, it is necessary to know the content of our main package of **UMAT subroutine (VUMAT Subroutine) introduction** that is the main reference of this article; lots of students and researchers get this package and write their UMAT easily:

### iii. Define the No. of state variables

Many mechanical constitutive models may require the storage of **Solution-Dependent** state **Variables (SDV) **such as plastic strains, back stress, saturation values, etc. in rate constitutive forms or historical data for theories written in integral form. You should allocate storage for these variables in the associated material definition. There is no restriction on the number of state variables.

The number of such variables required at the points is entered as part of the material definition. In Abaqus/CAE, Property module when defining a material, from **General** tab select **Depvar.** Then select the required quantity in** Number of solution-dependent state variables.**

State variables can be output to the output database (**.odb**) file using output identifiers **SDV**. You can ask Abaqus to visualize them later after completion of the job. In **Step module**, after defining your analysis type, from **Field Output Manager**, you can edit the **F-Output-1** created automatically by Abaqus:

Remember that the **SDV** in **Abaqus/CAE** is exactly the same as **STATEV** in **Abaqus Subroutine Interface**. That is just a difference in naming by developers of Abaqus.

iv. Give the Path of UMAT to Abaqus

Like any other subroutine, when creating an Abaqus job, you should provide the path of UMAT to Abaqus. You can include one or more UMATs in a model by specifying the name of a Fortran source file that contains the subroutines.

### EXAMPLE: Isotropic Linear Elastic Material (Implementation)

As we will discuss in section 6 (**Examining UMAT results**), at first, we start from a very simple model like simple tension (displacement-based) on one-element mode. After building our FEM model in Abaqus/CAE like any other model without UMAT, we should (we do not need any state variable in this simple UMAT):

**1.** Define a User Material from the Property module

**2.** Define two Mechanical Constants as inputs for our elastic model UMAT: E and Nu

**3.** Give the Path of our written UMAT to Abaqus when defining the job.

**5. Testing and debugging UMAT subroutine**

Keep in mind that writing a UMAT in Abaqus is exactly like developing a piece of code in Fortran. So, when you finish typing your code, the main task starts! After the first run, you may encounter compiling errors, complaining by compiler about structures and so on. Be patient; this is really normal even for experienced UMAT developers.

When you are facing an error and you are not sure about the cause, in a most easygoing manner, you can check the values by using ** write** command to write the variable values into

**.msg**file. We will discuss most important Fortran commands that are really handy when writing a UMAT (and also any subroutine) in an article later.

**6. Examining UMAT results and verification **

In this step, we will verify the compiled UMAT in Abaqus by running a couple of examples and compare the results against analytical, experiment or semi-analytical (predicted) results. UMAT verification is a crucial step in any UMAT development in order to guarantee a high level of confidence and quality in the developed material model.

Always start verifying the UMAT with a small (one element) model.

**1.** Run tests with all displacements prescribed to verify the integration algorithm for stresses and state variables (if any).

Suggested tests include:

**»** Uniaxial tensile/compressional test

**»** Biaxial/triaxial in two/three direction especially when anisotropy is present.

**»** Simple shear test

**2.** Run similar tests with load prescribed to verify the accuracy of the Jacobian.

**3.** Compare test results with analytical solutions or standard ABAQUS material models, if possible. If the above verification is successful, apply to more complicated problems.

### EXAMPLE: Isotropic Linear Elastic Material (Verification)

This very simple UMAT yields exactly the same results as the Abaqus elastic model. So, we can verify our subroutine by comparing the results with Abaqus results from the native elastic model.

For example, we can check simple tension, simple shear and then run a more complicated 3D model and compare the results.

This simple UMAT can be used in **3D** and **plane strain** models. It is usually straightforward to write a single routine that handles (**generalized**) **plane strain**, **axisymmetric**, and **three-dimensional** geometries. Generally, **plane stress** must be treated as a separate case because the stiffness coefficients are different.

**Your Turn!**

**1)** Try to develop a simple elastic UMAT like what we discussed for **3D** and **PE** (**plane strain) **models for an isotropic **PS** (**plane stress**) model. Follow exactly the steps.

You can find the theory in any basic **Continuum** or **Elasticity** reference books. Lazier to refer to books? Take a look at Abaqus documentation (Linear elastic behavior: Defining orthotropic elasticity in plane stress).

**2) **Combine two UMAT (**3D, PE** + **PS**) into one single Fortran file. Test it with PE and PS models in Abaqus.

**Tip:** Refer to the explanation beneath NTENS parameter in **2. ****Getting Familiar with UMAT Abaqus parameters (Inputs/Outputs)**. Try to use an ** IF structure** to ask Abaqus whether it is a plane stress problem or not.

If you are looking for more information about UMAT or you need to write a VUMAT, take a look at our comprehensive training package for UMAT/VUMAT:

If you have any questions about writing UMAT in Abaqus, comment here below, or are interested in this article, please share your idea in the comments.

Get the first part of this Article as a PDF: Start writing your 1st UMAT Abaqus

Get the second part of this article as a PDF: start writing your 1st-umat in abaqus construction

## References:

Tutorial: Write a simple UMAT in ABAQUS

Excellent article! We will be linking to this particularly great article on our website. Keep up the great writing. Kanya Waite Longo

Really informative blog article. Really thank you! Cool. Kattie Lorenzo Harwin

You made some nice points there. I looked on the internet for the subject matter and found most individuals will agree with your site.

Hello! I could have sworn I’ve been to this blog before but after browsing through some of the post I realized it’s new to me. Anyways, I’m definitely happy I found it and I’ll be book-marking and checking back frequently!

i like this fabulous article

Simply want to say your article is as astounding. The clearness to your post is

simply spectacular and i could think you’re an expert on this subject.

Fine with your permission allow me to grasp your

feed to stay up to date with approaching post. Thank you 1,000,000 and please carry on the

rewarding work.

i like this best suited article

I believe you have mentioned some very interesting points, thanks for the post.

If you wish for to grow your familiarity simply keep visiting this web page and be updated with the hottest news posted here.

Hello! I could have sworn I’ve been to this blog before but after browsing through some of the post I realized it’s new to me. Anyways, I’m definitely happy I found it and I’ll be book-marking and checking back frequently!

Thanks for finally talking about > Start Writing Your 1st UMAT for Abaqus (PART A:

Foundation) < Loved it!

I read a great article with pleasure, I hope it will continue