Last edited 16dec10 by jmetzge2@illinois.edu
Structural Analysis: Concrete Beam Deflection
Introduction
My program was done in Python and the animation used VPython. The program displays a concrete beam supported by two columns.
The columns and beams are designed to scale and oriented as a simple span setup. The arrow is labeled and represents the applied load
on the structure. As the animation is run, the applied load moves vertically to illustrate the loads on the structure being applied
to the system. The program is run by selecting run module from the Python toolbar (or pressing f5). The applied load hits the
bottom of its path then returns to its origin. The distance which the arrow moves is a scaled up value of the maximum deflection the beam
was calculated to withstand.
Here is a picture of the beam setup and the applied load.
Background Information
The topic of structural analysis is one that has been investigated and reinvented
over the years at the University of Illinois. Professors such as Hardy
Cross have innovated new methods with which to quantify and explain the
performance of structures in real world applications. Structures that are
used on an every day basis, as well as structures that have not been erected
yet. In order to create an everexpanding world of safe, yet exciting and
ground breaking structural wonders, proper application of the techniques
developed at Illinois (and elsewhere) must be implemented correctly and
consistently. My project aims at inspecting an important, yet specific portion
of analysis involved in structural mathematics, deflection. Deflection
can be defined as the movement or displacement of an element or structure
due to an external or internal force. Any structure, which for simplicity can
be defined as a freestanding object comprised of individual elements, must
be addressed case by case to properly analyze its behavior. Many factors
will contribute to the final properties of a structure including orientation,
material composition, external and internal loads, connections, and mathematical
assumptions.
In order to compose a simple and effective analysis of
structure deflection, I have implemented a set of parameters that will govern
the boundaries of my project. The first boundary addresses the setup
of the structure in question. The deflection of a single beam will be analyzed,
and this beam will be supported by two individual columns on each
end of the beam. Both columns will be considered infinitely strong and
able to support the beam under any applied load, this way, a determinate
analysis of the horizontal member alone can be achieved. The beam will be
simply supported by each of the columns along a given span width. Now
that the setup has been defined, the material composition must be chosen.
The mathematics that accompany structural analysis of concrete members
present some interesting relationships, so for my project a concrete beam
and columns will be used. The specific parameters of the concrete beam are
what will contribute to its behavior under loading, including width, depth,
steel reinforcing, length, and concrete strength. In my analysis I have defined
these properties as constants in order to isolate the loading parameter as a variable.
In depth exploration of these parameters and properties are
included in the mathematical development section.
Once the boundaries
and constants of the setup have been defined, several structural equations
can be applied to figure the final deflection experienced by the beam. My
project aims to keep everything but the external load constant in order to
see the effect on the given beam. In order to help the user see the effect
of a varying external load on beam deflection, I have used the VPython
programming environment for visualation. A simple beam setup has been
modeled with a moving arrow to show increasing force and the resulting
deflection. As the force magnitude varies, so does the deflection experienced
by the beam. The proportion between the applied force and the resulting
beam deflection has been calculated in the next section, and subsequently
applied to the programming used for the visualization. One important thing
to note is that the beam deflections experienced by most concrete beams are
so small that they cannot be detected by visual inspection. The programed
visualization has been scaled up several times in order that the user may see
the deflection resulting from an increasing load.
Final Equations
Coding
The following is the code used to make the animation. It was a fairly simply while, if statement that
moved the arrow a certain distance before reversing the velocity and moving it back to the original position.
from visual import *
wallR = box(pos=(5,0,0), size=(1,10,1), color=color.white)
wallR = box(pos=(-5,0,0), size=(1,10,1), color=color.white)
mybox = box(pos=(0,5.5,0), length=11, height=1, width=1)
pointer = arrow(pos=(0,12,0), axis=(0,-6,0), shaftwidth=1, color=color.yellow)
mybox = box(pos=(0,-5,0), length=12, height=1, width=5, color=color.green)
forcelabel = label(pos=pointer.pos, text='Applied Load', xoffset=3, yoffset=5, space=1, height=10, border=6, font='sans')
pointer.velocity = vector(0,-3,0)
deltat = 0.005
t = 0
while t < 2.5:
rate(50)
if pointer.pos.y < 8:
pointer.velocity.y = -pointer.velocity.y
if pointer.pos.y > 12:
pointer.velocity.y = -pointer.velocity.y
pointer.pos = pointer.pos + pointer.velocity*deltat
t = t + deltat