1 D Structures Basic Concepts

CEE 379 1-D Structural Analysis Notes
The majority of the basic concepts and issues associated with structural analysis can be considered in
the simple context of 1-Dimensional structural systems, i.e., structural systems in which all members are
aligned in series or parallel, and in which all internal forces are axial. Although this is not a particularly
useful class of structural models from a practical point of view, it is very useful from a conceptual point of
view because it removes all extraneous complexity.
1 Mechanics of Materials Examples
Figure 1 shows a typical problem one encounters in a mechanics of materials course. The two axial bars
act in parallel in this case, and we assume we know the member properties (E, A, and L) for each bar,
and the magnitude of the applied load, P. As in any structural analysis problem, we need to determine the
displacements () and internal forces (member forces f
a
and f
b
in this case) in the system. This requires
P,
L
b
, E
b
, A
b
L
a
, E
a
, A
a a b
Figure 1: A simple 1-D structural system
us to use equilibrium, kinematics, and constitutive relations as follows:
Kinematics:
a
=
b
= (1)
Equilibrium:
P = f
a
+ f
b
(2)
Constitutive:
f
a
=
_
AE
L
_
a
a
(3)
f
b
=
_
AE
L
_
b
b
(4)
If we count up equations and unknowns, we have 5 unknowns (f
a
, f
b
,
a
,
b
, and ), and 5 equations
(equilibrium (1 equation), kinematics (2 equations), and constitutive relations (2 equations)). The equations
are all linear
1
, and so with 5 equations and 5 unknowns, we know that determining the unknowns is a simple
matter of doing some linear algebra.
1.1 Matrix Formulation
Because we eventually will be dealing with much larger and more complicated systems of equations, it is
worthwhile developing a systematic approach to solving these equations. To this end, lets rewrite the above
linear equations in matrix form:
1
The equations are linear because there are no expressions involving higher order terms like
2
, (f
a
)
2
, etc.
1
CEE 379 2
Kinematics:
_
b
_
=
_
1
1
_
{} (5)
Equilibrium:
{P} = [ 1 1 ]
_
f
a
f
b
_
(6)
Constitutive:
_
f
a
f
b
_
=
_ _
AE
L
_
a
0
0
_
AE
L
_
b
_ _
b
_
(7)
You should convince yourself that these matrix expressions are equivalent to equations (1)-(4). In fact, it
would be a good investment of your time to get to the point that you could sit down with a blank piece of
paper and derive all the equations presented here so far.
A Comment on Notation Throughout these notes square brackets ([]) denote quantities that in general
can be represented by rectangular matrices, while curly braces ({}) denote quantities that in general
can be represented using column matrices. At times this gets a bit verbose, but it provides a consistent
indication of the type of each expression.
Fundamentally, the matrix expressions (5)-(7) are simply a rearrangement of the original equations and
therefore introduce no additional physical principles or concepts. However, when written in matrix form, it
is possible to interpret the expressions as maps or transformations. With the introduction of some additional
notation, we can write our expressions as follows:
Kinematics:
{} = [B] {} (8)
Equilibrium:
{P} = [B]
T
{f } (9)
Constitutive:
{f } = [C] {} (10)
In these expressions, {} represents the member deformations, {} represents the system displacements, and
the matrix [B] corresponds to the kinematic mapping between these quantities. Similarly, {f } represents
the internal member forces and {P} represents the system forces. Note that the mapping between system
and member forces corresponds to the transpose of the kinematic map, [B]. As we will see, this is a general
result and not merely a coincidence in this example. The constitutive matrix [C] in equation (10) relates
member forces to member deformations. We will see that this matrix is symmetric in the general case, as it
is in this simple case.
We are now ready to use our linear algebra machinery to solve the original problem. In particular, we
can combine equations (8) and (10) to obtain an expression for the member forces in terms of the system
displacements:
{f } = [C] {} = [C] [B] {} (11)
We can now substitute this expression into the equilibrium equation (9) to obtain a direct relation between
system loads and system displacements:
{P} = [B]
T
[C] [B] {} (12)
The quantity [B]
T
[C] [B] apparently characterizes the relation between system loads and displacements, and
so it is like a system constitutive relation. For this reason, it is called the system stiness, and is traditionally
denoted [K]. Thus with [K] = [B]
T
[C] [B] we can write the equilibrium equation as follows:
{P} = [K] {} (13)
This rather innocuous looking equation is actually quite important, as it summarizes the formulation of any
linear structural analysis problem, and so it has a box around it.
CEE 379 3
We are now in a position to complete the solution to our problem. Given the system loads, we can
determine the system displacements as follows:
{} = [K]
1
{P} (14)
The inverse of the system stiness is called the system exibility, but it is rare that we actually compute
it explicitly. Once we have the system displacements, we have accomplished half our job, which was to
determine the system displacements. The other half of the job can be completed using equation (11), which
relates member forces to system displacements. We have in eect reduced the solution of the original set of
kinematics, equilibrium, and member constitutive relations to a set of basic matrix operations which can be
easily automated using a tool like MATLAB.
For the example in Figure 1 the algebra is simple enough that we can carry through the matrix operations
by hand to see how it goes. Comparing equations (5)-(7) with equations (8)-(10) we can see that in this case
the system stiness is
[K] = [B]
T
[C] [B] = [ 1 1 ]
_ _
AE
L
_
a
0
0
_
AE
L
_
b
_ _
1
1
_
(15)
=
__
AE
L
_
a
+
_
AE
L
_
b
_
(16)
This is a 1 1 matrix, which is easy enough to invert, so the system displacement is
{} =
_
1
_
AE
L
_
a
+
_
AE
L
_
b
_
{P} (17)
The forces in members a and b can be determined using equation (11), which expands in this case to:
_
f
a
f
b
_
=
_ _
AE
L
_
a
0
0
_
AE
L
_
b
_ _
1
1
_
_
1
_
AE
L
_
a
+
_
AE
L
_
b
_
{P} (18)
=
P
_
AE
L
_
a
+
_
AE
L
_
b
__
AE
L
_
a
_
AE
L
_
b
_
(19)
This problem was particularly easy to solve because the system displacement could be completely charac-
terized by a single value, and so the system matrices were all 1 1. A more general case is considered in the
next subsection.
1.2 Two Degree of Freedom Example
Figure 2 shows another simple conguration typical of what one encounters in mechanics of materials. As
before, we need to determine the system displacements and member forces given system forces. The dierence
in this case is that the system is characterized in terms of two displacements rather than just one. Each
displacement component necessary to characterize the kinematics of a system is called a degree of freedom,
and so this system has two degrees of freedom.
P
2
,
2
L
b
, E
b
, A
b L
a
, E
a
, A
a
P
1
,
1
A
B
C
Figure 2: A simple 1-D structural system with 2 degrees of freedom.
We will follow a procedure similar to the previous example, rst setting up the equations in longhand
form, and then transforming to matrix expressions to generate the solution. The fundamental relations in
this case can be written as follows:
CEE 379 4
Kinematics:
a
=
1
(20)
b
=
2

1
(21)
Equilibrium:
P
2
C
P
1
B
f
b
f
b
f
a
Figure 3: Free body diagrams for joints B and C. Member forces assumed positive (tensile).
P
1
= f
a
f
b
(22)
P
2
= f
b
(23)
Constitutive:
f
a
=
_
AE
L
_
a
a
(24)
f
b
=
_
AE
L
_
b
b
(25)
In equation (21) we have used the fact that the elongation of an axial member is simply the dierence in the
end displacements.
Writing these equations in matrix form, we get
Kinematics:
_
b
_
=
_
1 0
1 1
_ _
2
_
(26)
Equilibrium:
_
P
1
P
2
_
=
_
1 1
0 1
_ _
f
a
f
b
_
(27)
Constitutive:
_
f
a
f
b
_
=
_ _
AE
L
_
a
0
0
_
AE
L
_
b
_ _
b
_
(28)
From these relations we can make the following identication:
[B] =
_
1 0
1 1
_
(29)
Note that in this case [B] (and [B]
T
) is square and has a non-zero determinant. This means that we could
invert the relation between member forces and system loads directly, i.e., the problem is statically determinate
because we can determine the member forces without using deformations. Most structural analysis problems
are not statically determinate, but if [B]
T
can be inverted, we can construct the exibility matrix (i.e.,
[K]
1
) directly:
[K]
1
= [B]
1
[C]([B]
T
)
1
(30)
When computers were scarce, it was often worth using techniques based on exibility approaches in special
cases, but practically all analysis is now done using a straight stiness approach.
CEE 379 5
Having identied the degrees of freedom and the kinematic matrix, it is pretty much a matter of turning
the crank to generate the desired results. First we compute the system stiness as
[K] = [B]
T
[C] [B] (31)
=
_
1 1
0 1
_ _ _
AE
L
_
a
0
0
_
AE
L
_
b
_ _
1 0
1 1
_
(32)
=
_ _
AE
L
_
a
+
_
AE
L
_
b

_
AE
L
_
b
_
AE
L
_
b
_
AE
L
_
b
_
(33)
Its not too hard to invert a 2 2:
[K]
1
=
1
D
_ _
AE
L
_
b
_
AE
L
_
b
_
AE
L
_
b
_
AE
L
_
a
+
_
AE
L
_
b
_
(34)
in which D =
__
AE
L
_
a
+
_
AE
L
_
b
_ _
AE
L
_
b
_
AE
L
_
2
b
=
_
AE
L
_
a
_
AE
L
_
b
. For simplicity we will consider the special
case in which P
1
= 0, P
2
= P. In this case, the system displacements are
_
2
_
=
1
D
_ _
AE
L
_
b
_
AE
L
_
b
_
AE
L
_
b
_
AE
L
_
a
+
_
AE
L
_
b
_ _
0
P
_
(35)
=
P
D
_ _
AE
L
_
b
_
AE
L
_
a
+
_
AE
L
_
b
_
(36)
= P
_ _
L
AE
_
a
_
L
AE
_
b
+
_
L
AE
_
a
_
(37)
The member forces can again be computed using equation (11):
_
f
a
f
b
_
= [C] [B] {} (38)
=
_ _
AE
L
_
a
0
0
_
AE
L
_
b
_ _
1 0
1 1
_
P
_ _
L
AE
_
a
_
L
AE
_
b
+
_
L
AE
_
a
_
(39)
= P
_
1
1
_
(40)
This nal result matches what we could have seen from inspection in this case: the applied load P simply
propagates uniformly through the members.
1.3 Numerical Computation
In practical situations, calculations are carried out numerically rather than symbolically, and a tool that
supports matrix operations such as MATLAB becomes quite useful. Consider again the example in Figure 2
with the following numerical values: L
a
= 5 ft; A
a
= 2 in
2
; E
a
= 10, 000 ksi; L
b
= 8 ft; A
b
= 1.0 in
2
;
E
b
= 29, 000 ksi; P
1
= 5 kip; and P
2
= 2 kip. The MATLAB code in Figure 4 can be used to solve this
problem, and the resulting output is shown in Figure 5. These results are easy to verify by hand, and you
should do so.
1.4 Conceptual Summary
The basic set-up we used in the previous examples is suciently important and general that it is worth
summarizing in a pictorial manner. Figure 6 shows the relationships between the system and member
variables of interest, and the role played by the principles of equilibrium, kinematics, and constitutive
relations. Note how this diagram can be used to compose mathematical relations to get from one quantity
to another. For example, if we know system displacements and want to calculate member forces, we start in
the System Displacements box, apply the kinematics relation [B] to get to the Member Deformations box,
and then apply the constitutive relation [C] to get to the desired Member Force box. Recalling that applying
matrix operations in series leads to a right-to-left ordering, we have {f} = [C][B] {}. This matches the
result we derived earlier in equation (11).
CEE 379 6
%%---Simple Spring Example
%%---Useful constants
ft = 12;
%%---Physical Quantities
A_a = 2; %in^2
L_a = 5*ft;
E_a = 10000; %ksi
A_b = 1; %in^2
L_b = 8*ft;
E_b = 29000; %ksi
%%---System Kinematic Matrix
B = [1 0; -1 1];
%%---System Constitutive Matrix
C = [A_a*E_a/L_a 0; 0 A_b*E_b/L_b];
%%---System Stiffness
K = B * C * B;
%%---System Load
P = [5; 2]; %kips
%%---System Displacement
sysDisp = K\P;
%%---Quick and Dirty Output
sysDisp
%%---Member Forces
memForce = C * B * sysDisp;
%%---Quick and Dirty Output
memForce
Figure 4: MATLAB code for solving simple mechanics of materials example.
sysDisp =
0.0210
0.0276
memForce =
7.0000
2.0000
Figure 5: MATLAB results for code in Figure 4
System

