I once wrote an optimization program which found the best fillet size, thickness and angle of a two dimensional cantilever beam with a given load. It took three days to write. What I’m about to show you took me 30 minutes. It makes use of real geometry and doesn’t require programing! Enter simulation automation…

Let’s consider a scenario. You work for an amusement park ride manufacturer. Your company has begun to streamline their design process. (Good idea if you ask me.) The company would like your team to design components which will be interchangeable (like Erector Set parts). The designer you work with calls himself an artist. He wears leather pants. His ideas are nutty. It’s up to you to make real decisions. He comes to you with the part seen below and says, with a blank stare, “To date, this is my best work. Try not to taint it.”

The company will be making thousands of these parts which will be made from cast carbon steel. It is designed to hold pipes and should carry at least 3000 lbs.

Decision: you decide that the part should have a safety factor of two. (The stress should not be higher than 120 MPa.) This means that the part should be able to hold at least 6000 lbs. without failing.

You setup an initial study to benchmark the current design.

Let’s discuss the difference between the linear solver and the dynamic solver with a case study. Take the example of an engineer slamming his head on his desk after getting poor simulation results from his linear solver.

In scenario #1, the engineer lightly places his head on his desk then proceeds to slowly press down with his body weight. The force value, F, represents the maximum amount of force he can transmit through his neck.

In scenario #2, the engineers head starts a distance of 2 feet from his desk. The engineer proceeds to accelerate his head towards his desk with the aforementioned force value, F. After he comes into contact with the desk, his neck continues to transmit the force until his head comes to a complete rest against the surface.

Now, in both scenarios, the engineer’s neck transmits the same amount of force, F. However, the second scenario will produce higher levels of cranial stress at specific instances in time. The higher stress is related to momentum. The engineer recognizes this and proceeds with scenario #2 until the desired level of masochistic indulgence is achieved.

If we were to simulate these events, design scenario #1 could be adequately achieved with either the static solver or the dynamic solver and the results would be the same. However, if we were to run scenario #2 with a static solver, we would get the same result as we would with scenario #1. Obviously, the static solver has limitations.

The linear solver only sees the last moment in time; when things are at rest. Thus, we have two data points, the beginning and the end.

On the other hand, the dynamic solver is aware of the time in-between the beginning and the end. As a result, we are left with a much more complete picture.

For a moment, let’s sidestep the slamming head on desk approach, as this practice is no longer necessary. Let’s use the example of a cantilever beam with a weight of one hundred pounds suspended from the end.

For the linear study, let’s consider the case of loading the end very slowly. The results of this simulation are shown below.
The maximum displacement is 58 mm.

For the dynamic study, let’s consider that the weight will take .05 seconds to reach its maximum value of 100 pounds and will then level out. The maximum displacement results of this simulation are shown below.
The maximum displacement is 93 mm. This is an enormous jump from 58mm. Obviously, we’d want to study the dynamic simulation results over the static.

To be a good simulation engineer, you need to ask “what if” questions. “What if we make this pipe longer?” “What if we change the thickness?” “What if we change the material?” However, if you have a complicated assembly or part, it’s easy to say, “I don’t want to model it again. That took forever.” Well, the solution has arrived: You need to become a better modeler.

