I got a really interesting question on my email from Fateme. I wanted to address this issue so many times now, so finally there is a great occasion to do this!
In Abaqus, can we review the capability of a structural member?
Whether or not it can bear the load like: shear, bending, twisting, axial etc.?
This issue seems trivial, but I’ve seen a lot of people wasting a lot of time around it!
Let’s start with how you can actually design a structural member!
Code design and member capacity
It’s obvious that structural members design is a very important part of engineering. This is especially true in civil engineering! This is simply because you build most structures from various members (and plates).
Through the years we have developed a lot of different codes that guide the member design. Of course, those usually differ from country to country. I.e. you will use ANSI/AISC 360 in US or EN 1993-1-1 in the European Union (almost entire Europe uses the same codes now – yay!).
As we learned more and more about structures those codes became more and more sophisticated. Right now they do not only dictate how to verify if the member has sufficient capacity. There are rules for a lot of different structures types. You can find information there about frame stability, or how to calculate members and connections in trusses etc.
Codes provide set of mathematical equations (usually) that when used allow verifying the member you wish to calculate. Usually, you can do everything by hand as long as you know the internal forces and cross-section properties of the member you wish to analyze.
Another important thing about codes is that they also provide test-based buckling curves for most problems. This means that when you calculate a column against buckling under compression the code will assume “proper” imperfections for the problem. This is an important factor. You simply can’t erect a building that is “perfect”. All shape mistakes, accidental eccentricities etc. may greatly reduce capacity due to buckling or lateral torsional buckling. Codes take that into account basing on extensive research and engineering experience gathered in the past.
Similarly, you can’t design everything with a simple “bending moment divided by section modulus”. In many member types (like concrete beams) a lot of sophisticated rules were in place. Those rules allow to correctly foresee the member capacity.
To sum this up
- Member design is usually performed in accordance with the codes.
- Codes vary from country to country but there are a few (like ANSI and EN 1993) that are recognized around the world.
- Codes provide rules for member design, that take into account imperfections and complex member behaviors.
- To calculate a member you need to know internal forces and geometric characteristic of this member. When you do, you can calculate the “rest” by hand according to a proper code-procedure.
- More complex problems like frames stability and interaction between different structural elements are also described in codes. Thos usually can greatly influence the design of singular members.
Where FEA kicks in?
It’s high time to wonder where FEA helps : )
Did you notice that I mentioned you need to calculate internal forces of the element you wish to design? In simple problems, you can easily do this by hand… but in structures like that:
There are literally thousands of elements in the trusses on the picture above. It is possible to calculate internal forces by hand in such situation… but you really don’t want to do that to yourself!
It is much faster, and to some degree more precise (assuming you know what you are doing) to make an FEA model. When analyzed the model will provide you with all the internal forces in each member. Usually, you also get all the geometric properties of cross-sections.
This is a great help, as in speeds up the process greatly! You also get deformations (which usually look far better on pictures : p) so you can check if your model deforms acceptably. If you want to learn more about FEA, you can always take my free FEA essentials course.
All in all, outcomes can look like this:
Looks great right… but there is one thing a lot of people miss…
FEA is not all – don’t miss out on the additional step!
It seems great to hear, that FEA will do the design for you… but there is something I didn’t mention in the previous chapter on purpose. You see, after FEA calculations you still have several thousands of elements you need to verify against code checks. This verification can be done with hand calculations, you can even make a script that does it for you. Whatever you chose there is still a lot you need to do!
This is where things are getting tiresome!
In short, I would divide FEA software into two categories:
- Advanced general FEA soft. You know this is the FEA software you would think about. Programs like Ansys, Abaqus, Nastran (that I use here) etc. Usually, the possibilities of those packages are very high. You can solve a lot of complex problems with them. But also, they do not have the “codes” implemented. This means that the software won’t do the code checks “for you”. You need to do it manually later or use more advanced numerical procedures.
- “Civil engineering” FEA soft. If you are not a civil engineer this is something you may not have heard before. Those are the programs like RFEM (which I really like and use here), SAP2000, Autodesk Robot and much more. Those programs are intended for civil engineering. Some allow only for beam elements, some allow plates and solids as well. Whatever the case may be, they do not have capacities of the advanced FEA soft for sure. You can do nonlinear analysis in almost all of them right now, but the post-critical analysis is more or less impossible. There are of course a lot of other limitations, not great mesh control etc. However, they have a huge advantage: codes are implemented in those programs! This means that the program automatically will do a lot of code checks for you, thus saving you a lot of effort.
Designing beams in both types of programs have positive and negative sides. Let’s discuss them briefly!
Member design with “civil engineering” FEA soft
I will start with the civil engineering soft as it is simpler to discuss : )
The outcome of the design you will get is in percentages (as of percentage of the maximal capacity ratio used). This means that if the beam is at 50% you can load it more – there is still 50% capacity not used.
You should remember that not everything in such software is FEA. Sure, FEA does provide a static solution, internal forces, deformations etc. But the “percentages” and every possible code check that is performed has nothing to do with FEA. Part of the software simply imports FEA outcomes to the place where code procedures are performed. You can think about is as an “Excel sheet”. Software imports internal forces there and the sheet calculates everything according to the code procedures.
- Does the work for you!
- Harder to make mistake in getting the “data” out
- Not as many analysis possibilities as “advanced FEA soft.”
- Usually code calculations require a lot of assumptions. Those should be defined in the software, but people often are unaware of it. This may lead to wrong design.
Member design with “advanced” FEA soft.
This is a bit more tricky. You can of course just do the static calculations here. Then export the outcomes somewhere (scripting will be helpful here) and simply do code checks elsewhere. Excel sheets seems to be a great choice of course : )
However this is still manual work, so instead people try to “automate” it more. Current codes, for instance, allow for imperfections to be implemented “geometrically”. This means that instead of following the code procedure (especially if you use EN 1993-1-1) you can implement geometrical imperfections and just do stress analysis!
However defining those imperfections is a lot of work. This won’t always greatly speed up calculations. This is especially true since there are several different imperfections types, and they can interact with each other, creating nasty combinations. Sadly in advanced FEA software not much more possibilities exist. Sometimes you will also have to model beams as a set of plates simply to be able to take some effects into account (like lateral torsional buckling).
Of course, you can simply do a stress design. Literally, any software can calculate the stress in a member, based on its cross-section. Sadly such approach does not take into account a lot of elements (concrete member design anyone?), so I would be very careful with this approach.
- More advanced calculation options
- Better solver control with different parameters
- No code design implemented
- Quite a lot of additional work to perform capacity design
There is a lot more to this subject for sure – I will try to expand on it in future : )
Want to learn more?
If you like FEA, you can learn some useful things in my free FEA essentials course.