Displacements
Member

Deformations
Kinematics/Compatibility [B]
Member

Forces
System

Forces
Equilibrium [B]
T
{}
{}
{P}
{f} Constitutive [C]
Stiffness [K]
Figure 6: Fundamental quantities and relations of structural analysis.
CEE 379 7
Load Paths
An important concept in structural engineering is that of a load path. A load path describes the
way in which a load applied at a particular point in a structure is carried through to the structures
supports. For example, the weight of a person standing on the 4th oor of an oce building might
follow a load path something like the following: the weight is transferred from the oor to supporting
beams, from the supporting beams over to supporting columns, and then through the columns on
down to the foundation. An important part of structural design is identifying and accommodating
load paths for all loads acting on the structure.
a
b
a
b
Statically Indeterminate Statically Determinate
Load paths for the simple examples we have considered so far are illustrated above. The gure
illustrates that an indeterminate system typically allows for multiple equilibrium-satisfying load
paths, while in a determinate system, the load path that satises equilibrium is unique. In the
indeterminate system, the amount of the load owing to each member is proportional to its
stiness. The general rule of thumb is that stiness attracts force, and so if one of the bars in the
statically indeterminate conguration shown were made of rubber and the other of steel, the steel
bar would carry virtually all the load.
2 General Spring Models
The mechanics of materials examples in the previous section are simple, but not necessarily compelling
because the formal matrix machinery appears to be overkill. To allow us to conveniently scale up to larger
problems we will replace the axial bar models with simple springs. The only real dierence this introduces
into our formulations is that we will replace expressions of the form f = (AE/L) with expressions of
the form f = k. Figure 7 shows a typical conguration we can use to further develop our theories and
2

3
1
2
3 4
k
d
k
a
k
b
k
c
Figure 7: A 1-D structural system based on simple springs.
procedures.
Well start by setting up the fundamental relations for this problem in the same manner as before, except
we will initally ignore the boundary condition constraints that
1
=
4
= 0. This gives us the following set
of equations:
Kinematics:
_
d
_
_
=
_
_
1 1 0 0
0 1 1 0
0 0 1 1
1 0 1 0
_
_
_
4
_
_
(41)
CEE 379 8
Equilibrium:
_
_
P
1
P
2
P
3
P
4
_
_
=
_
_
1 0 0 1
1 1 0 0
0 1 1 1
0 0 1 0
_
_
_
_
f
a
f
b
f
c
f
d
_
_
(42)
Constitutive:
_
_
f
a
f
b
f
c
f
d
_
_
=
_
_
k
a
0 0 0
0 k
b
0 0
0 0 k
c
0
0 0 0 k
d
_
_
_
d
_
_
(43)
In setting up these equations, it was easiest to gure out the kinematics relations and then simply transpose
them to get the equilibrium relations. You should verify for yourself that resulting equilibrium relations
make sense (drawing freebody diagrams, if necessary).
Note that the equilibrium equations are such that [B]
T
is square. At a glance this might seem to imply the
problem under consideration is statically determinate, but remember that [B]
T
being square is a necessary
but not sucient condition for determinacyits also necessary that the matrix be invertible. The easiest
check on this is to compute the determinant, which in this case turns out to be zero (in the case of a 4 4
system, using something like MATLAB to compute the determinant is most expedient). Physically, if the
supports at joints 1 and 4 in Figure 7 are removed, then the structure is unstable: applying loads would in
general cause translation of the entire structure. We will have a more general means to characterize this
kind of instability shortly.
With the fundamental relations dened, we can generate a direct relation between system forces and
system displacements in the usual way by computing the system stiness:
[K] = [B]
T
[C][B] (44)
=
_
_
k
a
+ k
d
k
a
k
d
0
k
a
k
a
+ k
b
k
b
0
k
d
k
b
k
b
+ k
c
+ k
d
k
c
0 0 k
c
k
c
_
_ (45)
Note that while [B] is square only in special cases (e.g., what happens to [B] in this case if member d is
removed?), the system stiness is always square. Again, it is important to note that this does not necessarily
imply that the stiness can be inverted. In the present case, we know that the structure as currently modeled
has no supports and is therefore unstable. This physical fact is manifested mathematically by consideration
of the determinant: if the determinant of the system stiness is zero, we cannot invert the stiness, and so
there is not a unique relation between applied load and displacement. In eect, the structure can displace
arbitrarily to some degree, and this is what we consider unstable behavior.
For reasons that we can not fully explain yet, it also turns out that the system stiness can not have a
negative determinant and be physically stable. A simplied explanation of this is to consider a single spring
supported at one end, for which the system stiness is simply a 1 1, i.e., [K] = [k]. For the determinant
to be negative, k < 0, and this means we have a spring which responds to load not by resisting deformation,
but rather by encouraging deformation. If you pull on the spring is pushes you in the direction you are
pulling. This implies you can get more work out of the system than you put in, and our universe does not
allow that.
Taken together, these observations lead us to the following useful fact:
For a stable structure, the system stiness will have a positive determinant.
This is an important analytical result with signicant physical ramications and many practical applications.
The system stiness in equation (45) in eect embodies our model of the structure. Although it is not
dicult to see how a computer can quickly construct such a system stiness via matrix multiplication, it
is not a particularly intuitive process in a physical sense. By considering the physical ramications of the
system stiness, we will gain a better understanding of whats going on, and even more signicantly, we will
discover more eective ways to construct system stinesses for both hand and computer-based calculation.
CEE 379 9
2.1 Physical Interpretation of Stiness Components
Globally speaking, the system stiness relates system displacements to system loads: if we know how the
structure is displaced, we can determine what loads must be acting to cause that displacement. We know
that we usually face the problem the other way around, i.e., we know the forces and wish to determine the
displacements, but for purposes of physical interpretation, we can keep a displacement-centric view of our
structure
2
.
To help understand what the terms of a stiness matrix mean, we will consider a special case for the
displacement of the structural system in Figure 7. In particular, consider the case shown in Figure 8. Here
2
= 1
3
= 0
1
2
3 4
k
d
k
a
k
b
k
c
1
= 0
4
= 0
Figure 8: Spring structure subjected to a unit displacement at joint 2; all other joints held xed.
we have displaced joint 2 by a unit amount (e.g., 1in, 1mm, etc., depending on our units) while keeping all
the other joints xed. We can use our system stiness to determine the corresponding system forces
3
:
_
_
P
1
P
2
P
3
P
4
_
_
=
_
_
k
a
+ k
d
k
a
k
d
0
k
a
k
a
+ k
b
k
b
0
k
d
k
b
k
b
+ k
c
+ k
d
k
c
0 0 k
c
k
c
_
_
_
_
0
1
0
0
_
_
(46)
=
_
_
k
a
k
a
+ k
b
k
b
0
_
_
(47)
There are two primary things to note here:
1. The system forces necessary to sustain the given unit displacement at joint 2 correspond to the second
column of the system stiness.
2. It would not be dicult to construct the set of system forces in equation (47) directly by considering
the problem physically, looking at the forces associated with each spring individually. If we know how
the ends of a spring are displaced, then we know the end forces directly, so this is simple to do. Try it!
The rst of these observations has general ramications for understanding the physical meaning of a particular
stiness component, K
ij
. To see this, note that if we displace joint 3 instead of joint 2 (see Figure 9) then
we get the following set of required system joint forces to maintain the given displacement:
_
_
P
1
P
2
P
3
P
4
_
_
=
_
_
k
a
+ k
d
k
a
k
d
0
k
a
k
a
+ k
b
k
b
0
k
d
k
b
k
b
+ k
c
+ k
d
k
c
0 0 k
c
k
c
_
_
_
_
0
0
1
0
_
_
(48)
=
_
_
k
d
k
b
k
b
+ k
c
+ k
d
k
c
_
_
(49)
2
Formulations based on displacements as the primary variables are called, not surprisingly, Displacement Methods. There
is another class of formulations called Force or Flexibility Methods, which are based on using forces as the primary variables.
Force methods are not well-suited to general computer implementation, and so they are not used much any more, but we will
give them some consideration later.
3
Even though the system is unstable with respect to applied force, if we completely specify the displacements as we are
doing here, we do not have any problem with arbitrary displacement.
CEE 379 10

3
= 1
2
= 0
1
2
3 4
k
d
k
a
k
b
k
c
1
= 0
4
= 0
We could could do further examples, but it should not be dicult to convince yourself of the following
general fact:
Each column in a 1-D spring system stiness matrix corresponds to the set of joint forces caused
by imposing a unit displacement to the corresponding joint (column 2 joint 2, column 3 joint
3, etc.)
You have to be a little careful about the units, but this is a very handy way of thinking about stinesses. It
also allows us to further identify each entry i in the jth column, K
ij
, as having the following meaning:
Each stiness entry, K
ij
, in a 1-D spring system stiness matrix corresponds to the force at joint
i induced by imposing a unit displacement at joint j.
Again, the K
ij
components do not have force units, but as long as one interprets the corresponds in the
above statement appropriately, this is a very powerful tool for physical understanding.
2.2 Direct Stiness by Hand
The two observations noted in the previous section can be combined to provide a means to construct system
stinesses directly by hand. Given a structural system, we can construct the stiness column by column by
simply visiting each joint in turn, applying a unit displacement, and determining the joint forces induced by
the displacement. For any problem of a size for which hand calculation makes sense, this is pretty simple to
do, as illustrated in the following example.
Example 1 Construct the rst column of the system stiness for the structure in Figure 7, ignoring the
supports.
Solution We proceed by sketching the displaced structure for the case in which the rst joint is given a
unit displacement and all other joints are held xed as shown in Figure 10. Looking at the gure, it
1
2
3 4
k
d
k
a
k
b
k
c
1
= 1

