Semester Goal for This Research

What is the End of the Semester Goal for this Research?

At the end of the semester, this research needs to yield a paper, a presentation, and a poster. That means that at some point, my advisor and I need to figure out exactly what we want to get out of this project. This will have to be dialed in precisely over the next few weeks, but here is what we have so far:

Strain Energy Convergence

When running a finite element analysis for a given model under a given load, the strain energy is the sum of the strain in every element. A finer mesh means the model will have more elements, and for a coarse mesh range, more elements will mean a higher total strain energy. Eventually, the model will have enough elements to accurately represent the strain in the model, and a finer mesh will not increase the strain energy anymore. This is called strain energy convergence, and ideally it should resemble a horizontal asymptote.

This is the graph from testing the 10x10 spherical cap (the model will be explained later in this post):

Total Strain Energy vs. 1/Mesh Length for 10x20 spherical cap

The graph doesn't quite reach convergence, but given the limitations of the technology at hand, it is going to have to be close enough (and it is reasonably close, we aren't even going to use the finest mesh shown).

Running a model with finer meshes until strain energy convergence gives the coarsest mesh that still shows all the strain in the model. In simpler terms, it shows the least process-intensive model to still get accurate results. In this case, it is somewhere around 0.08-0.05m, and most likely we will use 0.08m because that can run on my Naval Academy issued laptop.

What models are going to be run at this mesh?

This semester's research will most likely focus on rigid models instead of pre-tensioned models for sake of simplicity. This will allow us to evaluate multiple models (pre-tensioning just takes too long to create multiple models of the same form) and evaluate them under different member spacings and cross-sections to examine structural differences from having different numbers of members.

To show this process, I will be making three rigid gridshell models, all spherical caps with perpendicular members; one will have 10x10 members, then 20x20, and finally a 30x30 model. All three models are the same overall size, and for now they have the same cross section:

10x10 Spherical Cap Rigid Model

20x20 Spherical Cap Rigid Model

30x30 Spherical Cap Rigid Model (unfinished)

Why have Three Different Models?

The models will all be evaluated under the mesh size found from the strain energy convergence of the 10x10 (we will run strain energy convergence tests on the others to make sure 0.08m works for all three). These models will be compared on the basis of volume/mass (given a material), buckling load, and probably maximum stress/deflection given a prescribed load. Another interesting option may be to prescribe a load case and a maximum allowable stress, and then find the necessary cross section for each model to meet that criteria.

This comparison will explore the inherent trade-offs of changing member spacing. The next post will hopefully contain more specifics of the end-of-semester deliverables of this research.

Form-Finding

What is Form-Finding?

Form-finding is  the way in which computer programs easily simulate the hanging-spring networks mentioned previously in this blog. Form-finding fits into the larger algorithm of this research:

1. Set 2-D grid

2. Use form-finding to optimize the grid for a given height

3. Convert the simple, shell model into distinct members

4. Create members in Solidworks and mark/note their intersection points

5. Create Solidworks assembly of grid of members

6. Add connections to members

7. Erect the gridshell assembly

8. Test the gridshell in Solidworks Simulation

Steps 3-8 of the process come from the work I did at my internship, which in turn come from the process in which real gridshells are constructed: you lay the members flat on the ground, attach the joints, then raise the gridshell and lock it into place. Steps 1 and 2 are the new part.

Why use form-finding at all?

During the internship, the shape of the gridshell was determined by my Matlab code; its dimensions didn't need to have any basis in reality. That is not the case under the new system, in which the research is set up to directly complement the gridshell capstone project here at the Academy.

What does form-finding have to do with capstone?

My capstone project is to design a gridshell that can essentially compete with a standardized SWA hut for Humanitarian Assidance/Disaster Relief (HA/DR) applications. This means that at some point, the capstone group will have to pick a size and rough shape of the capstone (in order to solidify materials needed, weight, interior space, etc). Once this happens, or even to help this happen, I can use form-finding to test any size gridshell that the capstone group needs.

