What you'll learn

**a complete 3D finite element analysis solver**to simulate structures consisting of beam and axially loaded bar elements.

**efficiently build detailed structural models in Blender**and export these for analysis in your own Python solver.

**12 degree of freedom beam elements in 3D space**.

Description

In this course we’re going to dive deep into the world of 3D structural analysis by building a 3D structural analysis programme using Python. **After completing this course you’ll have built your own 3D finite element solver and have a workflow you can use to model and analyse complex 3D structures that would otherwise require expensive commercial software packages.**

Building on a family of Python-based structural analysis courses, this course will take your level of ability and self-reliance in structural analysis to yet another level by expanding to consider full 3-dimensional beam bending. In this 13.5 hour video course, we go beyond axially loaded 3D space frame structures covered previously, to build out a feature rich, general 3D solver that can simulate:

- Interaction between 6 degree of freedom axially loaded bar elements and 12 degree of freedom beam elements.
- Localised rotational releases in the form of pins.
- Structural response to both point and distributed loading.

**You DO NOT need to be a Python programming guru to take this course.**If you’ve taken any of the prerequisite courses – or even if you’re just familiar with basic programming ideas like functions, loops and variables that will be plenty to get you started.

The structural analysis tool you build in this course will give you the ability to analyse 3D frame structures, complete with axially loaded bracing elements and even rotational releases in the form of pins. Not only will you have a valuable tool to deploy, but you’ll have the knowledge and understanding that can only come from building it yourself!

When building computational models of real-world structures quite often the best starting point is a simplified 2D model. This greatly simplifies our analysis and if careful judgement is used in building the model, in many cases we lose very little accuracy by compressing from 3 down to 2 dimensions.

However, 2D structural analysis has its limitations. As the geometry of our structures becomes more complex the degree to which they can be accurately represented with planar models diminishes. As a result, the accuracy of our models deteriorates and model output drifts further and further from reality. At this point, it can help to expand into the third dimension.

This course build on the popular series of DegreeTutors stiffness method courses. In particular we will build on what we learned in the study of Beam & Frame Analysis using the Direct Stiffness Method in Python. We’ll expand the code developed in that course to accommodate 3D frame structures.

Unlike the expansion from 2D trusses to 3D space frames, which was relatively simple due to the axially loaded nature of the elements, moving from 2D to 3D frame analysis is a little more involved.

In this course we’ll work through the process step-by-step laying the foundation with theory before implementing what we’ve learned in code. Once complete, you’ll be rewarded with a huge sense of satisfaction (**and a pretty nice 3D analysis tool!**)

It’s a good idea to cover the prerequisite courses before diving into this one, check out the bundle discount at the bottom of this page. In particular consider working through Beam & Frame Analysis using the Direct Stiffness Method in Python.

Generating 3D model data manually can be a real pain, so we’ll be making use of Blender in this course. Blender is a powerful open-source 3D modelling tool. By getting to grips with only a handful of Blender’s modelling tools, we open the door to analysing the behaviour of any structure. We are limited only by our imagination! With its intuitive 3D modelling workflow and Python API, Blender is an excellent compliment to our structural analysis solver.

If you’ve ever tried to manually generate 3D frame data in some of the big name structural analysis packages, you’ll know it can be grindingly slow – you won’t look back after using our modelling and data export workflow.

After familiarising ourselves with how to generate structural models in Blender, we’ll develop some simple scripts that allow us to easily transfer model data back and forth between Blender and our structural analysis Jupyter notebook.

We’ll develop our Python code using the versatile **Jupyter development environment**. When you complete this course you will have a standalone 3D analysis Jupyter Notebook to deploy on your own projects. The code developed within each section of the course is also provided for download as a reference.

Course Breakdown

**Section 1: Welcome and Preliminaries**

In section one we’ll get our bearings and take a look at what the journey ahead looks like. This will give you a good idea of what to expect and how our solver will take shape. As this course is the fourth in a series, I’ll also say a few words on prerequisites and what you should consider covering before working through the course. Both of the short lectures in this section can be watched below before enrolling – take a look.

**Section 2: The 3D Beam Stiffness Matrix**

In this section we get right into the thick of it and start to work out how we’re going to model our 3D beam elements. By the end of this section we will have fully derived the 12×12 beam element stiffness matrix. We’ll start by briefly reviewing the 2D beam element before tackling the additional degrees of freedom in our 3D element.

**Section 3: ****Location and Rotation in 3D Space**

If there is one thing that has the potential to confuse you when trying to perform 3D frame analysis it’s how to deal with rotations in 3D space. Understanding how to handle element orientation, rotations and transitions between reference frames is critical. We’re going to tackle this head-on in this section. By the end of the section you will understand exactly how we’re capturing the orientation of our beam elements. The output at the end of this section will be our element transformation matrix.

**Section 4: ****Generating frame data in Blender**

In this section we take a break from theory and dive into Blender for some light relief. In this section we’ll generate our structural model and use Blender’s subdivide tools to easily ‘mesh’ our structure. By the end of this section we’ll have all of our model data loaded up inside our Jupyter Notebook and be ready to start writing our solver.

**Section 5: ****Building the Transformation Matrix**

In this section we’re going to focus on capturing the orientation of each element within our structure. This is one example of something that we didn’t need to spend too much time on for purely axially loaded 3D members. But for 3D beam elements, whether they bend about a major or minor axis has a huge impact on their behaviour. We’ll start by defining a default orientation for all members. Once we have a predictable orientation for each member, we’ll work out a strategy for calculating and storing each member’s transformation matrix.

**Section 6: ****Building and Solving the Stiffness Matrix**