2
= 0
3
= 0
4
= 0
can be seen that the force that must be applied at joint 1 to sustain the unit displacement of joint 1 is
the sum of the forces necessary to compress springs a and d, i.e., P
1
k
a
+ k
d
. Similarly, the force at
joint 2 must act to the left (the negative direction) and match the compressive force in spring a, and so
we get P
2
k
a
. Joint 3 requires a negative force matching the compression in member d, P
3
k
d
.
Finally, joint 4 has no deformed springs framing in, so no force is necessary, P
4
0. Putting these
CEE 379 11
pieces together, we get the rst column of the stiness:
{K
i1
} =
_
_
k
a
+ k
d
k
a
k
d
0
_
_
Note that this result matches what we obtained earlier via the matrix multiplication procedure.
Example 2 Construct the complete system stiness for the structure shown in Figure 11, ignoring the right
support.
1 2 3
4
k
a
k
b
k
c
Figure 11: Simple spring structure.
Solution Figure 12 contains a series of imposed unit displacements applied to each joint of the structure in
turn. By determining the joint forces associated with each displacement, we can construct the stiness
column by column. By exploiting the symmetry of the system stiness, we can do this relatively
1 2 3
4
k
a
k
b
k
c
1 2 3
4
k
a
k
b
k
c
1 2 3
4
k
a
k
b
k
c
1 2 3
4
k
a
k
b
k
c
1
= 1
2
= 1
3
= 1
4
= 1
Figure 12: Spring structure subjected to a unit displacement at each of joints 1, 2, 3, and 4.
quicklywe only need consider the joint forces on the joints including and ahead of the joint being
displaced. The resulting stiness is thus
[K] =
_
_
k
a

k
a
k
a
+ k
b

0 k
b
k
b
+ k
c
0 0 k
c
k
c
_
_ (50)
The dots in the above equation indicate entries that we can obtain from symmetry rather than from
scratching our head. If it is not obvious to you, you should use symmetry to ll in all the stiness
entries, and then convince yourself that these entries are consistent with the reaction forces you would
expect for each corresponding displacement case.
Dr. Frame Exercise To get more of a hands-on feel for the relation between individual joint displacements
and the corresponding stiness components, you can use Dr. Frame to get an inside view of whats
happening as you displace the joints in a structure. Figure 13 shows the Dr. Frame model we will
use to mimic the simple spring model from the previous example. The following steps will guide you
through setting up this model, and then show you how to apply displacements and observe the induced
member forces and joint reactions.
CEE 379 12
Figure 13: Dr. Frame conguration for studying axial system stiness behavior.
1. Start up Dr. Frame, and use the Aux Diagram popup in the Options menu to hide the moment
diagram.
2. Select Delete All from the Edit menu to clear the model.
3. Select the Fixed Support Tool from the tool palette and click on a grid point on the left side of
the grid to create a xed support.
4. Click three more times along a horizontal row to create the additional supports indicated in
Figure 13
4
.
5. Choose the Rigid-Ended Member Tool and click once on the rst support, and then click on
the second support to add a member. Add the remaining three members by clicking on the
corresponding end nodes, and you should have a conguration matching that in Figure 13.
6. Choose the Select Tool from the tool palette, and now you are ready to impose displacements,
and observe the consequences. Click on the second support from the left to select it (click on
the triangular bottom part), and then hit the right and left cursor keys a few times. You should
observe the horizontal translation of the joint you have selected.
7. Type 0 (zero) to return the joint to its original location, and now we will give ourselves something
more interesting to see as we impose displacement. Type s to turn on member force display, and
then type f to turn axial force coloring
5
. Type 8 to turn on reaction display, and then nally
type . (period) to set the force display to use xed arrow sizes (for axial displacements of this
kind, the reaction forces are very large and go o the screen if we scale them by magnitude).
8. The support you moved previously should still be selected, so go ahead and use the right cursor
key to displace the joint to the right. This time you should see several interesting things happen,
some of which are shown in Figure 14 (Type n if you want your joints labeled as in the gure).
In particular, you should see joint reaction forces appear in green, member forces will become
non-zero, and the members adjacent to the second joint will change color. As you can probably
surmise, red indicates compression, and blue indicates tension. Depending on how far apart you
set your supports, the labels may be overlapping. This can be remedied by zooming in a bit.
There are zoom buttons on the bottom of the tool palette (Mac OS) or on the tool bar above the
window (Windows), and you can use these to zoom in and out.
0 k -242 k 242 k
242 k 483 k 242 k
D
C B
A
Figure 14: Joint reaction force and member force display for translation of joint B .
9. Look at the reactions and member forces, both signs and relative magnitudes, and compare your
observations qualitatively to the second column of the system stiness from the previous example.
In eect Dr. Frame is explicitly doing the analysis we did in our heads when we did that example.
10. Type 0 (zero) to put the support back in its original location, and then use the Select Tool to
select one of the other joints (remember to click on the triangular bottom) and move it around
with the cursor keys (dont use the up and down keys yetwell do that later when we are studying
beam systems). Again, work on aligning your observations with your intuition, and compare what
the Dr. Frame model depicts to the stiness components derived above.
You might want to save this model for future usejust use the standard Save command. If you have
time, you might try these further exercises:
4
Dr. Frame has 10 levels of undo, so if you do something unintended, just undo it.
5
There are menu commands for all these operations, but the key shortcuts are quicker to use and identify in these exercises
CEE 379 13
1. Double-clicking (or right-clicking in Windows) on a member brings up a member properties dialog.
This will have much more information than you need for this simple example, but by locating
the cross sectional area, A, and the elastic modulus, E, you will be able to do numerical hand
calculations to compare with Dr. Frames results. You can get the members lengths by selecting
them and typing w.
2. Use the member properties dialog to change a members area or elastic modulus, and observe the
change in the joint reactions and member forces (note that you do not have to close the dialog
to see the changesjust move the dialog out of the way and use the Preview button). Does what
you observe make sense to you?
3. Using the Select Tool you can change the member lengths by clicking and dragging the joints
horizontally (be sure not to click on the support triangles in this caseclick on the joint boxes
instead). Again, see if the eect on the member forces and joint loads is what you expect.
2.3 Direct Stiness via Assembly
The direct construction of the system stiness used in the previous section is useful for partial hand calcula-
tions, but it is not particularly well-suited for computer implementation. We therefore need to derive a more
computer-friendly approach to constructing system stinesses directly. Our approach will be to characterize
the stiness of an isolated member, and then observe how each members stiness inuences the overall
system stiness. In eect, we will derive a means to construct a system stiness by simply adding together
(assembling) the contributions of each individual element in the system.
2.3.1 Member Stiness
If we consider a structure composed of a single spring, the corresponding system stiness must be the member
stiness for the spring, since the member and the system coincide in this case. Figure 15 shows such a simple
conguration. Using the longhand approach, we have the following fundamental relations in this case:
j
i
j
k
e
i
Figure 15: A single-spring structurei.e., a generic spring element, e, with end joints i and j.
Kinematics:
e
=
j

i
(51)
Equilibrium:
P
i
= f
e
(52)
P
j
= f
e
(53)
Constitutive:
f
e
= k
e
e
(54)
From these relations we can see that [B] = [ 1 1 ] and [C] = [k
e
]. The system/element stiness is thus
[K] =
_
k
e
k
e
k
e
k
e
_
(55)
Let us dene the element stiness as the relation between system displacements and the elements contri-
bution to the system loads for those specic displacements and loads associated with the element. Note that
since in this case the system and the member are the same, the element stiness for the spring element is
given by equation (55). This is an important and useful enough result that we will highlight it in a box:
CEE 379 14
1-D Spring Element Stiness
[k]
e
=
_
k
e
k
e
k
e
k
e
_
Element stinesses represent the behavior of the corresponding structural member or component, and thus
are the fundamental building block of structural models, just like physical structural members are the building
blocks of real structures. Note that using the column-by-column stiness construction described previously
leads very quickly to the same result as given above. Note also in the case of the single element stiness, it
is simple to compute the determinant by hand. Is the system stable?
Before looking at the relation between system stinesses and element stinesses in the general case, we
also can highlight the following important element result:
1-D Spring Element Force
f
e
= [ k
e
k
e
]
_
j
_
This is simply the specic case of the general relation we derived earlier: {f} = [C][B][]. The importance
of this relation is that it provides the means by which we can determine the force in each spring, e, once we
have solved for the system displacements.
2.3.2 System Disassembly
Our strategy to see how structural models are assembled from their components will again mimic what would
be sensible in the physical case: we will disassemble the model and see how it is constructed. This will gives
us the knowledge we need to put models together mathematically.
Consider the simple 3-element spring model shown in Figure 16. The stiness for this structure matches
1 2 3 4
k
a
k
b
k
c
Figure 16: 3-Element spring structure with no supports.
that in the second example from the previous section, since at this point we have not been including the
eect of supports. Therefore, the system stiness is
[K] =
_
_
k
a
k
a
0 0
k
a
k
a
+ k
b
k
b
0
0 k
b
k
b
+ k
c
k
c
0 0 k
c
k
c
_
_ (56)
To take this structure apart, consider the sequence of congurations in Figure 17. Here the structure has
been disassembled into its pieces. The system stiness for case (a) can be obtained from the expression in
(56) by simply setting k
b
= k
c
= 0 (removing the stiness of these elements is equivalent to removing the
elements themselves). The result is as follows:
_

