In this post I'll walk you through a parametric study I've made some years ago to optimise lattice, self-support tower layouts. The goal was to find better and more efficient shapes for 3 and 4-legged towers, thus gain competitiveness as tower supplier. I'll also demonstrate how the (already light-weight) tower's dropped weight by 5 to 8%.

## Introduction to computational design

### Command line tools

In the 80' we have had access to FEA solvers mainly through command line softwares. While they have done a great job, assemble and solve all matrix quotations, they had a very simple UI compared to today's softwares. It was more or less in the format as below.

```
someFeaCommand input_file output_file --some_paramaters --some_options
```

These kind of tool they still exist today and they are very useful, specially when we want to integrate them. But on the other hand they are lacking to provide a great UI/UX and the geometry is a static input.

### FEA Softwares

An evolution of the command line tools were FEA software packages where we have usually a nice user interface, several algorithms, post-processing opportunities and even code check modules. **StaadPro, SAP2000, Dlubal, Autodesk Robot, AxisVM, **among others. While these programs are very intuitive and usually provide great user experience, the concept are more or less the same. The geometry of the structure under analysis is a static (hard coded) input. If we want to experiment with new geometries, topologies or layouts we have to basically rebuild the whole finite element model (FEM). This makes it very cumbersome to come up with a very optimal design and the whole process is laying on the engineer's judgement. It worthless to say that the optimality of the design will be based on the seniority of the engineer and years of experience. But here is, where **parametric** or **computational** **design** comes in.

### Parametric and computational designs

We say parametric models when a design input of the model is a parameter rather than a scalar input. The parameter can have a range and steps. So we decide a certain input should be i.e in the range from **1.0m** to **3.5m** with a steps of **0.1m**. Nowadays more and more software companies introduce parametric tools into their products, like Dynamo for Revit. But today I'd like to show you how I used the Grasshopper, Karamba3D and other plugins in Rhino for a telecom lattice tower.

## Parametric models

Before I go to some details of my telecom tower model, I want to show you some other examples where parametric designs are so useful in the field of structural engineering. If I want to summarise in one sentence why even we want to use parametric tools for structural designs, then I would say

because of the so many possible options of an optimal layout which we cannot replicate by manual geometry inputs, or it would be too time consuming.

Let's start with a simple truss model. If you visit Karamba3D website, you will find several models, like the one below. Here we setup the **distance** of the vertical braces of the truss system as a parameter and then we plug it into the FEA solver. Then we can start to play around the **distance** value and see how our structural system responds. As you may see in the GIF below, the truss will deflect vertically more when we have very few bracings. Now, let's imagine that we have an output field which gives us the total weight of the structure. After few iteration and trials, we will find the most optimal shape, or with better terms, the optimal topology of the structure. One can already conclude from here the power of the parametric nature of the model and opportunities also for further improvements. We could, for instance move forward to establish other geometry inputs as parameters, like the **height** of the truss or **length**, etc.

Another example which I was working recently is a steel plate topology optimisation problem. Here a steel plate is given with some installation and manufacturing constraints. Then the task was to find the most optimal layout with the required thickness of the plate.

Another example is a base station satellite pedestal where all major geometry inputs are parameters. Then an evolutionary solver has been used to find the most optimal solution, in this case the minimum weight.

### The parametric tower model

The below is an overview about the model. On the right hand side there is the Grasshopper definition while on the left is the generated model. I want to note that the whole model you see on the left is fully parametric, meaning that there was no a single line drawn in Rhino. All points, lines and surfaces have been generated as a Grasshopper definition.

So, what this model does? It builds an arbitrary lattice tower from the below parameters, applies the loads as per TIA-222-G and runs a non-linear FE analysis.

**Parameters:**

- Number of legs
- Section height
- Number of sections
- Tappering
- Base width
- Bracing system type (4 types)
- Antenna EPA area
- BWS (basic wind speed)
- Topography category
- Exposure category

Thats a lot's of parameters. But to break down the problem, some of the parameters are not so dynamic. Let's imagine that we have a physical location on earth, so many of the parameters will become a static value. Like BWS, topography, etc. My real-life scenario was to optimise a tower family and as such they are deployed to certain areas. With a parametric model we can find optimal shapes for certain **wind speed **and **loading** options along with some other **site-specific **parameters. After "fixing" these location specific parameters and the tower height I remained with some others which are related to the tower layout. The based width, tapering, section height and bracing system. Since these geometrical parameters are setup within a wide range, we still have a lot's of options to run through the FEA. I didn't want to do that manually so I applied an evolutionary solver, Galapagos to do the job. Galapagos is a plugin on Grasshopper and solve optimisation problems in a stochastic way. It iterates through our parameters to find a minimum or maximum, in my case it was the minimum weight. If our definition is built up properly, in a way that we have a global optimum, then it will find the corresponding optimal parameters as well. See this in action in the video below.

### Challenges

While I was building the model I have faced with several challenges. The first was to create a proper wind model on the structure. In proper I mean really proper. I wanted something which is nearly identical if I run the model with TNXNumerics. So I needed a full implementation of the TIA wind loading requirements in the model. But how to achieve that? In Grasshopper we do not have a component, called TIA wind which magically creates the loading parameters on our model. At least we don't have it by default. But there is components for Python codes, so I built up my own. I implemented the structural drag factor and antenna EPA calculation into the Python component. This component gets the site-specific parameters and antenna areas with their position on the tower.

In return, it gives back the velocity pressure at each section height. Then from here it was a breeze to apply them to the FE model. ...or at least it seemed to be a breeze. The next major challenge came when I started to run the analysis and I optimised all members as per their internal forces. When a member is optimised, and let say the member size is dropped down compared to the initial assumption, then the wind loading is also changing on that member. I couldn't neglect this effect as that would ruin all the intention to optimise the structure. But this was maybe the biggest challenge I faced with during this development, as this was an infinite loop. It is, because one of our input is based on an output from the same algorithm. If you are familiar with Excel spreadsheets, you may encountered "circular references". This is when you reference the cell of your formula in your formula ;) So how to solve it? After some research I found a smart plugin for Grasshopper which solves this issue. It's called Anemone, and it does a recursive looping. With this component I was able to looping through all the geometry changes and run the optimisation component of Karamba3D.

The steps are as follows:

**Step 1**: Get the geometry from one set of parameters**Step 2**: Establish the wind loading on the tower and antennas**Step 3**: Run the FEA**Step 4**: Optimise the members**Step 5**: Re-calculate the wind loading based on the new members**Step 6**: repeat**Step 2**until**Step 5**until no new result achieved, meaning the tower weight is not changing.

## Conclusion

By the end of this development of the parametric model it was possible to achieve **5-8%** of weight reduction on an already optimised tower family. When structural engineers talks about optimisation of structures, we generally mean to optimise a member for certain internal forces and pick up a member which fulfils the code requirements. But with parametric approach (computational design), we are not limited only for member optimisation but we can carry out full scale layout or topology optimisations as well. The later one can bring into life many interesting structures and much more solutions than one could expect.

If you liked this article please share it with your friends or colleagues and follow us on LinkedIn. If you subscribe to our newsletter, then you will get these kind of articles into your email inbox at first hand.