Displacement-controlled bending with Abaqus

A few days ago I got a question from an Abaqus user on how to define a certain problem. At first it seemed like a basic task, but when thinking about it I realized, that it is not that obvious and that there are multiple things that could be done wrong. So after helping the user I’ve decided to create this post/article, where I explain the problem, what good and bad solutions are and why.

Even when you never face the exact same task, you will probably learn some things about how Abaqus works with this post. And as a bonus I will give you a performance tip at the end, that the majority of the Abaqus users aren’t even aware of, but that can have a massive effect.

So what is the problem? Of course, I cannot show the customers model, so I’ve simplified the issue down to a beam (shell) bending problem. Imagine a long thin beam and we want to bend the beam a lot (tip moves 180°) by applying a load at the tip. Material is an elastic-plastic aluminum. It is simple to apply a force at the tip and activate the “Follower” option, so the force rotates with the tip and stays perpendicular to it. But that was not the question of the user. The question can be summed up to three conditions:

1. Run that bending simulation displacement-controlled.
2. Only enforce the movement around the rotation axis. Do not restrain the other 5 DOF at the tip.
3. The reaction force of the enforced movement should be available afterwards.

Why displacement-controlled and not force-controlled, when the later would be much easier? I do not know exactly why the user asked for that - there could be several reasons. The two most obvious are:

1. Better convergence. Nonlinear static analysis usually run better displacement-controlled.
2. No stability issue. Force-controlled nonlinear static analysis have a problem, when the resistance of the structure goes down during the analysis. The solver cannot automatically reduce the applied force. Typically, the analysis aborts in those cases. Two alternatives would be to use an arc-length method (Riks) or to run it displacement-controlled. Others would be stabilization/damping and/or running it dynamically.

?

Before I explain bad and good methods to model the problem, stop reading for a moment and think about the method that you would try first. Let me know in the comments of a post that links to this article, especially when your method is not in my list below.

:

:

:

Invalid methods:

“Follower” displacement

No, this option does not exist for applied displacements. I assume the majority of users are aware of that.

Cylindrical Coordinate System

I guess this would be the option most novice user would try first, but this does not solve the problem. Let’s say you create a cylindrical CSYS (CSYS = coordinate system) at the rotation axis, refer to this when applying the displacement at the reference node at the tip and use the tangential DOF (DOF2). First, what value would you enter for the displacement? Second, the beam tip is not moving on a circular path in reality, so the idea to enforce that would generate a wrong result. But most importantly, this method wouldn’t actually enforce a circular movement of the tip node. Why? In Abaqus every node (with a few exceptions) gets its own rectangular coordinate system at the start of the analysis. This can be influenced when referencing to a local CSYS (cylindrical, e.g.), but this only effects the orientation of the rectangular CSYS that is generated. The enforced movement is based on the DOF of that rectangular nodal CSYS, so the movement would still be a straight line during the analysis. And no, that CSYS does not rotate with the node, even when NLGEOM is active.

Applying the tip movement piecewise in multiple steps

What’s the idea here: Define three nonlinear static steps, e.g. In the first step apply a displacement upward only to get the first portion of the bending (app. 70°). In the second step free that DOF and apply the movement sideways to get the next portion of the bending. A velocity BC has to be used, since you do not know the starting position in advance. And in the third step change the BC again to push the node down to position zero. Why isn’t this method a good idea? You can get approximately the same tip movement compared to the reference solution, but it depends on the values that you choose for the movement in each step. This is impossible to evaluate when you don’t have a reference solution to compare it too. Another issue is, that you can’t get the needed reaction force with this method. The reaction force in each step is always in the direction of the movement, not normal to the tip of the beam.

Coupling

This would work actually, but does not fulfill condition #3. You can define a kinematic coupling between the ref node at the tip and a ref node at the rotation axis. Only activate the one “tangential” translational DOF within the coupling. Now restrain the center ref node in 5 DOF and apply a rotation of 3.14. This would generate the correct movement and deformation. But you cannot directly get the force needed at the tip now. You can get the reaction moment at the axis, but you have no information about the current distance between the two ref nodes to calculate the force from the moment. Additional definitions and actions would be needed to get the constantly changing distance (connector, COORD output, scripting, …).

Subroutine DISP and/or ORIENT

Bringing out the big guns… ;) But no, this wouldn’t work. You could easily enforce a circular path with DISP, but that’s not what we need. DISP still requires to use the DOF of the node from its rectangular CSYS and we already discussed the problem with this. Adding the ORIENT subroutine wouldn’t help either, since this one is only called during the initialization of the model. It cannot be used to update a CSYS orientation during the run.

?

“Okay” method (possible, but not the best way to do it):

A contact definition could be used. Not very elegant, but possible. Create a rigid surface and place it’s ref node at the rotation axis. Define contact between the surface and the tip ref node and then rotate the surface. Don’t activate friction and use a contact output variable like CFN to get the force at the tip ref node. Be careful when you also have general contact active. Exclude the rigid surface from GC to not get other unwanted contact situations.

?

My preferred method:

Using a connector element. Experienced users probably thought of that right from the start. A connector element allows to connect the DOFs of two nodes and those DOF rotate with the element. The different connector types create a relation between certain DOF of the nodes and some relative movements might already be restraint. So what connector type would be the best choice here? A “Slide-Plane” connector would be the best choice. It creates a relation in all three translational CORM (components of relative motion), but restraints only one (=CORM1). When creating the connector between the two ref nodes, make sure to select the center ref node first. Afterwards request history output for the connector. I activated CTF1 and CP2 and explain later what to do with that. Restrain the center ref node in 5 DOF with a boundary condition and apply the rotation with 3.14 (= 180deg). You can also request history output of RM (reaction moment) for the center node. This offers now two options in postprocessing to get the force. The direct way is to plot CTF1 of the connector. This is the force that goes through the restraint CORM1 in our connector and is equivalent to the force that would be needed at the tip node. Another option is to use the reaction moment at the center node and the connector length (CP2 output of the connector) to calculate the force. Use the “Operate on XY data” option in Abaqus/CAE postprocessing to generate this curve. As expected, it is identical to curve of CTF1. A xy-plot of COORD2 vs COORD3 of the tip node allows to see the trajectory/path of that node, which can also be useful. Job done. I've added a result video in a previous post and link to it at the end of the article. Some images are also below.

I’ve uploaded the .cae (v2022) and .inp file of this solution to my OneDrive. Download-Link

?Expert bonus tip: There is an option that can improve convergence and reduce runtime in cases like this. By default linear extrapolation is used in the Newton-Raphson method to estimate the new displacement correction at the beginning of an increment. Switch to parabolic extrapolation when doing simulations that involve large rotational movements. Find more details in the Abaqus documentation. In this little example the setting reduces the runtime by a factor of 3.4. That’s massive. Would you have thought of that option?