At this point in our development, we have a lot of the necessary foundation work done. In this section we can actually solve the structure. If you’ve covered any of the prerequisite courses, you will be on familiar ground in this section. By the end of this section, our structure will be solved and all of our data will be just waiting to be visualised which we’ll take care of in the next section.

**Section 7: ****Visualising Results in 3D**

All of the data in the world is of no value to us unless we can visualise it and ultimately interpret it. This section is going to focus on building the standard plots you would expect to see in any structural analysis software. Once this section is complete we will have a fully functioning solver and a complete workflow where we build our models in Blender, import them and analyse them in our Jupyter Notebook solver and optimally review the deflections back in Blender. The next sections in the course are focused on implementing features that enhance the usability of our solver and turn it into a versatile and valuable analysis tool.

**Section 8: Implementing Bar Bracing elements****:**

In this section we’re going to focus on implementing purely axially loaded elements within our code. We’ll refer to these as bar elements, as opposed to beam elements that also resist shear, bending and torsion. We typically encounter these types of elements as bracing members within structures. The portal frame structure we’ve been working on up to now is a classic example of a structure that would use this as a lateral stability system. After this section is complete, our solver will be capable of handling some of the most common forms of framed structure.

**Section 9: Implementing Pinned Members****:**

In this section we’ll implement the ability to model a new type of element – beam elements that have a pin at node i or node j. These pins will act as rotational releases for major and minor axis bending at the respective node. Practically these pins allow our solver to handle simply supported or simply restrained structural members within our models. A practical example of this might be a beam that has a simple fin-plate shear connection on one or both ends. We wouldn’t want to model moment transmission through these connections. After completing this section we will be able to model the required rotational releases.

**Section 10: Implementing Distributed Loading****:**

The ability to handle distributed loading is probably the last big omission in our solver, so we’ll put that right in this section. As usual we’ll start in Blender and identify and export the members within our model that we want to apply uniformly distributed loading to. In contrast to the manual process of determining equivalent nodal actions when we did this for 2D frames, we’ll automate the process here making for a much smoother workflow. Once this section is complete, we’ll have a well rounded solver to put to work.

**Section 11: Bridge Model Case Study****:**

The purpose of this is to take a non-standard structure, unlike what we’ve been modelling up to this point – and see how to approach its modelling and analysis using the tools we’ve developed. One of the benefits of doing this is that we’ll identify good opportunities to further improve our solver – which you should consider doing when you’ve finished this course! I’ll also demonstrate how to make use of some of Blender’s fantastic mesh editing tools that make our lives so much easier!

## Who this course is for

- Students and professional engineers who’ve studied matrix analysis methods but never explored the 3D potential of this analysis technique.
- Students and professional engineers who’ve taken some or all of our previous direct stiffness method courses (see bundle discount at the bottom of this page) and want to continue learning and expanding their abilities.
- Anyone who wants to leverage programming as a tool for structural analysis or within their day-to-day study or work.

*The codes developed in this course are for educational purposes only and are not tested or certified for use beyond the educational scope of this course. Always employ your own engineering judgement first and foremost, regardless of what the computer says!*

## Course Completion Certificate

- Download your personalised Certificate of Completion once you’ve finished all course lectures.
- Applying for jobs? Use your Certificate of Completion to show prospective employers what you’ve been doing to improve your capabilities.
- Independently completing an online course is an achievement. Let people know about it by posting your Certificate of Completion on your Linkedin profile or workplace CPD portfolio.

Course preview

### Lecture 1: Introduction and course overview

### Lecture 5: 3D Beam Elements

Course content

### Welcome and Preliminaries

### The 3D Beam Stiffness Matrix

### Location and Rotation in 3D Space

### Generating frame data in Blender

Importing our frame data into a Jupyter Notebook

### Building the Transformation Matrix

### Building and Solving the Stiffness Matrix

### Visualising Results in 3D

### Implementing Bar Bracing elements

### Implementing Pinned Members

### Implementing Distributed Loading

### Bridge Model Case Study

Reviewing the results

### Course Updates

Roadmap

## 📍 You're here

Frequently Asked Questions

Absolutely. Even if you watched the full course, if you’re not satisfied, contact me in the first 30 days and I will give you a full refund, no questions asked. It would be helpful if you could tell me how I can improve the course for other students.

Ready to get started?

Prerequisites Discount - Save 35% Direct Stiffness Method Bundle

## The Direct Stiffness Method for Truss Analysis with Python

*Build your own finite element truss analysis software using Python and tackle large scale structures.*

**After completing this course…**

- You’ll understand how to use the
**Direct Stiffness Method**to build complete structural models that can be solved using Python. - You’ll have your own analysis programme to identify
**displacements, reactions and internal member forces for any truss**. - You’ll understand how common models of elastic behaviour such as
**plane stress**and**plane strain**apply to real-world structures.

## Beam & Frame Analysis using the Direct Stiffness Method in Python

*Build a sophisticated structural analysis software tool that models beams and frames using Python.*

**After completing this course…**

- You’ll understand how to model beam elements that resist
**axial force, shear forces and bending moments**within the Direct Stiffness Method. - You’ll have your own analysis software that can generate
**shear force diagrams, bending moment diagrams,**deflected shapes and more. - You’ll understand how to model
**rotational pins**within your structures, inter-nodal**distributed loading**and**realistic flexible supports.**

## 3D Space Frame Analysis using Python and Blender

*Develop tools to model and analyse complex 3D space frame structures using Python.*

**After completing this course…**

- You’ll understand how to apply the Direct Stiffness Method to solve 3D space frame structures.
- You’ll have your own analysis programme to identify
**displacements, reactions and internal member forces for any 3D space frame**. - You’ll be able to use
**Blender**, a powerful open source**3D modelling software**to build, visualise and export your structural models.