K
a
_
=
_
_
k
a
k
a
0 0
k
a
k
a
0 0
0 0 0 0
0 0 0 0
_
_ (57)
Similarly we can write the stinesses for cases (b) and (c) as:
_
K
b
_
=
_
_
0 0 0 0
0 k
b
k
b
0
0 k
b
k
b
0
0 0 0 0
_
_ (58)
CEE 379 15
1 2 3 4
k
a
1 2 3 4
k
b
(a)
(b)
1 2 3 4
k
c
(c)
Figure 17: Spring structure disassembly: (a) Member a alone; (b) Member b alone; (c) Member c alone.
_
K
c
_
=
_
_
0 0 0 0
0 0 0 0
0 0 k
c
k
c
0 0 k
c
k
c
_
_ (59)
There are two things to note about these expressions. First, the overall system stiness is simply the sum
of the system stinesses for each component:
[K] =
e
[

K
e
] (60)
Second, and perhaps most important, if you compare the entries in each of the subassembly stinesses, [

K
e
],
to the standalone stiness for a generic spring element we derived above, you can see that the only non-zero
entries in each [

K
e
] consist simply of a copy of the smaller standalone stiness components. The only trick
is putting the components from the smaller element stiness into the correct places in the overall system
stiness. The details of doing this are covered in the next section, but for now we can conclude that if
we can do this elementsystem transfer correctly, then we can construct system stinesses by looping over
the elements or members in the structure, compute each elements standalone stiness, and then add these
stiness components to the overall system stiness. This procedure is called assembly, and although we are
only considering 1-D spring structures at this point, we will see that this is a general procedure that can be
used for any structural model of arbitrary size and complexity.
CEE 379 16
2.3.3 Assembly
Conceptually, assembly is simply the process of accumulating element stiness components into a structures
system stiness. The actual mechanism used to carry this out is more an algorithmic issue than anything
else. As with any algorithm, there is a tie between the method used for accomplishing the task and the
technique used to store the data. Here we will assume the simplest data storage model: a fully populated
matrix. In this case, we can accomplish assembly for 1-D spring structures as follows:
1. Start with a system stiness sized appropriately to hold the system stiness with all entries set to zero.
For a 1-D spring structure with N joints, this implies an N N scalar matrix (do you see why this is
the appropriate size?). This essentially represents the structure with no elements or members.
2. For each member or element e, do the following:
(a) Compute the element stiness [k]
e
. For 1-D springs this will be a scalar 2 2 as derived earlier.
(b) Loop over the element stiness components and add them to the system stiness as follows:
for r = 1, 2
for s = 1, 2
K
I(e,r)I(e,s)
= K
I(e,r)I(e,s)
+ k
e
rs
end for
end for
After looping over all the elements, the system stiness will be complete. As indicated by the pseudo code
above, this is a process best suited for computer implementation rather than human bookkeeping. The key
to the process is in understanding the index mapping implied by the notation of the form I(e, r) that appears
in the subscripts in the pseudo code. Conceptually, I(e, r) answers the question: for element e and joint r,
what is the system joint number, I? This is actually an easy question to answer for a particular element
in a particular structure. For example, consider the 3-element structure shown in Figure 16 in the previous
section, and look at element b. In the pseudo code above, when r = 1 it refers to the elements rst end,
and when r = 2, it refers to the elements second end. For element b, then, we can see from the picture
that I(b, 1) = 2 (element bs rst system joint is 2) and I(b, 2) = 3 (element bs second system joint is 3).
Similarly, I(a, 1) = 1 and I(a, 2) = 2, and you should try to do element c yourself.
In practice, the map I(e, r) is not really implemented as a function, but rather is implemented by carrying
along member data. Thus, each member has an associated rst and second system index, and these indices
are used by the element itself to accomplish assembly. All of this is best illustrated with some actual code
that works, and so lets consider some MATLAB code we could use to build stiness matrices for arbitrary
1-D spring assemblages.
2.3.4 MATLAB Example Code
Figure 18 shows simple MATLAB code that handles the assembly of a single element stiness, adding the
appropriate terms into the overall system stiness. The code is relatively self-explanatory, with the one
tricky item perhaps being the index map. The index map plays the role of the I(e, r) function introduced
in the previous section, essentially mapping the elements rst and second (i.e. r, s = 1, 2) joints to the
corresponding system indices. This allows the actual installation code at the end of the function to be
written in the relatively compact loop shown.
For simple elements such as this, and in fact in many general cases, it is neither necessary nor ecient
to implement the assembly using loops. The code in Figure 19 is an alternative implementation of spring
element assembly, and you will probably agree it is simpler. It is shorter and more ecient, as well.
Regardless of which style of implementation one uses for the element assembly, code of the kind shown in
Figure 20 is necessary to actually set up the system stiness for structure with multiple members or elements.
The rst part of this code could be turned into simple le-based i/o, and then we would have in eect a
simple program that could read in a le composed of element properties and connectivity information, and
compute the corresponding system stiness. The second part of the code could be put in its own separate
function, since it handles the actual system assembly. Note, however, that the second part of the code relies
directly on the data storage style implicit in the rst part of the code. Keeping the two parts of the code
together makes this link explicit, and there are various advantages to doing things this way. Ultimately, the
CEE 379 17
function [sys_K] = Spring_InstallKe(i,j,ke,sys_K);
%---Input variables
% i,j = system node ids for spring ends
% ke = spring stiffness
% sys_K = system stiffness into which element stiffness is assembled
%---Compute stiffness
element_k = ke * [1,-1;-1,1];
%---Set up index map
Idx = [i, j];
%---Install element stiffness in system stiffness
for r = 1:2
for s = 1:2
sys_K(Idx(r),Idx(s)) = sys_K(Idx(r),Idx(s)) + element_k(r,s);
end
end
%---set return value
Spring_InstallKe = sys_K;
Figure 18: MATLAB code for spring element assembly.
function [sys_K] = Spring_InstallKe(i,j,ke,sys_K);
%---Input variables
% sys_K = system stiffness into which element stiffness is assembled
%---Simple direct assembly
sys_K(i,i) = sys_K(i,i) + ke;
sys_K(i,j) = sys_K(i,j) - ke;
sys_K(j,i) = sys_K(j,i) - ke;
sys_K(j,j) = sys_K(j,j) + ke;
Spring_InstallKe = sys_K;
Figure 19: Alternative code for spring element assembly with no looping and simpler implementation.
CEE 379 18
%%---This script illustrates a simple implementation of an automated
%% spring system stiffness assembler
%%=======================Input data (Could read from file)======
%%---Set problem size
sys_size = 4;
%%---Element definitions
%% Each row defines an element--> [Joint_i, Joint_j, ke]
Elements = ...
[ 1, 2, 100.0; ...
2, 3, 200.0; ...
3, 4, 300.0; ...
1, 3, 200.0
];
%%=====================End data input===========================
%%---Set up some constants for indexing
jointi = 1;
jointj = 2;
ke = 3;
%--- Step 1: Start with sys_K = all zeros
sys_K = zeros(sys_size,sys_size);
%--- Step 2: loop over elements and assemble stiffnesses
num_elts = size(Elements,1);
for e = 1:num_elts
sys_K = Spring_InstallKe(Elements(e,jointi),Elements(e,jointj),Elements(e,ke),sys_K);
end
%--- Simple output
sys_K
Figure 20: Stiness building script for the structure in Figure 8, with numerical values for the various k
e
.
focus here is not on programming detailsthe code is intended to indicate how assembly works, and how it
is relatively simple to implement, at least in principle.
Exercises Here are some things to think about and/or try to do:
1. See if you can think of a way to generate [B] and [C] automatically from input similar to that
used in the assembly code in Figure 20. Try out your approach.
2. Think about what the assembly code would look like if we did not ignore the presence of the
structures supports.
3. Modify the given code so that it works by reading in a le containing the element data.
2.4 Constraints
Now that we have a means to assemble stinesses relatively directly, we need to go back and gure out how
to handle supports. We have seen earlier that one simple way to account for the presence of supports is to
simply remove the associated joint displacements from the problem. While this works, it is worth thinking
about this a bit more generally. One useful perspective for thinking about solving systems of equations of
this kind for displacements given load is to imagine a process by which you must adjust the displacements at
each joint in the structure until you nd the unique set of displacements for which equilibrium is satised.
In the presence of supports, there are some displacements you are not allowed to adjust, since these joints
have pre-determined displacement values (generally zero, but not always, as we will see). Each displacement
you are free to adjust is called a degree of freedom, and the inclusion of support conditions in eect takes
some degrees of freedom and makes them no longer free. To account for this change in categorization, it is
useful to partition the joint displacements into two groups: free (which we will denote {
f
}) and supported
CEE 379 19
(which we will denote {
s
}). In general we can thus view the addition of supports as a partitioning of the
system displacements into free and supported groups:
{}
_
{
f
}
{
s
}
_
(61)
This partitioning carries through to the system equations in a natural manner as follows:
{P} = [K] {}
_
{P
f
}
{P
s
}
_
=
_
[K
ff
] [K
fs
]
[K
sf
] [K
ss
]
_ _
{
f
}
{
s
}
_
(62)
in which {P
f
} refers to loads applied at free joints, {P
s
} refers to forces applied at the supports (i.e., the
support reactions), and the stiness component subscripts indicate interactions between the displacement
and load groups.
With the system equations partitioned into free and supported parts, we can now look in more detail at
the general issue of solving for displacements for a given set of loads. In the partitioned system of equations
in (62), the unknowns are the
f
s and the support reactions, {P
s
}. To see how to solve for these unknowns
in the general case, we can simply expand the partitioned system into a longhand form:
{P
f
} = [K
ff
] {
f
} + [K
fs
] {
s
} (63)
{P
s
} = [K
sf
] {
f
} + [K
ss
] {
s
} (64)
The rst of these relations involves only one of our unknowns ({
f
}), so we can use this equation to solve
for the free displacements:
{
f
} = [K
ff
]
1
({P
f
} [K
fs
] {
s
}) (65)
Note that in the event the support displacements are all zero, this relation reduces to the simple-minded
approach of ignoring constrained joints in setting up the problem. In this more general form, we can handle
the case of imposed support displacements
6
as well as the usual applied loads. Once we have the free
displacements calculated, we can then use equation (64) to determine the support reactions. This requires
no inversion or solutionthe terms on the right hand side of the equation are all known.
Clearly this more general consideration of supports is somewhat more complex than simply ignoring
supported joints, but it adds value in two ways:
1. We can handle cases involving support settlement.
2. We can determine the support reactions directly.
Example 1 Figure 21 shows again a simple conguration we used in an earlier example, with a load applied
at the left end. Lets use the general approach to determine the displacements and support reaction
at joint 4. After setting the problem up symbolically, we will switch over to the following numerical
values: k
a
= 100 k/in, k
b
= 150 k/in, k
c
= 200 k/in, and P = 10 kips.
1 2 3
4
k
a
k
b
k
c
P
Figure 21: Simple spring structure with support.
Solution From before, we know the relation between load and displacement for this structure can be written
as follows
_
_
P
1
P
2
P
3
P
4
_
_
=
_
_
k
a
k
a
0 0
k
a
k
a
+ k
b
k
b
0
0 k
b
k
b
+ k
c
k
c
0 0 k
c
k
c
_
_
_
4
_
_
(66)
6
Foundation settlement is a practical example of an imposed joint displacement
CEE 379 20
%%---Simple script for support example 1
%%---Values
sysK_ff = [100 -100 0; -100 250 -150; 0 -150 350]; % k/in
sysK_sf = [0 0 -200]; % k/in
sysK_ss = [200]; % k/in
sysK_fs = sysK_sf;
sysP_f = [10 ; 0 ; 0]; % kips
sysDisp_s = [0]; % in
%%---Solution
sysDisp_f = sysK_ff\(sysP_f - sysK_fs * sysDisp_s);
sysP_s = sysK_sf * sysDisp_f + sysK_ss * sysDisp_s;
%%---simple output
fprintf(1, ---Displacements: \n);
fprintf(1, Delta_%d = %f inches \n, 1, sysDisp_f(1));
fprintf(1, ---Support Reactions: \n);
fprintf(1, P_%d = %f kips \n, 4, sysP_s(1));
-----------Output---------
---Displacements:
Delta_1 = 0.216667 inches
---Support Reactions:
P_4 = -10.000000 kips
Figure 22: Matlab script for computing support Example 1 results.
The support at joint 4 can be accounted for by partitioning as follows:
_
_
P
1
P
2
P
3
P
4
_
_
=
_
_
k
a
k
a
0 0
k
a
k
a
+ k
b
k
b
0
0 k
b
k
b
+ k
c
k
c
0 0 k
c
k
c
_
_
_
4
_
_
(67)
From this relation we can make the following identications:
{P
f
} =
_
_
_
P
1
P
2
P
3
_
_
_
=
_
_
_
10
0
0
_
_
_
kip (68)
{P
s
} = { P
4
} (69)
{
f
} =
_
_
_
3
_
_
_
(70)
{
s
} = {
4
} = { 0 } (71)
[K
ff
] =
_
_
k
a
k
a
0
k
a
k
a
+ k
b
k
b
0 k
b
k
b
+ k
c
_
_
=
_
_
100 100 0
100 250 150
0 150 350
_
_
k/in (72)
[K
sf
] = [K
fs
]
T
= [ 0 0 k
c
] = [ 0 0 200 ] k/in (73)
[K
ss
] = [k
c
] = [200] k/in (74)
In these expressions we have put in the specic data relevant to the current problem. With the
numerical values in place, it is convenient to switch over to MATLAB to do actual computations
reected in equations (65) and (64). The simple script in Figure 22 carries out the required calculations,
and the results are included in Figure 22, as well. Note that the resulting support reaction is
CEE 379 21
P
4
= 10 kips, which is as we would expect in this case. Apparently the machinery is working, at
least in this case.
Example 2 Figure 23 shows another of our earlier spring structures, in this case with a load applied at
joint 3. Given k
a
= 100 k/in, k
b
= 150 k/in, k
c
= 200 k/in, k
d
= 50 k/in, and P = 10 kips, we need
to determine the displacements and support reactions.
1
2
3 4
k
d
k
a
k
b
k
c
P
Figure 23: General spring model with a load, P, at joint 3.
Solution Our approach will be similar to the previous example, but this time we will MATLAB handle
more of the details for us. In particular, we start with the full stiness we derived earlier, including
the numerical values given:
[K] =
_
_
k
a
+ k
d
k
a
k
d
0
k
a
k
a
+ k
b
k
b
0
k
d
k
b
k
b
+ k
c
+ k
d
k
c
0 0 k
c
k
c
_
_ =
_
_
150 100 50 0
100 250 150 0
50 150 400 200
0 0 200 200
_
_k/in (75)
Similarly, the full applied load matrix can be written as:
{P} =
_
_
0
0
10
0
_
_
kip (76)
From the gure we can see that the free joints are 2 and 3, and the supported joints are 1 and 4. Since
MATLAB makes it easy to pull out portions of matrices based on index sets, we can let MATLAB do
the partitioning for us. The MATLAB script in Figure 24 shows how this can be done. If you look at
the code closely, you should be able to see that everything following the index partition denitions is
generali.e., there is nothing problem specic. This implies that we could package up most this code,
combine it with our earlier assembly code (see Figures 18 and 20) and have a general spring system
solver. We would need to add to our input information some way of keeping track of which joints were
supported and which were not.
Exercises Here are some further things to try as a follow on to this example:
1. How would you modify this last example code to handle the case in which joint 1 is given an
imposed displacement of 0.02 inches to the right, in addition to the originally applied load?
Try it.
2. Modify the code for the case in which joint 2 has an imposed displacement of 0.03 inches to
the left, and joint 4 is unsupported. Keep the applied load at joint 3.
3. How would you determine the member forces following any of these solutions?
4. See if you can construct a general solver using the pieces we have developed so far. You will
need to add some way of handling joint input data. A common approach is to have an input
row for each joint with an entry for an ID number, an applied load value, and a support ag
indicating whether the joint is supported or free. By reading the joint data rst, you can
determine the problem size, and then use this information to build an empty system stiness
for use by the assembly code.
CEE 379 22
%%---Simple script for support example 2
%%---Values
sysK = [150 -100 -50 0; -100 250 -150 0; -50 -150 400 -200; 0 0 -200 200]; % k/in
sysP = [0; 0; 10; 0]; % kips
sysDisp = [0; 0; 0; 0]; % inches (imposed displacements)
%%---Index partitions
idx_f = [2 ; 3];
idx_s = [1 ; 4];
%%---System partitions
sysK_ff = sysK(idx_f,idx_f);
sysK_fs = sysK(idx_f,idx_s);
sysK_sf = sysK(idx_s,idx_f);
sysK_ss = sysK(idx_s,idx_s);
sysP_f = sysP(idx_f);
sysDisp_s = sysDisp(idx_s);
%%---Solution
%%---Update system data with formerly unknown quantities
for i = 1:size(idx_f, 1)
sysDisp(idx_f(i)) = sysDisp_f(i);
end
for i = 1:size(idx_s, 1)
sysP(idx_s(i)) = sysP_s(i);
end
%%---simple output
for i = 1:size(sysDisp,1)
fprintf(1, Delta_%d = %f inches \n, i, sysDisp(i));
end
fprintf(1, ---Joint Loads/Reactions: \n);
fprintf(1, P_%d = %f kips \n, i, sysP(i));
end
===========Output========
---Displacements:
---Joint Loads/Reactions:
P_1 = -3.548387 kips
P_2 = 0.000000 kips
P_3 = 10.000000 kips
P_4 = -6.451613 kips
Figure 24: MATLAB script for computing support Example 2 results.
CEE 379 23
2.5 Mist and Load-Independent Deformations
In the previous section, we encountered the possibility of support movements, which we related physically
to such phenomena as foundation settlements. These are special cases of the more general phenomenon of
load-independent deformations that can occur in structures and structural components. Common sources
of load-independent deformations are temperature changes, moisture content changes (signicant in wood
and concrete), fabrication variations, and residual plastic deformation following an overload. These kinds of
deformations can be signicant in various ways, either inducing large stresses in the structure, or in causing
movements and misalignments that have other problematic side eects. In this section we will see how we
can account for such eects in our structural models.
In our current 1-D world, the eect of any such phenomenon is a change in the initial or natural length of
an element. This inuences how force and elongation are related. Mathematically we can write the following:
f
e
= k
e
(
e
e
0
) (77)
in which
e
0
represents the load-independent elongation. As illustrated in Figure 25, this relation osets
the force-displacement curve so that the natural, zero-force elongation is
e
0
rather than zero. If you heat
something up, its natural length changes, and you have to add force to get back to its original length, and
that is what this kind of oset is modeling. To accommodate this in our analysis framework, we will look
f
e
e
k
e
e
0
Figure 25: Force-elongation relation in the presence of load-independent elongation,
e
0
.
again at our single element formulation as in Section 2.3.1. In particular, we will modify our constitutive
relation to account for the additional elongation beyond that associated with system joint displacements,
and leave the kinematics and equilibrium relations unchanged:
Kinematics:
e
=
j

