FOR THOSE WHO ARE CURIOUS ABOUT SCIENCE & ENGINEERING

Menu

Tag Archives:
FEA

Predicting material failure is always a challenge, especially when it comes to composites and advanced materials. There are plenty of theories that try to provide a numerical approach to solve this complex problem, such as Maximum Stress/Strain Theories, Hashin, Tsai-Hill or Tsai-Wu. Although all of them brought something valuable to the table, some of them don’t seem to be that precise when accurate results are needed. In these terms, Tsai-Wu is my least favourite criterion and I’ll explain the reasons for that.

First of all, Tsai-Wu is an interactive failure criterion for composite materials. This means that the theory takes into account the interaction of different stress components in order to predict failure. Basically, the criterion uses equation 1 (subjected to the condition given by equation 2) to calculate an index and, if its value is one, then it means the material is failing. Please note that i,j=1,2,…,6, where subindices 1 to 3 represent normal stress components and 4 to 6 are shear stress components. In the original publication, authors explain how the different coefficient can be determined through experimental tests (e.g. compression, tension, biaxial…). So far, so good.

Equation 1

Equation 2

Problems start when people adapt this approach to introduce failure in Finite Element (FE) analyses. This theory does not include any damage evolution, so if you define failure as soon as the index reaches 1, then elements will be deleted from the model straight away. To be fair, if you are just trying to get estimations for composites, this is not that bad, since they are supposed to fail as soon as they reach a certain level of stress. The main issue is when users use this interactive failure criterion for other materials. For example, for a three dimensional case, equation 1 can be rewritten as follows:

Equation 3

Now consider a material which has similar strengths in the 3-principal axes and assume that the positive and negative shear strengths are equal. Then, using the expressions from equation 4 (where the parameters represent the tensile, compressive and shear strengths), we know that: F1=F2=F3; F11=F22=F33; F4=F5=F6=0; F44=F55=F66.

Equation 4

There are an infinite number of ways to determine the interactive coefficients so, how do we solve this problem? Some people suggests biaxial tests but another effective way to overcome this issue is to make the following assumption (as suggested in literature):

Equation 5

Firstly, this assumption satisfies the stability condition (equation 2) and secondly, it proves to be quite satisfactory for composite materials. Generalising this idea, we find the following:

Equation 6

Okay, so now consider that our material exhibits an elastic-perfectly plastic behaviour in compression. This would mean that the specimen should keep deforming under constant load after the yield (or maximum) compressive stress was reached. Hence, the criterion would predict failure once that value was reached, and no plastification prior to failure would be considered. For instance, consider uniaxial compression once the yield stress is reached, as shown in Figure 1:

Figure 1

Using all the equations which were introduced before, we have:

Equation 7

Therefore, in FEA elements would be deleted after that point, whereas in reality we would expect the material to keep deforming. That being said, more problems appear in cases where the structure is subjected to mixed loading conditions, since the criterion would then predict premature failure.

This post does not intend to state categorically that this theory is useless, that is not what I mean at all! But lately I have seen companies offering FE services using this type of approach, not taking into account that the material under consideration might not be compatible with the assumptions made for this criterion. I just needed to highlight this bad practice that I’ve noticed, so sorry if I’ve offended anyone!

If you are an advanced Abaqus user, I am sure you have heard a word which some people try to avoid at all costs: subroutines. Today, I write about them as well as about my recent experience coding one for my research.

First of all, lets start with the main question: what is a subroutine? It is a script that, when run in parallel with the Finite Element (FE) model, allows users to request features which are not defined by default in the commercial software Abaqus. This FE package recognises a lot of different types of subroutines for both implicit and explicit simulations, depending on the information that we want to include, recalculate, modify, request… In other words, subroutines are useful when we want something that is not already available within the software and we need it in order to produce acceptable results.

Consider, for instance, that we were trying to simulate the response of a certain material, but the material model which was available in Abaqus did not quite reproduce the correct behaviour. What could we do then? The first option would be to contact Dassault Systemes to ask if they had any kind of expansion (with its corresponding extra cost, not too many things are given for free these days I’m afraid); sometimes, since a lot of users request the same thing, it is the company itself the one that creates the official subroutine. This option would save time and effort, but it would also affect our wallet. The second option would be to create a new material model from scratch. How could we do that? Well, we would need to code a UMAT (implicit) or a VUMAT (explicit) subroutine. In order to do so, we would need to learn how to code in Fortran, which is the only language supported by Abaqus (I know, this is a bit of a pain since Fortran is basically obsolete, but hey! It’s always good to learn something new!). We would also need to install two compilers and link them to the FE package, which once again is not straight forward (don’t worry, I’ll try to write another post to explain this). Some people might say that giving up would be the third option, but to me that attitude would be unacceptable, so don’t you dare!Read more