PushMePullMe

PushMePullMe, which will now be referred to as PMPM, is a form-finding function that works well for gridshells, as shown by the model below, which took all of ten minutes to make:

Basic gridshell model found using PushMePullMe 3-D

PMPM, as far as I've found, isn't terribly precise in its height criteria for optimization, but it is extremely quick to raise the gridshell optimally once the grid and anchors are laid out on the ground.

We will also be looking into using Rhino with the Grasshopper plugin to allow for more precise parametric design in the optimization, but I haven't had a chance to look at that yet.

Taking a form from a shell model to Solidworks

A model such as the above PMPM model isn't exactly correct as far as the members; in the model above, all the members are on the same shell, which means they all take up no space and go through each other. Real gridshells have stacked members sandwiched with plates, which need to be modeled to ensure an accurate result.

Going from points generated from a model such as the above, and creating a Solidworks sketch is a fairly simple process, using one macro found online:

Simple Solidworks sketch from points

This model, however, still has all the members on the same plane, and wouldn't allow for the stacked members. This means I must manipulate the points in order to get one member at a time. Then I need the length of that member so that I can lay it flat in Solidworks and then get the pre-tension when the gridshell is raised.

I have done this before, over the internshp. Here is the Matlab plot of the points used to make the above sketch (note that the axes aren't the same scale so the cap dome looks much higher than it really is):

Matlab plot of points used to make Solidworks sketch shown above

By looking through the coordinate arrays, I was able to isolate one cross-member. This allowed me to then spline the points of that beam to create close to a smooth curve. This almost-smooth curve then allows me to measure and output the length of the member and the length in between intersection points, which I need in order to lay the flat grid of members in Solidworks. The plot below shows the nodes and spline of one member:

2-D Plot of one member in Matlab.

The blue circles are the nodes that define the member, and the red curve is the points that make up the spline approximation for the shape of the member, allowing me to calculate its overall length and length between nodes.

Next Steps

The next thing to try will be Rhino with Grasshopper. I am confident that I could finish the spherical cap, as it would essentially be the same process used in the last part of the internship. Focusing on steps 1 and 2 will also allow the research to better integrate with the capstone project.

Pre-Tension in a Gridshell

How would you model pre-tension in a gridshell caused by bending members in Solidworks?

Apparently, Solidworks has the capability to model the pre-tension, by essentially replicating the bending process, which allows the user to start with this model;

Gridshell Beam Model

And bend it a prescribed amount, resulting in this:

Bent Gridshell Beam

It is worth noting that, while this beam is correctly matched to the height and length of a gridshell (calculated mathematically in Matlab), it is only constrained via prescribed displacement at the ends, but the capability exists to constrain several points along the beam, ensuring the final shape matches the desired catenary curve.

Now, can this method handle bolted connections?

Turns out Solidworks also does that pretty well. I started the test with a simple cross of two long beams, connected with the standard curved plate and bolt connection used previously. The result (note this one uses several prescribed displacements to ensure a slightly more accurate catenary shape) is shown below:

Basic Bolted Joint Bent

Which also started laid out flat:

Basic Bolted Joint Model

This model involved most of the same process as before:

1. Lay out the members flat
2. Use Assembly mates to achieve the desired position and layout
3. Fix the center of each beam (this leaves both plates able to flex)
4. Sketch lines into the beams to create the edges that will have prescribed deflections
5. Prescribe the deflections, making use of the "Split" option for selecting lines partway down the beam

Now, what if the bolted connection moves?

The next logical step was to see what happens if the bolted connection itself needs to move with the beam; how will Solidworks handle having the bolted connections moving like that? Will everything stay together as it should, or will the bolts do something unrealistic?

To test this, I started making a simple 5-member gridshell, in the shape of a catenary dome, as shown below modeled in Matlab:

Matlab 3-D Plot of 5-Member Catenary Dome

I haven't yet added all the members, but here is the flat assembly so far:

Unfinished Catenary Gridshell Laid Flat

It's hard to see, but each point where beams cross has a full bolted connection (bolted between two curved plates, that might have to change eventually to a more simple shape). The end of each beam was constrained to drop 2m vertically, so that everything ends up at "ground" level. The resulting model doesn't really look like a catenary shape (the next step is to use the Matlab model and constrain each joint to drop by the correct amount), but it shows that the bolted connections managed to hold up, even when the whole joint moves:

Unfinished Catenary Gridshell Bent

The next step is to add more complexity to this model to make it actually resemble the Matlab plot. In order to make the model match the plot, a few things must be added:

1. Add the other cross-beams, with 6 more bolted plate connections
2. Constrain each connection to displace its correct amount
3. If that still doesn't accurately resemble a catenary dome, then move on to prescribing the displacement of each beam at a few intermediate points

Working with Simulation in Solidworks

How do you make sure a bolted connection will model correctly in Solidworks?

Here are a few realizations I had about making sure a simulation of a bolted connection will run correctly:

1. Friction - Solidworks Help page says that friction is added automatically based on the materials chosen, but it isn't (note there is nowhere in material properties to add a coefficient of friction; it's based on both materials contacting, not just one). This means that every component contact must have a coefficient of friction set; if this varies, then multiple component contacts will be needed to fully define the model
2. Solver - The Solver matters; different solvers are better at different things. Most notably, the Direct Sparse Solver, while being potentially less accurate than the Iterative Solver, can better make use of powerful multi-threaded CPU's (such as the 32-thread Xeon in the Watkins Hall computer lab)