i
(78)
Equilibrium:
P
i
= f
e
(79)
P
j
= f
e
(80)
Constitutive:
f
e
= k
e
(
e
e
0
) (81)
If we express these relations in a general form we have
Kinematics:
{
e
} = [B] {
e
} (82)
Equilibrium:
{P
e
} = [B]
T
{f
e
} (83)
Constitutive:
{f
e
} = [C
e
] ({
e
} {
e
0
}) (84)
Relating member forces to system displacements we get
{f
e
} = [C
e
] ([B] {
e
} {
e
0
}) (85)
CEE 379 24
This equation indicates how we calculate member forces in the presence of mist once we have determined
the system displacements. In eect, we need to subtract out the mist strain as part of our calculation.
Relating system forces to system displacements we get
{P
e
} = [B]
T
[C
e
] ([B] {
e
} {
e
0
}) (86)
= [B]
T
[C
e
] [B] {
e
} [B]
T
[C
e
] {
e
0
} (87)
= [k
e
] {
e
} {P
e
0
} (88)
in which {P
e
0
} = [B]
T
[C
e
] {
e
0
}. This nal relation shows that the eect on our formulation is to leave the
element stiness unchanged, but we need to add to the system loads an additional contribution arising from
the mist in the element. For the 1-D spring case at hand, we already know what [k
e
] in equation (88)
isusing the appropriate [B] and [C] we can determine that the eective mist load we need to add to the
system load is
{P
e
0
} = [B]
T
[C
e
] {
e
0
} (89)
=
_
1
1
_
[k
e
] {
e
0
} (90)
= k
e
e
0
_
1
1
_
(91)
In its nal form, it is easy to interpret the additional element mist load as follows: if the member is too
long (i.e.,
e
0
> 0 as shown in Figure 26(a)), then we need to compress the member to t it into the structure
(Figure 26(b)), and when we release the compression, the equivalent compressive force is transferred to the
members end joints, pushing to the left on the left end and to the right on the right end (Figure 26(c)).
k
e
i
e
j
e
e
0
i
e
j
e
k
e
k
e
i
e
j
e
e
0
k
e
e
0
k
e
(a) Misfit (b) Precompression (c) Effective Load
e
0
k
e
e
0
k
e
Figure 26: Physical interpretation of element mist.
To incorporate member loads of this kind into our system equations, we can use a procedure analogous to
our assembly procedure for stinesses. That is to say, we can loop over all elements, and add each elements
mist force contribution to the system loads as follows:
P
I(r,e)
P
I(r,e)
+ P
e
0r
(92)
in which I(r, e) is the same index map used in the assembly of stinesses. The examples below will illustrate
the application of this equation.
One other important thing to note is that these element mist loads are not externally applied forces in
the normal sense, and so when evaluating nal system reactions and joint loads, these member forces need
to be subtracted back out of the system. To help illustrate this, consider a very simple single spring model,
as shown in Figure 27. We will compute the system displacements, member force, and system reactions for
the case in which the member has a mist of
e
0
. Note that the answers to all these questions are evident
from inspection: the force in the member will be zero, the reaction force at joint 2 will be zero, and the
displacement at joint 1 will be
e
0
. To see our analysis machinery work to arrive at these results, we start
with the system stiness, which is just the element stiness in this case:
[K] =
_
k k
k k
_
CEE 379 25
1 2
k
Figure 27: A single-spring structure to illustrate member mist.
In partitioned form, the system equations can thus be written:
_
0
R
2
_
=
_
k k
k k
_ _

1
0
_
(93)
in which we have used the notation R
2
to indicate that system force at joint 2 is a reaction. Now we add in
the eect of the elements mist force:
_
k
e
0
R
2
+ k
e
0
_
=
_
k k
k k
_ _