Recently, I was introduced to parametric modeling by my partner in crime, Nick B (or #2, as I call him). It took a while before I realized its potential in regards to optimization and these so called “What if” scenarios.

Once a multi-body part or assembly is parametrically driven, changing values become much easier to do.

To illustrate my point, I’ll breeze through the modeling process for the design of a solar thermal unit. With a setup like this, a good engineer will ask questions like, “What if we add pipe passes?” and “What if we make the passes closer together?” If the model isn’t setup correctly, these changes are difficult to make. So, we’ll design with the intention of changing it later.

Let’s get started with the first pass of the copper tube. A sweep is done and the model is dimensioned and linked accordingly.

The next thing to do is create a linear pattern, linking the spacing value with the pass width and iteration values.

We then create “plane 1,” normal to the right plane and define its spacing with an equation, relating the number of pass iterations with the pass distance.

Plane Distance = (# of passes)*(pass distance)

At this point, the reason for the plane might seem unclear. However, the protective box and heat sink will reference this plane.

We then create merged pipe extensions using linked values while referencing the default right plane and plane 1.

When sunlight travels through the glass opening of our solar panel, only a small percentage of sunlight will actually hit the pipe. So, we need to create a heat sink which will capture radiation from the sunlight and transfer heat via conduction to the copper tubing. We’ll do this by creating a single sheet metal piece with linked values, then pattern it with linked values and equations.

Heat sink iterations = (# of passes)*2 +1

The next step is to create the protective box and glass cover. The geometry is defined using existing relations, similar to what we’ve already done.

Now, if I change values, like the number of tube pass iterations or tube space distance, the entire model updates automatically. This will come in handy when running optimization simulations and playing with other what if scenarios.

I very well could have had this conversation while doing tech support…
Dude: Well, I can see that this is some powerful software, but it’s taking a long time to solve and things shouldn’t be this complicated.

Me: Yeah… that’s a pretty… pretty big mesh. I can’t even see the part.

Me: What are you trying to study here?
Dude: The assembly. (Duhhh!)
Me: Yeah, but what about the assembly? Is there a particular part you’re worried about?
Dude: Well, now that you’ve mentioned it, I am pretty concerned about this part.

Me: Okay, we can eliminate these parts and apply equivalent forces on the faces.

Me: Alright, let’s get started! We can use a rough mesh to find the contact forces.

Me: Now, we can eliminate the top pieces from the assembly and create split lines where we would like to apply the equivalent forces.

Me: This is a perfect opportunity to use 2D simplification. Let’s create a new study.

Me: Now, we can afford a pretty heavy mesh control on the component of interest.

Me: If we go into properties and select the option for “Improve accuracy for no penetration contacting surfaces” we’ll get the same results as before with a fraction of the run time.
Dude: Thanks Nick! You’re the best!
Me: I know… I know.

What is nonlinear simulation? Most people don’t know. So, I’ll lay it out as simply as I can.

First, let’s talk about the linear solver. When the linear solver runs, it solves for the end result. Only the end result. The solver doesn’t recognize any of the in-between steps. Most people notice this when they create an animation where you would expect some intermediate interaction between parts. “Why didn’t the hook go over the latch?” Is a question I hear all too often when customers create animations from linear simulations. When you have a hook going over a latch, you would expect some interaction between the two components. The reason the two components don’t move like you would expect is because a linear solver only focuses on the end result. So, we only have two points to work with – The start point and the end point. The animation interpolates between the two. The middle is missing.

The nonlinear solver goes about the problem in a different way. Instead of having two points, A and B, the nonlinear solver will solve the in-between steps. The solver marches through time solving these intermediate steps. However, this time isn’t real time. It’s merely a parameter used to describe the relation between the intermediate steps. So, it’s often referred to as pseudo time. This approach comes in handy in a few different situations.

Boundary nonlinearity – Just like the latch example. You have two parts that interact with one another. When the situation arises where you would like to study the steps in-between start and finish, you might want to treat the simulation nonlinearly.

Geometric nonlinearity – When a part deforms so much that its spacial orientation significantly changes, it often helps to solve with little steps. This sort of nonlinear simulation can be dealt with using Simulation Standard. To turn this option on, click, “Large displacement” under properties.

Material nonlinearity – When a material doesn’t have a straight stress-strain curve, you can’t go from point A to point B without the in-between steps. This is because the path from point A to point B is crooked. Have you ever stretched rubber so far that it became easier to stretch? Well, how could you ever solve THAT with a linear solver? You have one force and two or more displacements. Think about it. There are a few different types of material non-linearity, so I won’t go into it too deeply. but they apply to rubbers, plastics, metals after yield and so forth.

So, when someone tells you, “This problem is nonlinear,” don’t change the subject. It’s not as complicated as it sounds.