Solving With 'FFEPlus' Iterative Solver - Note 3% overall usage and one core used

Solving with 'Intel Direct Sparse' - Note 39% overall usage and most cores used

3. Washers on Bolted Connections - Washers are commonly used on bolted connections to avoid preload loss at the head or nut of a bolt due to deformation when the contact stress deforms the material where the head/nut presses. However, after reading about their use in bolted connections in Solidworks, I don't think it is necessary to add washers in the simulation, and it has the tendency to make the simulation not actually solve. It seems best, then, to leave washers out (maybe adjust the radius of the head and/or nut, I'm not sure how that works, I'm going to check that out next).

Update: Bolt head size does work in Solidworks Simulation

After testing the same model with a larger bolt head, it would seem Solidworks does in fact model the size of the bolt head (why would they let the user define the bolt head/nut size if they didn't?). This means that the user can use a larger bolt head to model a washer of the same size. Proof shown below:

Joint Model with 12mm Bolt Head - Note the lighter sections (more stress) around the bolt 

Identical Joint Model with 20mm Bolt Head - Note the area around the bolt is now light blue - lower contact stress

Bolted Connections In Solidworks - Gridshell Joint Exercise

Can Solidworks easily handle a bolted connection?

Or: Practice Working on a Gridshell Joint

Gridshells are generally laid out on the ground, then propped into their final shape by scaffolding (or other means, as will be the subject of next year's capstone project). This means that a gridshell joint needs to be attached on the ground while still allowing rotational and longitudinal freedom of its members, and then locked into place when the final form is attained.

The most common way this is achieved today is through the use of clamped plates that sandwich the gridshell members. They are initially applied loosely to allow the members to flex and slide during the erection of the gridshell, and then clamped more tightly later to lock the gridshell into the correct form.

Modeling this joint in Solidworks is a hurdle this research will eventually have to face, due to the potential effect the joints will have on the structure that cannot be modeled by a simple rigid connection. But doing this in Solidworks requires using a bolted connection, which the author was not sure if Solidworks actually had the capability to handle natively. It turns out Solidworks does have this ability, and it really isn't too terribly hard.

In a Solidworks Simulation (in this case a static simulation set to study the stresses on the clamping plates due to rotating force in the members), the user simply needs to select the drop-down menu under 'Connections Advisor' and select 'Bolt' and follow the setup to select the cylindrical cuts the bolt will go through, and the ends where the head and nut will be. This selection even allows for a set preload, a crucial part of any bolted connection (a preload applies the clamping force and prevents joint separation, allowing the joint to be treated as one rigid member).

Approximation of a Gridshell Joint, Showing Bolted Connections

A real clamped connection on a Gridshell would have additional complexity, such as plate shapes that are more visually appealing, and washers (and even some disk springs) on the bolted connection, that are not modeled here. These can be added later to this model or a new model if this ends up being too far from reality.

With that disclaimer in mind, it was possible to run this model, which yielded the following stress visualization:

Approximation of a Gridshell Joint, Under a Twisting Force on the 'Gridshell Members'

This shows almost no load on the members themselves, and almost all of the load on the plates. While this may or may not resemble a realistic connection (ideally the members should only be transmitting compression forces, as shown in the last post), it does show that the bolts are transmitting load through the clamping force they exert.

I also found out that Solidworks does in fact have a way to treat a member as a beam (including selecting joints), so the next step will be to check that out, and see if it is feasible for use in this project.

Testing Catenary Arch and Catenary Dome

How do you verify that a shape is a catenary?

A catenary shape is defined as the shape a hanging chain makes, resulting in pure tension. When flipped, the resulting catenary arch should, under equal and opposite gravitational load, be in a state of pure compression.

To verify the catenary shapes that I made in Solidworks, I turned them into a catenary arch and a catenary dome, using the following procedure:

1. Create a sketch of the center of each 'node' in the hanging chain model
2. Copy the sketch into a new Solidworks part file
3. Spline the points together
4. Sweep a cross section along the spline
5. Fix the ends of the arch/corners of the dome
6. Apply gravitational load
7. View results, if the compression load is close to equal throughout the part, then it can be considered a catenary arch/dome

Using the spline took to create a continuous curve and sweeping the cross section along the curve yielded the following parts:

Catenary Arch

Catenary Dome

With the ends of the arch and corners of the dome fixed and gravitational load applied, the stress visualization showed that the parts are indeed approximately catenary shapes (Note that it was easier to flip the gravitational force than it would have been to flip the part):

Catenary Arch Under Graviational Load

Catenary Dome Under Graviational Load

The side view shows that the shapes (except for near the fixtures, especially on the arch) have a consistent stress throughout the part, further proving that they are roughly catenary shapes:

Catenary Arch Under Gravitational Load, Side View

Catenary Dome Under Gravitational Load, Side View

This means that using Solidworks to model a hanging chain could, indeed, be used as a tool for generating catenary curves to be used in gridshell design. Another option I have been pursuing is using Matlab to create a catenary equation for a given size and shape (input desired height and width, and the script solves for the necessary curvature, and outputs the list of points for the desired shape/form)

Hanging Grid of Spring Chains

Can Solidworks Handle a Matrix of Hanging Spring Chains?

Yes, with similar procedure as the catenary shape of the chain of springs, only this time there is a grid (or matrix) or springs, making a 'catenary dome' that could eventually be used to make a gridshell. The result ends up looking as expected:

Spring Chain Matrix, Hanging

Just as with a single spring chain, starting from a flat position ensures that the hanging is repeatable, and the curvature of the form (basically how far down the chains actually hang) can be manipulated by adjusting the spring constant of the springs, either individually or together.

Spring Chain Matrix Starting Position (disregard the red springs)

Adjusting the springs individually will change the shape from a standard catenary shape, however, and would only make sense when the flipped catenary dome will be under uneven loading.

Both the single spring chain and the spring chain matrix were able to yield sketches representing the position of each 'node,' which means the next step moving forward is to turn those sketches into an actual catenary arch (and eventually a catenary dome) and test them under even graviational loading to see if they are at or near pure compression.