1
0
_
(94)
Expanding these matrix expressions leads to the following:
k
e
0
= k
1
(95)
P
2
= R
2
+ k
e
0
= k
1
(96)
From the rst of these equations we can see that
1
=
e
0
, as expected. The second equation then becomes
P
2
= R
2
+ k
e
0
= k
e
0
(97)
Note that R
2
= P
2
k
e
0
= 0, which illustrates the need to subtract back out of member mist load from
the computed system force (P
2
in this case). The member force is calculated using equation (85):
f = k(
2

1

e
0
) (98)
= k(0 (
e
0
)
e
0
) (99)
= 0 (100)
The results all turn out as expected, but we can see how it is necessary to insert and remove the mist terms
in a consistent fashion.
Now we are ready to consider some more involved examples and to look at how the approach can be
implemented computationally.
Example 1 Figure 28 shows again one of the simple spring structures we have considered previously. De-
termine the force induced in member b if its temperature is increased such that its natural elongation
is 0.02 inches.
1
2
3 4
k
d
k
a
k
b
k
c
Figure 28: A 1-D structural system based on simple springs.
Solution The solution of problems with mist proceeds the same as the solution to any linear structural
analysis problem, the primary dierence being the alteration of the system load to account for the
mist. The system stiness is thus set up the same as usual:
[K] =
_
k
a
+ k
b
k
b
k
b
k
b
+ k
c
+ k
d
_
(101)
CEE 379 26
The system loads in this case are solely due to the mist:
{P
f
} =
_
0.02k
b
0.02k
b
_
(102)
The free system displacements are thus given by {
f
} = [K]
1
{P
f
}. To determine the nal force
in member b, we use equation (85), which accounts for the member force due the movement of the
members end joints plus the pre-existing force due to squeezing the mistting member into place. In
particular, we can write:
f
b
= k
b
(
3

2
) 0.02k
b
(103)
Example 2 Write a MATLAB function that adds a spring elements mist eect to the system load, and
write an additional function that computes a members force in terms of system displacements and
member mist.
Solution There are various ways one might do this depending on how the data are structured. We will
use an approach similar to that in our assembly code from Section 2.3.4. In particular, we will set
things up so that the member end joint indices are passed into our function, along with the member
stiness, k
e
, and a specied mist. See Figure 29 for the resulting code. Note the commented out
function [sys_P] = Spring_InstallP0(i,j,ke, delta0, sys_P);
%---Input variables
% delta0 = member misfit
% sys_P = system stiffness into which element force is assembled
%---Compute member misfit force
P0e = ke * delta0 * [-1;1];
%---Set up index map
Idx = [i, j];
%---Install member misfit force in system force
for r = 1:2
sys_P(Idx(r)) = sys_P(Idx(r)) + P0e(r);
end
%---A simpler (and more efficient) alternative to the above:
%sys_P(i) = sys_P(i) - ke * delta0;
%sys_P(j) = sys_P(j) + ke * delta0;
Spring_InstallP0 = sys_P;
Figure 29: MATLAB script for computing joint loads due to member mist.
code indicating a simpler and more direct alternative to the formal looping code.
Proceeding in similar fashion for the case of computing member force from system displacement, we
end up with the code in Figure 30. This code is essentially a one-liner, which is about as simple as
things can get.
Example 3 For the same structure used in Example 1 above, combine the assembly code, mist member
code, and the support code to determine the displacements, member forces, and support reactions for
the following combination of problem parameters:
Member stiness values as follows: k
a
= 100 k/in, k
b
= 200 k/in, k
c
= 300 k/in, and k
d
=
200 k/in.
An applied load at joint 3 of 15 kips acting to the left.
An imposed displacement at joint 4 of 0.3 inches to the right.
CEE 379 27
function fe = Spring_MemForce(i,j,ke, delta0, sys_Disp);
%---Input variables
% sys_Disp = system displacements
%---Compute member force
fe = ke * (sys_Disp(j) - sys_Disp(i) - delta0);
Spring_MemForce = fe;
Figure 30: MATLAB script for computing member force including member mist.
A temperature change in member c such that it contracts 0.025 inches.
Solution This problem is small in size, but it has just about all the bells and whistles possible for linear
1-D spring models. If we can write code to solve this problem, we will have the framework to solve just
about any problem in the context of 1-D analysis, and as we will see, for most any linear structural
analysis in general. The solution code for this problem is long enough that we will go through it
here piece by piece. The majority of the code has been seen before in earlier listings. The framework
of the code (what each step does) is more important than the details of the code (how each step is
accomplished), and you should be able to explain clearly what each step is doing.
The script begins with an input section, which again is in hard-wired script form rather than in a more
general le reading form
7
:
%%---This script illustrates a simple but general implementation of an
%% automated spring system
%%---Some definitions to make for more readable code:
free = 0; supported = 1;
%% Each row defines joint data as follows: [id, P_i, supported/free, imposedDisp]
Joints = ...
[1, 0, supported, 0; ...
2, 0, free, 0; ...
3, -15, free, 0; ...
4, 0, supported, 0.3 ];
%% Each row defines an element--> [Joint_i, Joint_j, ke, delta0]
Elements = ...
[ 1, 2, 100.0, 0.0; ... % member a
2, 3, 200.0, 0.0; ... % member b
3, 4, 300.0, -0.025; ... % member c
%3, 4, 300.0, 0.0; ... % member c
1, 3, 200.0, 0.0 % member d
];
Next we set up some useful constant denitions, and then build the system stiness:
%%---Set up some constants for indexing
jointi = 1;
jointj = 2;
ke = 3;
delta0 = 4;
ID = 1;
P_i = 2;
fixity = 3;
7
Note that le reading code could include error checking and allow for more general input styles
CEE 379 28
disp0 = 4;
%--- Step 1: Start with sysK = all zeros
sysSize = size(Joints,1);
sysK = zeros(sysSize,sysSize);
%--- Step 2: loop over elements and assemble stiffnesses
numElts = size(Elements,1);
for e = 1:numElts
sysK = Spring_InstallKe(Elements(e,jointi),Elements(e,jointj),Elements(e,ke),sysK);
end
Next we set the joint loads and any imposed displacements:
%--- Step 3: loop over joints and set up system loads and initial displacements
sysP = zeros(sysSize, 1);
sysDisp = zeros(sysSize, 1);
for i=1:sysSize
sysP(i) = sysP(i) + Joints(i, P_i);
sysDisp(i) = Joints(i, disp0);
end
Now we add in the eect of the member mist loads (more general code might check whether any
mist exists during le reading, set a ag accordingly, and then only do this step if necessary):
%--- Step 4: loop over elements and add misfit loads to system loads
for e = 1:numElts
sysP = Spring_InstallP0(Elements(e,jointi),Elements(e,jointj),Elements(e,ke),...
Elements(e,delta0),sysP);
end
Partitioning the system to account for supports requires setting up the partition index sets, which
we accomplish by looping over the joints and accumulating the corresponding indices into free and
supported categories:
%--- Step 5: Set up fixed and free partitions
idx_f = [];
idx_s = [];
for i=1:sysSize
if Joints(i, fixity) == free
idx_f = [idx_f ;Joints(i, ID)];
else %---supported
idx_s = [idx_s ; Joints(i, ID)];
end
end
Setting up the partitions themselves, generating the solution, and putting the partition-specic infor-
mation back into the unpartitioned matrices follows our earlier code exactly:
% ---Step 6: Set up partitions
sysK_ff = sysK(idx_f,idx_f);
sysK_fs = sysK(idx_f,idx_s);
sysK_sf = sysK(idx_s,idx_f);
sysK_ss = sysK(idx_s,idx_s);
sysP_f = sysP(idx_f);
sysDisp_s = sysDisp(idx_s);
% ---Step 7: Solution
% ---Step 8: Update system data with formerly unknown quantities
for i = 1:size(idx_f, 1)
sysDisp(idx_f(i)) = sysDisp_f(i);
end
for i = 1:size(idx_s, 1)
sysP(idx_s(i)) = sysP_s(i);
end
CEE 379 29
As we saw earlier, we need to back out the eect of the mist member joint loads. We do this by
calling Spring InstallP0 again using a reversed sign on the mist:
% ---Step 9: Back out the misfit pseduo-loads
for e = 1:numElts
-Elements(e,delta0),sysP);
end
We can now print out the displacement and reaction results, and use these results to compute the
member forces. Note that the member force function accounts for the pre-existing mist load, and
note also how we use an alphabet string to preserve letter-based member labeling. This obviously
restricts us to 26 members, and so in more general contexts one must resort to numerical ids (or
construct a more general automatic naming scheme).
% ---Step 10: Simple output
fprintf(1, Delta_%d = %f inches \n, i, sysDisp(i));
end
fprintf(1, ---Joint Loads/Reactions: \n);
fprintf(1, P_%d = %f kips \n, i, sysP(i));
end
fprintf(1, ---Member Forces: \n);
alphabet = abcdefghijklmnopqrstuvwxyz;
for e = 1:numElts
fe = Spring_MemForce(Elements(e,jointi),Elements(e,jointj),Elements(e,ke),...
Elements(e,delta0),sysDisp);
fprintf(1, f_%s = %f kips \n, alphabet(e), fe);
end
The results for this particular case are as follows:
---Displacements:
P_1 = -38.823529 kips
P_2 = 0.000000 kips
P_3 = -15.000000 kips
P_4 = 53.823529 kips
---Member Forces:
f_a = 9.705882 kips
f_b = 9.705882 kips
f_c = 53.823529 kips
f_d = 29.117647 kips
1
2
3 4
15
k
53.8
k
9.7
k 9.7
k
29.1
k
38.8
k
29.1
k
9.7
k
9.7
k
53.8
k
53.8
k
Figure 31: Verication of equilibrium to check computer results.
The code used to generate these results is relatively complex compared to what we have done so far,
and so it is useful to have some means to check whether the results make sense. In fact, it is worth
making a general statement in this regard: Doing independent checks on computer-generated results is
an extremely important part of engineering analysis. This is easy to state, but it is not always easy to
doif it were simple to generate results independent of the computer analysis, we would not need the
CEE 379 30
computer analysis in the rst place. In the context of structural analysis, it is not generally practical
to try to solve the problem by hand for a check, and so one of the most common and reliable ways of
checking results is to ensure that the solution achieves what it set out to achieve. In particular, we
can verify that equilibrium is satised. For the problem at hand, Figure 31 shows free body diagrams
for each joint in which the various force quantities correspond to the computer results. It can be seen
that each joint is in equilibrium, and since the member forces were computed using the displacement
results, this generally implies that the results are correct. You should get in the habit of viewing all
computer-generated results critically, always making sure that what you see makes sense.
Exercises Try these additional exercises to round out your understanding of this code and the mod-
eling of systems of this type.
1. Remove the line ending semicolons (;) selectively, running the code each time to see the
various intermediate results.
2. Change the support conditions so the problem becomes statically determinate, run various
cases, and check by hand. What is the eect of mist or imposed support displacement in
the case of a statically determinate system?
3. Change the code to read its input from a le, and include the possibility of user error.
4. Break the code up into smaller pieces, using separate functions to accomplish the work rather
than having everything in one big script.
CEE 379 31
3 1-Dimensional Elasticity-Based Elements
Now that we have an idea how structural analysis works once we have characterized the behavior of an
element, it makes sense to return again to a mechanics of materials view of the world and consider more
carefully how a 1-D axial element can be derived from fundamental principles. In particular, we will go
through a derivation of the stiness coecients for a 1-D element using a dierential equation approach.
The main point is to provide a simple example that parallels the more involved derivations we will need in
the case of beams.
3.1 1-D Elasticity Formulation
Like any structural mechanics formulation, we need to address the fundamental issue of characterizing
equilibrium, kinematics, and constitutive behavior. From a mechanics of materials perspective, we need to
carry out these characterizations at the level of stress and strain rather than force and displacement, and
we need to consider dierential elements rather than nite bodies. Figure 32 shows the basic set-up for our
x
A
b(x)
Figure 32: A 1-D elastic rod.
derivation. We have a 1-D rod of material with the location of each point given by a coordinate, x, and
the displacement of each point from its original location denoted u(x). In general, we can have distributed
applied axial loading, denoted here as b(x).
3.1.1 Kinematics: Strain-Displacement Relation
To characterize the strain in this context, we need to determine the elongation intensity at each point in the
body as function of the overall displacements. Applying the concept of strain as length change normalized
x
x
x
u(x)
u(x + x)
before deformation
after deformation
Figure 33: A 1-D elastic rod.
by original length of a particular segment as shown in Figure 33, we can write
=
u(x + x) u(x)
x
(104)
To get the strain at the point x itself, we take the limit as x 0, and this becomes our 1-D strain-
displacement relation:
(x) = lim
x0
u(x + x) u(x)
x
=
du
dx
(105)
Lets box this result up so its easy to nd:
CEE 379 32
1-D Strain-Displacement Relation
(x) =
du
dx
3.1.2 Equilibrium
In the case of a continuous rather than discrete model, equilibrium characterizes how the stress, (x), varies
through the body. Following the usual practice, we isolate a small element of material, apply equilibrium
to this small piece, and then take allow the small element of material to shrink to a point. Referring to
x
(x)
(x + x) = (x) +
d
dx
x +
1
2
d
2
dx
2
x
2
+K
x
b(x)
Figure 34: A 1-D rod segment free body.
Figure 34, recalling that stresses need to be multiplied by the area they act on to get force, and noting that
b(x) is an applied force per unit length, we can write the following expression for the balance of force on a
small element:
A(x) + A(x + x) + b(x)x = 0 (106)
The middle term in this expression can be expanded as (x +x) = (x) +xd/dx +. . ., and so we have
A(x) + A(x) + Ax
d
dx
+ . . . + b(x)x = 0 (107)
Canceling the rst terms, dividing through by x, and then taking the limit x 0 we get the following
dierential equation of equilibrium:
1-D Equation of Equilibrium
A
d
dx
+ b(x) = 0
3.1.3 Constitutive Relation
For 1-D elasticity, the constitutive relation is particularly simple as we have a linear relation between stress
and strain:
1-D Equation of Equilibrium
(x) = E(x)
3.1.4 Governing Equation and Boundary Conditions
Having characterized the kinematics and constitutive behavior, and having determined an expression for
equilibrium, we are now in a position to solve any 1-D elasticity problem. Following a similar approach to
the discrete analysis we have done so far, we will express equilibrium in terms of displacements, and use this
as our governing equation. Combining our constitutive and kinematics relations, we get
(x) = E
du
dx
(108)
Substituting this expression into the equilibrium equation then leads to the desired governing equation:
CEE 379 33
1-D Elasticity Governing Equation
EA
d
2
u
dx
2
+ b(x) = 0
If we rearrange this equation a bit and use prime notation for the derivatives, we have EAu
(x) = b(x).
Comparing this to the fundamental beam equation, EIv
(x) = q(x), we can see that there is a great deal