If you are a regular Abaqus user, I am sure that eventually you will need to run models for long periods of time. It can be quite annoying to go back to the office just to check if the simulation has finished to then find out that it is still running. For that reason, I’ve coded a simple python script that sends an automatic e-mail to the user once the simulation is completed or aborts due to errors.

While you run FE models that take a huge amount of computational time to finish, it is likely that you will be working on other things, such as experimental tests, reports, meetings and so on. Obviously, we want to check our results as soon as they are ready, but in order to do so we need to be checking our computer every now and then. This can be particularly annoying when you leave a simulation running for a few days and you are doing things out of the office. Hence you need to go and check if the model is done… and then you realise it’s still there, calculating more stresses and strains and that your trip to the office was a waste of time. To overcome this problem, I decided to create a python script to send a notification directly to my e-mail every time my analyses finish. I will try to explain you the basics so you can use this code on your computer.Read more

Basically, when we want to determine the forces and displacements in a certain structure using Finite Element Analysis (FEA), what we are doing is creating a system of equations that relates the stiffness of the elements to the displacements and forces in each node. When we run a simulation, we do not see all the calculations. For that reason, today I want to illustrate a simple case that can be easily solved by hand applying that methodology.

Before getting started, just think of a spring. Everyone has come across the Hooke’s law at a certain point during school. It states that the force in the spring is proportional to a constant “k” multiplied by the variation in length of the spring. FEA follows the same principle, but in this case the “k” constant is the stiffness matrix and the variation in length is a vector of displacements and rotations, depending on the case.

Let’s study a simple static case. Our structure consists of two bar elements connected at a common node, where a load “P” is applied. The other two nodes have both horizontal and vertical displacements constrained (see the boundary conditions). For this particular case, the reactions in nodes 1 and 3 and the displacements of node 2 are requested. I have solved the problem by hand following a few steps that, based on my experience, can be generalised for more complex problems. Pretty much, the summary of the methodology is:Read more

The FEA dictionary is back and it’s time for letter D! Today I will introduce you to one of the methods to introduce damage in your material models.

Although it was created based on the failure of metals, this damage model can be used to introduce the degradation of mechanical properties for other types of materials. This option is available in Abaqus/Standard and Abaqus/Explicit and it requires the definition of the ideal elastic-plastic behaviour of the material, a damage initiation criterion and a damage evolution response. Please note that if any of the requirements cited before is not defined, the material properties will not be degraded.

In Abaqus there are different options for the damage initiation criterion and basically they can be classified as follows:

As I promised a few weeks ago, I’m back with a tutorial! In this occasion, a cantilever beam will be modelled in Abaqus/Standard. What is more, the importance of defining a good mesh (not only the element size matters!) will be illustrated with several examples.

So, first things first. A cantilever beam is a structure which has one of its ends fully constrained. This means that all degrees of freedom are restricted. An example is presented in the following figure:

A similar case as the one presented above will be modelled using the Finite Element package Abaqus/Standard. The structure can be created using different types of elements: beam, bar, solid or shell. I have decided to model it using shell elements, since it will allow me to show the influence of the element size and type in a very simple way.

In order to create the component we need to be in the Part module. We should select the 3D deformable shell(planar) option. Then we will be able to create the geometry. In this case a simple rectangle of 20mm x 100mm will be enough. Please bear in mind that Finite Element codes are unitless and all the parameters need to be defined in a consistent system of units. I have decided to use mm, GPa and kN.

New post about FEA! In this occasion, I bring you some theoretical background for two types of elements which are very useful for modelling certain structures: bars and beams.

Let’s start from the beginning. A bar is basically an element which can resist only axial loading. Therefore each of its nodes has one degree of freedom, i.e. a displacement along the longitudinal axis of the element. On the other hand, each node of a beam presents not only one but three degrees of freedom: displacement in the longitudinal axis, displacement in the transverse direction and rotation.

As you should already know, Finite Element Analysis requires the a stiffness matrix (K) so, in order to illustrate this, in this post I will show you how the K matrix can be derived for bar elements. Note that the process for obtaining the stiffness matrix of a beam element is similar but a bit more tedious.