of similarity between the two. In both cases there is a dierential relation between displacement and applied
load, with material and cross section parameters as linear multipliers. While the beam equation and its
applications are of much more general practical interest than the 1-D rod equation, the axial equation is
simpler to work with and understand. We will thus use the axial case primarily as an aid in preparing
ourselves to understand beams and frames, which we will deal with later.
There are three things in particular we can investigate for the simple axial case that will be very useful
again later in the case of beams:
1. Deriving member stinesses from dierential equations.
2. Handling in-span loading for members.
3. Determining internal distributions of displacement and force for individual members following matrix
analysis of the system to which the member belongs.
The rst of these will provide us with a mechanism to construct general structural models from various kinds
of members. The second of these will allow us to include in our models loads applied at locations other than
joints. The third will gives us the ability to assess displacement and stress throughout our structural models.
3.2 Stiness Derivation
We have seen that the stiness of an element provides a relation between displacement of its ends and the
resulting joint reactions. Our task for our 1-D rod, then, is to determine the end reactions necessary to
sustain an arbitrary set of end displacements as illustrated below:
u
i
u
j
We have seen before that linear stiness does not depend on loading, so we start with the general
analytical solution of the governing equation EAu
= 0 (i.e., we consider an unloaded element and take

b(x) = 0):
u(x) = c
1
x + c
2
Next, we dene equations expressing the two boundary conditions u(0) = u
i
and u(L) = u
j
. Using the
solution given above, we can write
c
2
= u
i
c
1
L + c
2
= u
j
We now need to solve these two equations so that we can express the constants c
1
, and c
2
in terms of the
parameters we are interested in: the end displacements. This is a matter of doing some algebra, and the
expressions we get can be put in the following form:
u(x) = u
i
N
1
(x) + u
j
N
2
(x)
The shape function expressions, N
i
(x), are easily derived and are given below:
N
1
(x) = 1
x
L
N
2
(x) =
x
L
CEE 379 34
We are now ready to extract the stiness coecients by evaluating the appropriate shape function deriva-
tives at the end points. This follows from the fact that, for example, P
i
= (0)A = EAu
(0) =
EA[u
i
N
1
(0) + u
j
N
2
(0)] This can be summarized in matrix form as indicated below:
_
P
i
P
j
_
= AE
_
N
1
(0) N
2
(0)
N
1
(L) N
2
(L)
_ _
u
i
u
j
_
Carrying out the simple evaluations in the matrix above, we end up with the standard 1-D truss element
stiness matrix:
[k] =
_
k k
k k
_
in which the single stiness coecient, k, is dened as follows:
k =
AE
L
This is of course the exact same stiness we had before, which should not be surprising. The key here is to
see how we used the fundamental dierential equation with imposed displacement boundary conditions to
determine the necessary reactions, and thus the corresponding stiness terms.
3.3 In-Span Loads
It is very common for structural members to be loaded at locations other than their ends, and so we need
a means for incorporating such loadings into our models. From the perspective of our 1-D elasticity model,
we must gure out how to handle cases in which b(x) = 0.
Our approach will once again rely on adapting some basic results from dierential equations. In particular,
we will use the fact that for linear dierential equations we can consider the solution to equations with a
non-zero right-hand side (b(x) in the present case) as the sum of a homogeneous and particular part:
u(x) = u
h
(x) + u
p
(x) (109)
The key to making this work is in dening carefully what each solution satises in terms of boundary
conditions as well as the right hand side. The expressions below show how we set things up:
EAu
H
= 0 EAu
p
= b(x)
u
H
(0) = u
i
u
p
(0) = 0
u
H
(L) = u
j
u
p
(L) = 0
Note that the homogeneous solution takes account of the non-zero boundary conditions, while the particular
solution accounts for the load, but keeps the end displacements xed. When we add the solutions together
we get:
EA(u
H
+ u
p
) = b(x) (110)
u
H
(0) + u
p
(0) = u
i
(111)
u
H
(L) + u
p
(L) = u
j
(112)
This is just what we need: a solution accounting for applied load (b(x)) and arbitrary joint displacements
(u
i
and u
j
).
To adapt these results to our structural analysis framework, note that u
H
(x) is just the solution we
obtained in the previous section. Expressing the relation between system loads and system displacements
including the particular solution terms gives us the following:
_
P
i
e
P
j
e
_
=
_
k k
k k
_ _
u
i
e
u
j
e
_
+
_
AEu
p
(0)
AEu
p
(L)
_
(113)
Remember that the system-level analysis is responsible for determining the joint displacements, and note
that b(x) is a known loading function, so in principle we know u
p
(x). This means that the eect of the
in-span load is to add some additional joint loading to the system load:
_
P
i
e
P
j
e
_

_
P
i
e
P
j
e
_
+
_
F
e
1
F
e
2
_
(114)
CEE 379 35
in which F
e
1
= AEu
p
(0) and F
e
2
= AEu
p
(L). Note the close similarity between this result and what we saw
earlier in the case of member mist (c.f. equation (92)). This indicates that as far as our overall structural
system model goes, we handle in-span member loads by simply computing the equivalent end reactions
caused by the in-span loads in the case of zero end displacements, and then assemble these additional loads
into the system loads in the usual fashion. As in the case of member mist loads, we then need to properly
account for these additional loads when we subsequently compute member forces and support reactions. In
particular, once the system displacements have been determined, we need to subtract out the member loads
from the joint loads, and in computing member end reactions, we must use relations of the form:
f
e
1
= k(u
i
e u
j
e ) F
e
1
(115)
f
e
2
= k(u
j
e u
i
e ) F
e
2
(116)
Note that the member end reactions are no longer simply equal and opposite due to the presence of the in-
span load. Note also that the member force is no longer a constant, but rather varies through the member.
We will consider this in more detail in the next section.
As usual, it is easiest to get a handle on all this via an example:
Example For the problem shown in Figure 35 determine the displacement at joint 2, the force in member
b, and the reaction at supports 1 and 3.
1
2
3
b
0
E, A, L E, A, L
a
b
Figure 35: A 1-D rod assemblage with in-span loading.
Solution The system stiness is simple to compute in this case, especially since the member properties are
identical:
[K] =
AE
L
_
_
1 1 0
1 2 1
0 1 1
_
_
(117)
The only loading applied here is the member load, so the system load matrix will consist solely of
element as xed end forces. You can probably guess from observation that we will just have b
0
L/2
going to each joint, but in general we need to derive the particular solution for the dierential equation
in question. This is straightforward to carry out for this example:
EAu
p
(x) = b
0
u
p
(x) =
b
0
x
2
2AE
+ c
1
x + c
2
Using the boundary condition u
p
(0) = 0 tells us that c
2
= 0, and u
p
(L) = 0 requires c
1
=
b0L
2AE
. We
thus have
u
p
(x) =
b
0
x
2AE
(L x)
The corresponding end forces can thus be determined to be
_
F
a
1
F
a
2
_
=
_
AEu
p
(0)
AEu
p
(L)
_
=
_
b0L
2
b0L
2
_
The result is as expected. Assembling these element contributions to the system load gives
{P} =
_
_
_
R
1
+
b0L
2
b0L
2
R
3
_
_
_
CEE 379 36
We have again used the notation R
1
and R
3
to represent the as yet unknown support reactions.
Partitioning the system to account for the supports leads us to the following identications:
[K
ff
] =
AE
L
[2]
[K
ss
] =
AE
L
_
1 0
0 1
_
[K
fs
] = [K
fs
]
T
=
AE
L
[ 1 1 ]
{P
f
} =
_
b
0
L
2
_
{P
s
} =
_
R
1
+
b0L
2
R
3
_
Solving for the free displacement is easy in this case:
u
2
=
L
2AE

b
0
L
2
=
b
0
L
2
4AE
The support loads are
_
R
1
+
b0L
2
R
3
_
= [K
fs
]u
2
+ [K
ss
]
_
0
0
_
=
b
0
L
4
_
1
1
_
from which we get R
1
= 3b
0
L/4 and R
3
= b
0
L/4. You should sketch a free body diagram of the
loaded structure to ensure that equilibrium is satised globally.
To compute the (constant) force in member b we simply do the usual calculation: f
b
= AE/L(u
3
u
2
) = b
0
L/4. Characterizing the force in member a is more involved, as will be seen in the next
section. However, we can use equations (115) and (116) to determine the end reactions:
f
a
1
=
AE
L
(u
1
u
2
)
b
0
L
2
= 3b
0
L/4
f
a
2
=
AE
L
(u
2
u
1
)
b
0
L
2
= b
0
L/4
Note that these are reactions rather than internal forces, and so the sign convention is left-right rather
than tension-compression. The free body diagram in Figure 36 shows these results for member a,
illustrating how equilibrium is satised.
1
2
3b
0
L
4
b
0
L
4
b
0
a
Figure 36: Member a free body showing in-span load and end reactions.
3.4 Internal Displacements and Force Distributions
As the example in the previous section illustrates, internal forces in members are not always simply constant.
To characterize the stresses and displacements within a given element, we combine the solutions to the
governing equations for the element with the end displacement values obtained from the structural system
analysis. The displacement at any point in a 1-D member is thus given by
u(x) = u
i
N
1
(x) + u
j
N
2
(x) + u
p
(x)
CEE 379 37
For the particular case of a 1-D elasticity element with a uniform load, b
0
, if we substitute explicitly for the
N functions we can write
u(x) = u
i
_
1
x
L
_
+ u
j
x
L
+
b
0
x
2AE
(L x)
Once we have solved the system problem, we know u
i
and u
j
, and so we can use this expression to compute
displacements anywhere in the member. We also can determine the distribution of stress anywhere in the
member via the relation (x) = Eu
(x). In the case of a uniformly loaded 1-D elasticity element we have

(x) =
E
L
(u
j
u
i
) +
b
0
A
_
L
2
x
_
Example Plot the displacements and stress in member a for the example problem in the previous section.
Solution Substituting the values we obtained for u
i
and u
j
into the general displacement and stress equa-
tions gives us the following expressions:
u(x) =
b
0
L
4AE
x +
b
0
x
2AE
(L x)
(x) =
b
0
L
4A
+
b
0
A
_
L
2
x
_
These can be cleaned up algebraically as follows:
u(x) =
b
0
L
2
4AE
x
L
_
3 2
x
L
_
(x) =
b
0
L
4A
_
3 4
x
L
_
Plotting these expressions gives us the results shown in Figure 37. Note the changeover from tension
to compression in the member.
u(x)
b
0
L
2
4AE ( )
x L
1 0.8 0.6 0.4 0.2
1
0.8
0.6
0.4
0.2
0
x L
x ( )
b
0
L 4A ( )
1
0.8
0.6 0.4 0.2
3
2
1
0
-1
Figure 37: Displacement and stress variation in member a.
The approach taken in this example and in this section has been to go back to the fundamental dierential
equation solutions to generate internal displacements and stresses. This is a general approach that is well
suited to computational implementation. It is worth pointing out, though, that once the end reactions are
known, you could also just use simple statics to determine internal stresses. If you set up a free body diagram
with an internal cut a distance x from the left end of the member and then apply static equlibrium as when
you set up moment diagrams, you will be able to arrive at the same result as what the dierential equation
gives.
CEE 379 38
3.5 Computer Implementation
Including in-span loading into the basic computational framework presented in Example 3 in section 2.5 is
straightforward. We need rst a function that allows an element to add its internal load eects to the system
load. For this purpose, we will assume the following form for b(x);
b(x) = b
i
+ (b
j
b
i
)
x
L
This expression corresponds to a linearly varying distributed axial load with arbitrary end values, b
i
and b
j
.
This load can be used to model most any general case by breaking the general load up into piecewise linear
segments. This will also hold true in the case of beams, where in practice it is rare to get loading more
complex than linear variation, and the most common case by far is constant distributed load.
It is straightforward to determine the xed-end solution corresponding to this loading:
u
p
(x) =
b
i
x
2AE
(L x) +
(b
j
b
i
)x
6AEL
2
_
L
2
x
2
_
The corresponding eective joint loads are
_
F
1
F
2
_
=
b
i
L
2
_
1
1
_
+
(b
j
b
i
)L
6
_
1
2
_
The MATLAB code shown in Figure 38 provides a straightforward implementation of this joint force calcu-
lation, including the assembly into the system load.
function [sys_P] = Spring_InstallFe(i, j, bi, bj, L, sys_P);
%---Input variables
% bi,bj = member end load magnitude
% L = member length
% sys_P = system forces
%---Compute and add load
sys_P(i) = sys_P(i) + bi*L/2 + (bj - bi)*L/6;
sys_P(j) = sys_P(j) + bi*L/2 + (bj - bi)*L/3;
Spring_InstallFe = sys_P;
Figure 38: MATLAB code for computing and installing 1-D elasticity element in-span loads.
We also need to add the capability for computing member end reactions, since as we have seen in the
case of in-span loading, the member force is not constant. The member reactions can be determined from
equations (115) and (116) in general, and for the case at hand we get:
f
e
1
=
AE
L
(u
1
u
2
)
b
i
L
2

(b
j
b
i
)L
6
f
e
2
=
AE
L
(u
2
u
1
)
b
0
L
2

(b
j
b
i
)L
3
The corresponding MATLAB code is presented in Figure 39.
With these two basic functions in hand, it is relatively simple to modify our previous system code to
handle in-span loading. The rst modication is that we need to require additional element data as input, so
the element denition code should look something like (see the example below for the corresponding member
layout):
...
%% Each row defines an element--> [Joint_i, Joint_j, AE/L, bi, bj, Length, delta0]
Elements = ...
[ 1, 2, 100.0, 0.0, 0.0, 10, 0.0; ... % member a
CEE 379 39
function [fe] = Elt1D_MemForce(i,j,ke,delta0,bi,bj,L,sys_Disp);
%---Input variables
% bi,bj = end load magnitudes
% L = member length
% sys_Disp = system displacements
%---Make room for member force
fe = zeros(2,1);
%---Compute member forces
fe(1) = -ke * (sys_Disp(j) - sys_Disp(i) - delta0) - bi*L/2 - (bj-bi)*L/6;
fe(2) = ke * (sys_Disp(j) - sys_Disp(i) - delta0) - bi*L/2 - (bj-bi)*L/3;
Elt1D_MemForce = fe;
Figure 39: MATLAB code for computing 1-D elasticity element end reactions.
2, 3, 200.0, 1.0, 1.0, 10, 0.0; ... % member b
3, 4, 300.0, 0,0, 10, 0.0; ... % member c
1, 3, 200.0, 0,0, 20, 0.0 % member d
];
...
Strictly speaking, the elements stiness depends on the length, A, and E, but we will avoid dealing with
this here.
The next modication involves the assembly of element loads. We simply need to add a call to our
member load installer to go along with the previously dened member mist load installer:
...
%--- Step 4: loop over elements and add misfit and in-span loads to system loads
for e = 1:numElts
Elements(e,delta0),sysP);
sysP = Spring_InstallFe(Elements(e,jointi),Elements(e,jointj),Elements(e,bi),...
Elements(e,bj),Elements(e,length),sysP);
end
...
Everything proceeds as usual until after the solution, at which point the joint loads/reactions need to have
the member forces removed:
...
% ---Step 9: Back out the member pseduo-loads
for e = 1:numElts
-Elements(e,delta0),sysP);
sysP = Spring_InstallFe(Elements(e,jointi),Elements(e,jointj),-Elements(e,bi),...
-Elements(e,bj),Elements(e,length),sysP);
end
...
Finally, we need a more general means for writing out the member forces. Later on, we will write code
to plot internal distributions of moment and displacement for beams. For now, we will simply print out the
member end reactions, which need no longer match due to the presence of internal loading:
...
% ---Step 10: Simple output
...
fprintf(1, ---Member Forces: \n);
CEE 379 40
alphabet = abcdefghijklmnopqrstuvwxyz;
for e = 1:numElts
fe = Elt1D_MemForce(Elements(e,jointi),Elements(e,jointj),Elements(e,ke),...
Elements(e,delta0),Elements(e,bi),Elements(e,bj),Elements(e,length),sysDisp);
fprintf(1, f_%s1 = %f kips \n, alphabet(e), fe(1));
fprintf(1, f_%s2 = %f kips \n\n, alphabet(e), fe(2));
end
Numerical Example The conguration shown in Figure 40 matches closely that of Example 3 in sec-
tion 2.5. The only real distinctions are that the members have been drawn dierently to indicate they
are 1-D elasticity elements, and the only loading eect is an in-span load as shown. Running a similar
1
2
3 4
a
b
d
c
1.0
k/ f t
Figure 40: In-span load example.
script to that used for Example 3 in section 2.5 with the modications indicated above, we get the
following results:
---Displacements:
P_1 = -5.588235 kips
P_2 = 0.000000 kips
P_3 = 0.000000 kips
P_4 = -4.411765 kips
---Member Forces:
f_a1 = -2.647059 kips
f_a2 = 2.647059 kips
f_b1 = -2.647059 kips
f_b2 = -7.352941 kips
f_c1 = 4.411765 kips
f_c2 = -4.411765 kips
f_d1 = -2.941176 kips
f_d2 = 2.941176 kips
These results are shown applied to the structures joints in Figure 41, along with an isolated view of
member b. Note how equilibrium is satised consistently throughout the structure.
4 Summary
The key results from our consideration of 1-D structures can be summarized as follows:
Solving a structural analysis problem means that we determine the displacements, internal forces,
and support reactions resulting from a given set of loading, system geometry, support conditions, and
material properties.
The three ingredients to formulating and solving any structural analysis problem are equilibrium,
kinematics, and constitutive relations.
CEE 379 41
1
2
3 4
7.35
k 2.64
k
2.94
k
5.58
k
2.94
k
2.64
k
2.64
k
4.41
k
4.41
k
4.41
k
2.64
k
7.35
k
1.0
k/ f t
L=10
f t
Figure 41: Verication of equilibrium to check computer results.
For linear analysis, these three ingredients can be expressed in terms of three linear relations:
Kinematics:
{} = [B] {} (118)
Equilibrium:
{P} = [B]
T
{f } (119)
Constitutive:
{f } = [C] {} (120)
If [B] is square and invertible, then the problem is statically determinate. Member forces can be
determined directly from system joint loads, and system displacements can be determined from
{} = [B]
1
[C] [B]
T
{P} = [F] {P} (121)
This is called a force or exibility method, and [F] is called the system exibility matrix.
An alternative solution approach which does not require static determinacy and which is best suited
to automated analysis uses a displacement formulation (i.e., we express equilibrium in terms of dis-
placements). This leads to the following single set of linear equations relating system displacements to
applied loads:
{P} = [B]
T
[C] [B] {} = [K] {} (122)
The system stiness, [K], characterizes the response behavior of the structural model. An individual
entry, K
ij
, physically represents the force generated at joint i due to a unit displacement at joint j.
The system stiness can be constructed directly using a physical approach, or via an element-by-
element assembly procedure. The latter approach is amenable to computer implementation and uses
a basic index mapping scheme.
Individual element response is characterized via the element stiness, [k
e
]. It is equivalent to the
system stiness for a structure composed of the single element in question.
For stable structures, the system stiness must be invertible (i.e., det([K]) = 0). This requires the
addition of support constraints to the system.
Supported (constrained) degrees-of-freedom (DOFs) can be distinguished from free DOFs, because
their values are known a priori. This leads to a natural partitioning of the overall system equations.
{P} = [K] {}
_
{P
f
}
{P
s
}
_
=
_
[K
ff
] [K
fs
]
[K
sf
] [K
ss
]
_ _
{
f
}
{
s
}
_
(123)
CEE 379 42
The partitioned equations can be solved in two steps:
{
f
} = [K
ff
]
1
({P
f
} [K
fs
] {
s
}) (124)
{P
s
} = [K
sf
] {
f
} + [K
ss
] {
s
} (125)
Once the above equations are solved, all joint displacements and support reactions are known.
Member internal forces can be determined in an element-by-element manner using the known joint
displacements.
Support settlement/movement is handled by entering the appropriate values in {
s
}.
Member mist is handled by: (a) adding in equivalent joint loads prior to solution; (b) using modied
expressions to compute internal member forces; and (c) accounting for the equivalent joint loads when
computing support reactions.
Element stiness relations can be derived from fundamental dierential equations for cases where
in-span variation in quantities is of interest.
Members loaded within their span are handled by: (a) adding equivalent joint loads to the system loads
prior to displacement; (b) combining homogeneous and particular solution terms to determine in-span
quantities such as member forces and displacements; and (c) accounting for the equivalent joint loads
when computing support reactions.
The entire solution procedure can be captured in write-it-and-forget-it code, with straightforward
input for joint, support, load, and member data.
Any solution can be veried on a joint-by-joint basis using simple statics and on an element-by-element
basis using simple element relations.
Although the 1-D modeling we have done so far is limited in its practical applicability, the overall structure
of the analysis framework is all we need to handle the full range of linear structural analysis problems. In our
following work we will simply be changing some of the internal details to account for 2D and 3D geometry,
and to accommodate more complicated elements. The overall picture will not change. It is thus worth
reviewing the above summarizing points and taking the time to understand them as fully as you can.

1 D Structures Basic Concepts

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

1 D Structures Basic Concepts

Загружено:

Авторское право:

Доступные форматы

CEE 379 1-D Structural Analysis Notes

(x) = q(x), we can see that there is a great deal

= 0 (i.e., we consider an unloaded element and take

(x). In the case of a uniformly loaded 1-D elasticity element we have

Вам также может понравиться