1 d Structures basic concepts

7/28/2019 1 d Structures basic concepts

1/42

CEE 379 1-D Structural Analysis Notes

The majority of the basic concepts and issues associated with structural analysis can be considered inthe simple context of 1-Dimensional structural systems, i.e., structural systems in which all members arealigned 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 ofview 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 barsact 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 thedisplacements () and internal forces (member forces fa and fb in this case) in the system. This requires

P,

Lb, Eb, Ab

La, Ea, Aa 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 = fa + fb (2)

Constitutive:

fa =

AE

L

a

a (3)

fb =

AE

L

b

b (4)

If we count up equations and unknowns, we have 5 unknowns (fa

, fb

, a

, b

, and ), and 5 equations(equilibrium (1 equation), kinematics (2 equations), and constitutive relations (2 equations)). The equationsare all linear1, and so with 5 equations and 5 unknowns, we know that determining the unknowns is a simplematter 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 isworthwhile developing a systematic approach to solving these equations. To this end, lets rewrite the abovelinear equations in matrix form:

1The equations are linear because there are no expressions involving higher order terms like 2, (fa)2, etc.

1


2/42

CEE 379 2

Kinematics: a

b

=

11

{} (5)

Equilibrium:

{P} = [ 1 1 ]

fa

fb (6)

Constitutive: fa

fb

=

AEL

a

0

0AEL

b

a

b

(7)

You should convince yourself that these matrix expressions are equivalent to equations (1)-(4). In fact, itwould be a good investment of your time to get to the point that you could sit down with a blank piece ofpaper and derive all the equations presented here so far.

A Comment on Notation Throughout these notes square brackets ([]) denote quantities that in generalcan be represented by rectangular matrices, while curly braces ({}) denote quantities that in generalcan be represented using column matrices. At times this gets a bit verbose, but it provides a consistentindication 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, itis possible to interpret the expressions as maps or transformations. With the introduction of some additionalnotation, 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} representsthe internal member forces and {P} represents the system forces. Note that the mapping between systemand member forces corresponds to the transpose of the kinematic map, [B]. As we will see, this is a generalresult and not merely a coincidence in this example. The constitutive matrix [C] in equation (10) relatesmember forces to member deformations. We will see that this matrix is symmetric in the general case, as itis in this simple case.

We are now ready to use our linear algebra machinery to solve the original problem. In particular, wecan combine equations (8) and (10) to obtain an expression for the member forces in terms of the systemdisplacements:

{f} = [C] {} = [C] [B] {} (11)

We can now substitute this expression into the equilibrium equation (9) to obtain a direct relation betweensystem 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, andso it is like a system constitutive relation. For this reason, it is called the system stiffness, and is traditionallydenoted [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 anylinear structural analysis problem, and so it has a box around it.


3/42

CEE 379 3

We are now in a position to complete the solution to our problem. Given the system loads, we candetermine the system displacements as follows:

{} = [K]1 {P} (14)

The inverse of the system stiffness is called the system flexibility, but it is rare that we actually computeit explicitly. Once we have the system displacements, we have accomplished half our job, which was todetermine the system displacements. The other half of the job can be completed using equation (11), whichrelates member forces to system displacements. We have in effect reduced the solution of the original set ofkinematics, equilibrium, and member constitutive relations to a set of basic matrix operations which can beeasily automated using a tool like MATLAB.

For the example in Figure 1 the algebra is simple enough that we can carry through the matrix operationsby hand to see how it goes. Comparing equations (5)-(7) with equations (8)-(10) we can see that in this casethe system stiffness is

[K] = [B]T

[C] [B] = [ 1 1 ]

AEL

a

0

0AEL

b

11

(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

AEL

a

+AEL

b

{P} (17)

The forces in members a and b can be determined using equation (11), which expands in this case to:

fa

fb

=

AEL

a

0

0AEL

b

11

1

AEL

a

+AEL

b

{P} (18)

=P

AEL a +

AEL b

AEL

a

AEL 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 thenext subsection.

1.2 Two Degree of Freedom Example

Figure 2 shows another simple configuration typical of what one encounters in mechanics of materials. Asbefore, we need to determine the system displacements and member forces given system forces. The differencein this case is that the system is characterized in terms of two displacements rather than just one. Eachdisplacement component necessary to characterize the kinematics of a system is called a degree of freedom,and so this system has two degrees of freedom.

P2, 2

Lb, Eb, AbLa, Ea, Aa

P1, 1A

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, first setting up the equations in longhandform, and then transforming to matrix expressions to generate the solution. The fundamental relations inthis case can be written as follows:


4/42

CEE 379 4

Kinematics:

a = 1 (20)

b = 2 1 (21)

Equilibrium:

P2CP1

Bfbfbfa

Figure 3: Free body diagrams for joints B and C. Member forces assumed positive (tensile).

P1 = fa fb (22)

P2 = fb (23)

Constitutive:

fa =

AE

L

a

a (24)

fb =

AE

L

b

b (25)

In equation (21) we have used the fact that the elongation of an axial member is simply the difference in theend displacements.

Writing these equations in matrix form, we get

Kinematics: a

b

=

1 0

1 1

12

(26)

Equilibrium: P1P2

=

1 10 1

fa

fb

(27)

Constitutive: fa

fb

=

AEL

a

0

0AEL

b

a

b

(28)

From these relations we can make the following identification:

[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 determinatebecause we can determine the member forces without using deformations. Most structural analysis problemsare not statically determinate, but if [B]

Tcan be inverted, we can construct the flexibility 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 flexibility approaches in specialcases, but practically all analysis is now done using a straight stiffness approach.


5/42

CEE 379 5

Having identified the degrees of freedom and the kinematic matrix, it is pretty much a matter of turningthe crank to generate the desired results. First we compute the system stiffness as

[K] = [B]T

[C] [B] (31)

=

1 10 1

AEL

a

0

0 AEL b

1 01 1

(32)

=

AELa +

AELb

AELb

AEL

b

AEL

b

(33)

Its not too hard to invert a 2 2:

[K]1

=1

D

AEL

b

AEL

b

AEL

b

AEL

a

+AEL

b

(34)

in which D =

AEL

a

+AEL

b

AEL

b

AEL

2b

=AEL

a

AEL

b

. For simplicity we will consider the specialcase in which P1 = 0, P2 = P. In this case, the system displacements are

12

=

1

D

AEL

b

AEL

b

AEL b

AEL a

+

AEL b

0P

(35)

= PD AE

Lb

AEL

a

+AEL

b

(36)

= P

LAE

a

LAE

b

+

LAE

a

(37)

The member forces can again be computed using equation (11):fa

fb

= [C] [B] {} (38)

=

AEL

a

0

0AEL

b

1 0

1 1

P

LAE

a

LAE

b

+

LAE

a

(39)

= P11 (40)

This final result matches what we could have seen from inspection in this case: the applied load P simplypropagates uniformly through the members.

1.3 Numerical Computation

In practical situations, calculations are carried out numerically rather than symbolically, and a tool thatsupports matrix operations such as MATLAB becomes quite useful. Consider again the example in Figure 2with the following numerical values: La = 5 ft; Aa = 2 in

2; Ea = 10, 000 ksi; Lb = 8 ft; Ab = 1.0 in2;

Eb = 29, 000 ksi; P1 = 5 kip; and P2 = 2 kip. The MATLAB code in Figure 4 can be used to solve thisproblem, and the resulting output is shown in Figure 5. These results are easy to verify by hand, and youshould do so.

1.4 Conceptual Summary

The basic set-up we used in the previous examples is sufficiently important and general that it is worthsummarizing in a pictorial manner. Figure 6 shows the relationships between the system and membervariables of interest, and the role played by the principles of equilibrium, kinematics, and constitutiverelations. Note how this diagram can be used to compose mathematical relations to get from one quantityto another. For example, if we know system displacements and want to calculate member forces, we start inthe 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 applyingmatrix operations in series leads to a right-to-left ordering, we have {f} = [C][B] {}. This matches theresult we derived earlier in equation (11).


6/42

CEE 379 6

%%---Simple Spring Example

%%---Useful constants

ft = 12;

%%---Physical Quantities

A_a = 2; %in 2L_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

SystemDisplacements

MemberDeformations

Kinematics/Compatibility [B]

MemberForces

SystemForces

Equilibrium [B]T

{}

{}

{P}

{f}Constitutive [C]

Stiffness [K]

Figure 6: Fundamental quantities and relations of structural analysis.


7/42

CEE 379 7

Load Paths

An important concept in structural engineering is that of a load path. A load path describes theway in which a load applied at a particular point in a structure is carried through to the structuressupports. For example, the weight of a person standing on the 4th floor of an office building mightfollow a load path something like the following: the weight is transferred from the floor to supportingbeams, 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 accommodatingload 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 figureillustrates that an indeterminate system typically allows for multiple equilibrium-satisfying loadpaths, while in a determinate system, the load path that satisfies equilibrium is unique. In theindeterminate system, the amount of the load flowing to each member is proportional to itsstiffness. The general rule of thumb is that stiffness attracts force, and so if one of the bars in thestatically indeterminate configuration shown were made of rubber and the other of steel, the steelbar would carry virtually all the load.

2 General Spring Models

The mechanics of materials examples in the previous section are simple, but not necessarily compellingbecause 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 difference this introducesinto our formulations is that we will replace expressions of the form f = (AE/L) with expressions ofthe form f = k. Figure 7 shows a typical configuration we can use to further develop our theories and

2

3

1

2

3 4

kd

ka kb

kc

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 setof equations:

Kinematics:

a

b

c

d

=

1 1 0 00 1 1 00 0 1 1

1 0 1 0

1234

(41)


8/42

CEE 379 8

Equilibrium:

P1P2P3P4

=

1 0 0 11 1 0 00 1 1 10 0 1 0

fa

fb

fc

fd

(42)

Constitutive:

fa

fb

fc

fd

=

ka

0 0 00 kb 0 00 0 kc 00 0 0 kd

a

b

b

d

(43)

In setting up these equations, it was easiest to figure out the kinematics relations and then simply transposethem to get the equilibrium relations. You should verify for yourself that resulting equilibrium relationsmake 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 necessarybut not sufficient condition for determinacyits also necessary that the matrix be invertible. The easiestcheck on this is to compute the determinant, which in this case turns out to be zero (in the case of a 4 4system, 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 ingeneral cause translation of the entire structure. We will have a more general means to characterize thiskind of instability shortly.

With the fundamental relations defined, we can generate a direct relation between system forces andsystem displacements in the usual way by computing the system stiffness:

[K] = [B]T

[C][B] (44)

=

ka + kd ka kd 0ka ka + kb kb 0kd kb kb + kc + kd kc

0 0 kc kc

(45)

Note that while [B] is square only in special cases (e.g., what happens to [B] in this case if member d isremoved?), the system stiffness is always square. Again, it is important to note that this does not necessarilyimply that the stiffness can be inverted. In the present case, we know that the structure as currently modeledhas no supports and is therefore unstable. This physical fact is manifested mathematically by considerationof the determinant: if the determinant of the system stiffness is zero, we cannot invert the stiffness, and sothere is not a unique relation between applied load and displacement. In effect, the structure can displacearbitrarily 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 stiffness can not have anegative determinant and be physically stable. A simplified explanation of this is to consider a single springsupported at one end, for which the system stiffness is simply a 1 1, i.e., [K] = [k]. For the determinantto 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 arepulling. This implies you can get more work out of the system than you put in, and our universe does notallow that.

Taken together, these observations lead us to the following useful fact:For a stable structure, the system stiffness will have a positive determinant.

This is an important analytical result with significant physical ramifications and many practical applications.The system stiffness in equation (45) in effect embodies our model of the structure. Although it is not

difficult to see how a computer can quickly construct such a system stiffness via matrix multiplication, itis not a particularly intuitive process in a physical sense. By considering the physical ramifications of thesystem stiffness, we will gain a better understanding of whats going on, and even more significantly, we willdiscover more effective ways to construct system stiffnesses for both hand and computer-based calculation.


9/42

CEE 379 9

2.1 Physical Interpretation of Stiffness Components

Globally speaking, the system stiffness relates system displacements to system loads: if we know how thestructure is displaced, we can determine what loads must be acting to cause that displacement. We knowthat we usually face the problem the other way around, i.e., we know the forces and wish to determine thedisplacements, but for purposes of physical interpretation, we can keep a displacement-centric view of ourstructure 2 .

To help understand what the terms of a stiffness matrix mean, we will consider a special case for thedisplacement 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

kd

ka kb

kc

1= 0

4= 0

Figure 8: Spring structure subjected to a unit displacement at joint 2; all other joints held fixed.

we have displaced joint 2 by a unit amount (e.g., 1in, 1mm, etc., depending on our units) while keeping allthe other joints fixed. We can use our system stiffness to determine the corresponding system forces 3 :

P1P2P3P4

=


0 0 kc kc

0100

(46)

=

ka

ka + kb

kb

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 secondcolumn of the system stiffness.

2. It would not be difficult to construct the set of system forces in equation (47) directly by consideringthe problem physically, looking at the forces associated with each spring individually. If we know howthe ends of a spring are displaced, then we know the end forces directly, so this is simple to do. Try it!

The first of these observations has general ramifications for understanding the physical meaning of a particularstiffness component, Kij. To see this, note that if we displace joint 3 instead of joint 2 (see Figure 9) thenwe get the following set of required system joint forces to maintain the given displacement:

P1P2P3P4

=


0 0 kc kc

0010

(48)

=

kd

kb

kb + kc + kd

kc

(49)

2Formulations based on displacements as the primary variables are called, not surprisingly, Displacement Methods. Thereis 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 willgive them some consideration later.

3Even though the system is unstable with respect to applied force, if we completely specify the displacements as we aredoing here, we do not have any problem with arbitrary displacement.


10/42

CEE 379 10

3 = 12= 0

1

2

3 4

kd

ka kb

kc

1= 0

4= 0


We could could do further examples, but it should not be difficult to convince yourself of the followinggeneral fact:

Each column in a 1-D spring system stiffness matrix corresponds to the set of joint forces causedby imposing a unit displacement to the corresponding joint (column 2 joint 2, column 3 joint3, etc.)

You have to be a little careful about the units, but this is a very handy way of thinking about stiffnesses. Italso allows us to further identify each entry i in the jth column, Kij, as having the following meaning:

Each stiffness entry, Kij, in a 1-D spring system stiffness matrix corresponds to the force at jointi induced by imposing a unit displacement at joint j.

Again, the Kij components do not have force units, but as long as one interprets the corresponds in theabove statement appropriately, this is a very powerful tool for physical understanding.

2.2 Direct Stiffness by Hand

The two observations noted in the previous section can be combined to provide a means to construct systemstiffnesses directly by hand. Given a structural system, we can construct the stiffness column by column bysimply visiting each joint in turn, applying a unit displacement, and determining the joint forces induced bythe displacement. For any problem of a size for which hand calculation makes sense, this is pretty simple todo, as illustrated in the following example.

Example 1 Construct the first column of the system stiffness for the structure in Figure 7, ignoring thesupports.

Solution We proceed by sketching the displaced structure for the case in which the first joint is given aunit displacement and all other joints are held fixed as shown in Figure 10. Looking at the figure, it

1

2

3 4

kd

ka kb

kc

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 isthe sum of the forces necessary to compress springs a and d, i.e., P1 k

a + kd. Similarly, the force atjoint 2 must act to the left (the negative direction) and match the compressive force in spring a, and sowe get P2 k

a. Joint 3 requires a negative force matching the compression in member d, P3 kd.

Finally, joint 4 has no deformed springs framing in, so no force is necessary, P4 0. Putting these


11/42

CEE 379 11

pieces together, we get the first column of the stiffness:

{Ki1} =

ka + kd

ka

kd

0

Note that this result matches what we obtained earlier via the matrix multiplication procedure.

Example 2 Construct the complete system stiffness for the structure shown in Figure 11, ignoring the rightsupport.

1 2 34

ka kb kc

Figure 11: Simple spring structure.

Solution Figure 12 contains a series of imposed unit displacements applied to each joint of the structure inturn. By determining the joint forces associated with each displacement, we can construct the stiffness

column by column. By exploiting the symmetry of the system stiffness, we can do this relatively

1 2 34

ka kb kc

1 2 34

ka kb kc

1 2 34

ka kb kc

1 2 34

ka kb kc

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 beingdisplaced. The resulting stiffness is thus

[K] =

ka ka ka + kb

0 kb kb + kc 0 0 kc kc

(50)

The dots in the above equation indicate entries that we can obtain from symmetry rather than fromscratching our head. If it is not obvious to you, you should use symmetry to fill in all the stiffnessentries, and then convince yourself that these entries are consistent with the reaction forces you wouldexpect for each corresponding displacement case.

Dr. Frame Exercise To get more of a hands-on feel for the relation between individual joint displacementsand the corresponding stiffness components, you can use Dr. Frame to get an inside view of whatshappening as you displace the joints in a structure. Figure 13 shows the Dr. Frame model we willuse to mimic the simple spring model from the previous example. The following steps will guide youthrough setting up this model, and then show you how to apply displacements and observe the inducedmember forces and joint reactions.


12/42

CEE 379 12

Figure 13: Dr. Frame configuration for studying axial system stiffness 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 ofthe grid to create a fixed support.

4. Click three more times along a horizontal row to create the additional supports indicated inFigure 134.

5. Choose the Rigid-Ended Member Tool and click once on the first support, and then click onthe second support to add a member. Add the remaining three members by clicking on thecorresponding end nodes, and you should have a configuration 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 onthe triangular bottom part), and then hit the right and left cursor keys a few times. You shouldobserve 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 somethingmore interesting to see as we impose displacement. Type s to turn on member force display, andthen type f to turn axial force coloring5. Type 8 to turn on reaction display, and then finallytype . (period) to set the force display to use fixed arrow sizes (for axial displacements of thiskind, the reaction forces are very large and go off 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 cursorkey 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 figure).In particular, you should see joint reaction forces appear in green, member forces will becomenon-zero, and the members adjacent to the second joint will change color. As you can probablysurmise, red indicates compression, and blue indicates tension. Depending on how far apart youset 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 thewindow (Windows), and you can use these to zoom in and out.

0 k-242 k242 k 242 k483 k242 kDCBA

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 yourobservations qualitatively to the second column of the system stiffness from the previous example.In effect 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 toselect one of the other joints (remember to click on the triangular bottom) and move it aroundwith the cursor keys (dont use the up and down keys yetwell do that later when we are studyingbeam systems). Again, work on aligning your observations with your intuition, and compare whatthe Dr. Frame model depicts to the stiffness components derived above.

You might want to save this model for future usejust use the standard Save command. If you havetime, you might try these further exercises:

4Dr. Frame has 10 levels of undo, so if you do something unintended, just undo it.5There are menu commands for all these operations, but the key shortcuts are quicker to use and identify in these exercises


13/42

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 locatingthe cross sectional area, A, and the elastic modulus, E, you will be able to do numerical handcalculations to compare with Dr. Frames results. You can get the members lengths by selectingthem 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 dialogto see the changesjust move the dialog out of the way and use the Preview button). Does whatyou observe make sense to you?

3. Using the Select Tool you can change the member lengths by clicking and dragging the jointshorizontally (be sure not to click on the support triangles in this caseclick on the joint boxesinstead). Again, see if the effect on the member forces and joint loads is what you expect.

2.3 Direct Stiffness via Assembly

The direct construction of the system stiffness 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 morecomputer-friendly approach to constructing system stiffnesses directly. Our approach will be to characterize

the stiffness of an isolated member, and then observe how each members stiffness influences the overallsystem stiffness. In effect, we will derive a means to construct a system stiffness by simply adding together(assembling) the contributions of each individual element in the system.

2.3.1 Member Stiffness

If we consider a structure composed of a single spring, the corresponding system stiffness must be the memberstiffness for the spring, since the member and the system coincide in this case. Figure 15 shows such a simpleconfiguration. Using the longhand approach, we have the following fundamental relations in this case:

j

i jke

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:

Pi = fe (52)

Pj = fe (53)

Constitutive:

fe

= ke

e

(54)From these relations we can see that [B] = [ 1 1 ] and [C] = [ke]. The system/element stiffness is thus

[K] =

ke ke

ke ke

(55)

Let us define the element stiffness as the relation between system displacements and the elements contri-bution to the system loads for those specific displacements and loads associated with the element. Note thatsince in this case the system and the member are the same, the element stiffness for the spring element isgiven by equation (55). This is an important and useful enough result that we will highlight it in a box:


14/42

CEE 379 14

1-D Spring Element Stiffness

[k]e =

ke ke

ke ke

Element stiffnesses 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 buildingblocks of real structures. Note that using the column-by-column stiffness construction described previouslyleads very quickly to the same result as given above. Note also in the case of the single element stiffness, itis simple to compute the determinant by hand. Is the system stable?

Before looking at the relation between system stiffnesses and element stiffnesses in the general case, wealso can highlight the following important element result:

1-D Spring Element Force

fe = [ ke ke ]

ij

This is simply the specific 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 wehave 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 wouldbe sensible in the physical case: we will disassemble the model and see how it is constructed. This will givesus the knowledge we need to put models together mathematically.

Consider the simple 3-element spring model shown in Figure 16. The stiffness for this structure matches

1 2 3 4

ka kb kc

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 theeffect of supports. Therefore, the system stiffness is

[K] =

ka ka 0 0ka ka + kb kb 0

0 kb kb + kc kc

0 0 kc kc

(56)

To take this structure apart, consider the sequence of configurations in Figure 17. Here the structure hasbeen disassembled into its pieces. The system stiffness for case (a) can be obtained from the expression in(56) by simply setting kb = kc = 0 (removing the stiffness of these elements is equivalent to removing theelements themselves). The result is as follows:

Ka

=

ka ka 0 0ka ka 0 0

0 0 0 00 0 0 0

(57)

Similarly we can write the stiffnesses for cases (b) and (c) as:

Kb

=

0 0 0 00 kb kb 00 kb kb 00 0 0 0

(58)


15/42

CEE 379 15

1 2 3 4

ka

1 2 3 4

kb

(a)

(b)

1 2 3 4

kc

(c)

Figure 17: Spring structure disassembly: (a) Member a alone; (b) Member b alone; (c) Member c alone.

Kc

=

0 0 0 00 0 0 00 0 kc kc

0 0 kc kc

(59)

There are two things to note about these expressions. First, the overall system stiffness is simply the sumof the system stiffnesses for each component:

[K] =e

[Ke] (60)

Second, and perhaps most important, if you compare the entries in each of the subassembly stiffnesses, [ Ke],to the standalone stiffness for a generic spring element we derived above, you can see that the only non-zeroentries in each [Ke] consist simply of a copy of the smaller standalone stiffness components. The only trickis putting the components from the smaller element stiffness into the correct places in the overall systemstiffness. The details of doing this are covered in the next section, but for now we can conclude that ifwe can do this elementsystem transfer correctly, then we can construct system stiffnesses by looping overthe elements or members in the structure, compute each elements standalone stiffness, and then add thesestiffness components to the overall system stiffness. This procedure is called assembly, and although we areonly 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.


16/42

CEE 379 16

2.3.3 Assembly

Conceptually, assembly is simply the process of accumulating element stiffness components into a structuressystem stiffness. The actual mechanism used to carry this out is more an algorithmic issue than anythingelse. As with any algorithm, there is a tie between the method used for accomplishing the task and thetechnique used to store the data. Here we will assume the simplest data storage model: a fully populatedmatrix. In this case, we can accomplish assembly for 1-D spring structures as follows:

1. Start with a system stiffness sized appropriately to hold the system stiffness 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 isthe 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 stiffness [k]e. For 1-D springs this will be a scalar 2 2 as derived earlier.

(b) Loop over the element stiffness components and add them to the system stiffness as follows:

for r = 1, 2for s = 1, 2

KI(e,r)I(e,s) = KI(e,r)I(e,s) + kers

end for

end for

After looping over all the elements, the system stiffness will be complete. As indicated by the pseudo codeabove, this is a process best suited for computer implementation rather than human bookkeeping. The keyto the process is in understanding the index mapping implied by the notation of the form I(e, r) that appearsin 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 elementin a particular structure. For example, consider the 3-element structure shown in Figure 16 in the previoussection, and look at element b. In the pseudo code above, when r = 1 it refers to the elements first end,and when r = 2, it refers to the elements second end. For element b, then, we can see from the picturethat I(b, 1) = 2 (element bs first 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 first and second system index, and these indicesare used by the element itself to accomplish assembly. All of this is best illustrated with some actual codethat works, and so lets consider some MATLAB code we could use to build stiffness matrices for arbitrary1-D spring assemblages.

2.3.4 MATLAB Example Code

Figure 18 shows simple MATLAB code that handles the assembly of a single element stiffness, adding theappropriate terms into the overall system stiffness. The code is relatively self-explanatory, with the onetricky item perhaps being the index map. The index map plays the role of the I(e, r) function introducedin the previous section, essentially mapping the elements first and second (i.e. r, s = 1, 2) joints to thecorresponding system indices. This allows the actual installation code at the end of the function to bewritten in the relatively compact loop shown.

For simple elements such as this, and in fact in many general cases, it is neither necessary nor efficientto implement the assembly using loops. The code in Figure 19 is an alternative implementation of springelement assembly, and you will probably agree it is simpler. It is shorter and more efficient, as well.

Regardless of which style of implementation one uses for the element assembly, code of the kind shown inFigure 20 is necessary to actually set up the system stiffness for structure with multiple members or elements.The first part of this code could be turned into simple file-based i/o, and then we would have in effect asimple program that could read in a file composed of element properties and connectivity information, andcompute the corresponding system stiffness. The second part of the code could be put in its own separatefunction, since it handles the actual system assembly. Note, however, that the second part of the code reliesdirectly on the data storage style implicit in the first part of the code. Keeping the two parts of the codetogether makes this link explicit, and there are various advantages to doing things this way. Ultimately, the


17/42

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.


18/42

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;

k e = 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: Stiffness building script for the structure in Figure 8, with numerical values for the various ke.

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 thatused 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 thestructures supports.

3. Modify the given code so that it works by reading in a file containing the element data.

2.4 Constraints

Now that we have a means to assemble stiffnesses relatively directly, we need to go back and figure out howto handle supports. We have seen earlier that one simple way to account for the presence of supports is tosimply remove the associated joint displacements from the problem. While this works, it is worth thinkingabout this a bit more generally. One useful perspective for thinking about solving systems of equations ofthis kind for displacements given load is to imagine a process by which you must adjust the displacements ateach joint in the structure until you find the unique set of displacements for which equilibrium is satisfied.In the presence of supports, there are some displacements you are not allowed to adjust, since these jointshave pre-determined displacement values (generally zero, but not always, as we will see). Each displacementyou are free to adjust is called a degree of freedom, and the inclusion of support conditions in effect takessome degrees of freedom and makes them no longer free. To account for this change in categorization, it isuseful to partition the joint displacements into two groups: free (which we will denote {f}) and supported


19/42

CEE 379 19

(which we will denote {s}). In general we can thus view the addition of supports as a partitioning of thesystem 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] {}

{Pf}{Ps}

=

[Kff] [Kfs ][Ksf] [Kss]

{f}{s}

(62)

in which {Pf} refers to loads applied at free joints, {Ps} refers to forces applied at the supports (i.e., thesupport reactions), and the stiffness component subscripts indicate interactions between the displacementand load groups.

With the system equations partitioned into free and supported parts, we can now look in more detail atthe general issue of solving for displacements for a given set of loads. In the partitioned system of equationsin (62), the unknowns are the fs and the support reactions, {Ps}. To see how to solve for these unknownsin the general case, we can simply expand the partitioned system into a longhand form:

{Pf} = [Kff] {f} + [Kfs ] {s} (63)

{Ps} = [Ksf] {f} + [Kss] {s} (64)

The first of these relations involves only one of our unknowns ({f}), so we can use this equation to solvefor the free displacements:

{f} = [Kff]1

({Pf} [Kfs ] {s}) (65)

Note that in the event the support displacements are all zero, this relation reduces to the simple-mindedapproach of ignoring constrained joints in setting up the problem. In this more general form, we can handlethe case of imposed support displacements6 as well as the usual applied loads. Once we have the freedisplacements calculated, we can then use equation (64) to determine the support reactions. This requiresno 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 ignoringsupported 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 configuration we used in an earlier example, with a load appliedat the left end. Lets use the general approach to determine the displacements and support reactionat joint 4. After setting the problem up symbolically, we will switch over to the following numericalvalues: ka = 100 k/in, kb = 150 k/in, kc = 200 k/in, and P = 10 kips.

1 2 3 4

ka kb kcP

Figure 21: Simple spring structure with support.

Solution From before, we know the relation between load and displacement for this structure can be writtenas follows

P1P2P3P4

=


0 kb kb + kc kc

0 0 kc kc

1234

(66)

6Foundation settlement is a practical example of an imposed joint displacement


20/42

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 inchesDelta_2 = 0.116667 inches

Delta_3 = 0.050000 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:

P1P2P3P4

=


0 kb kb + kc kc

0 0 kc kc

1234

(67)

From this relation we can make the following identifications:

{Pf} =

P1P2P3

=

1000

kip (68)

{Ps} = { P4 } (69)

{f} =

123

(70)

{s} = { 4 } = { 0 } (71)

[Kff] =

ka ka 0ka ka + kb kb0 kb kb + kc

= 100 100 0100 250 150

0 150 350

k/in (72)[Ksf] = [Kfs ]

T= [ 0 0 kc ] = [ 0 0 200]k/in (73)

[Kss] = [kc] = [200] k/in (74)

In these expressions we have put in the specific data relevant to the current problem. With thenumerical values in place, it is convenient to switch over to MATLAB to do actual computationsreflected 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


21/42

CEE 379 21

P4 = 10 kips, which is as we would expect in this case. Apparently the machinery is working, atleast in this case.

Example 2 Figure 23 shows another of our earlier spring structures, in this case with a load applied atjoint 3. Given ka = 100 k/in, kb = 150 k/in, kc = 200 k/in, kd = 50 k/in, and P = 10 kips, we needto determine the displacements and support reactions.

1

2

3 4

kd

ka kb

kcP

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 handlemore of the details for us. In particular, we start with the full stiffness we derived earlier, includingthe numerical values given:

[K] =


0 0 kc kc

=

150 100 50 0100 250 150 050 150 400 200

0 0 200 200

k/in (75)

Similarly, the full applied load matrix can be written as:

{P} =

00

100

kip (76)

From the figure we can see that the free joints are 2 and 3, and the supported joints are 1 and 4. SinceMATLAB makes it easy to pull out portions of matrices based on index sets, we can let MATLAB dothe partitioning for us. The MATLAB script in Figure 24 shows how this can be done. If you look atthe code closely, you should be able to see that everything following the index partition definitions isgenerali.e., there is nothing problem specific. 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 systemsolver. We would need to add to our input information some way of keeping track of which joints weresupported 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 animposed 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 tothe 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 willneed to add some way of handling joint input data. A common approach is to have an inputrow for each joint with an entry for an ID number, an applied load value, and a support flagindicating whether the joint is supported or free. By reading the joint data first, you candetermine the problem size, and then use this information to build an empty system stiffnessfor use by the assembly code.


22/42

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);

for i = 1:size(sysDisp,1)

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 kipsP_3 = 10.000000 kips

P_4 = -6.451613 kips

Figure 24: MATLAB script for computing support Example 2 results.


23/42

CEE 379 23

2.5 Misfit and Load-Independent Deformations

In the previous section, we encountered the possibility of support movements, which we related physicallyto such phenomena as foundation settlements. These are special cases of the more general phenomenon ofload-independent deformations that can occur in structures and structural components. Common sourcesof load-independent deformations are temperature changes, moisture content changes (significant in woodand concrete), fabrication variations, and residual plastic deformation following an overload. These kinds ofdeformations can be significant in various ways, either inducing large stresses in the structure, or in causingmovements and misalignments that have other problematic side effects. In this section we will see how wecan account for such effects in our structural models.

In our current 1-D world, the effect of any such phenomenon is a change in the initial or natural length ofan element. This influences how force and elongation are related. Mathematically we can write the following:

fe = ke(e e0) (77)

in which e0 represents the load-independent elongation. As illustrated in Figure 25, this relation offsetsthe force-displacement curve so that the natural, zero-force elongation is e0 rather than zero. If you heatsomething up, its natural length changes, and you have to add force to get back to its original length, andthat is what this kind of offset is modeling. To accommodate this in our analysis framework, we will look

fe

e

ke

e0

Figure 25: Force-elongation relation in the presence of load-independent elongation, e0.

again at our single element formulation as in Section 2.3.1. In particular, we will modify our constitutiverelation 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:

Pi = fe (79)

Pj = fe (80)

Constitutive:fe = ke(e e0) (81)

If we express these relations in a general form we have

Kinematics:{e} = [B] {e} (82)

Equilibrium:{Pe} = [B]

T {fe} (83)

Constitutive:{fe} = [Ce] ({

e} {e0}) (84)

Relating member forces to system displacements we get

{fe} = [Ce] ([B] {e} {e0}) (85)


24/42

CEE 379 24

This equation indicates how we calculate member forces in the presence of misfit once we have determinedthe system displacements. In effect, we need to subtract out the misfit strain as part of our calculation.

Relating system forces to system displacements we get

{Pe} = [B]T

[Ce] ([B] {e} {e0}) (86)

= [B]T

[Ce] [B] {e} [B]T

[Ce] {e0} (87)

= [ke] {e} {Pe0 } (88)

in which {Pe0 } = [B]T

[Ce] {e0}. This final relation shows that the effect on our formulation is to leave theelement stiffness unchanged, but we need to add to the system loads an additional contribution arising fromthe misfit in the element. For the 1-D spring case at hand, we already know what [ke] in equation (88)isusing the appropriate [B] and [C] we can determine that the effective misfit load we need to add to thesystem load is

{Pe0 } = [B]T

[Ce] {e0} (89)

=

11

[ke] {e0} (90)

= kee0 11 (91)

In its final form, it is easy to interpret the additional element misfit load as follows: if the member is toolong (i.e., e0 > 0 as shown in Figure 26(a)), then we need to compress the member to fit it into the structure(Figure 26(b)), and when we release the compression, the equivalent compressive force is transferred to themembers end joints, pushing to the left on the left end and to the right on the right end (Figure 26(c)).

ke

ie je

e0

ie je

ke

ke

ie je

e0k

ee0k

e

(a) Misfit (b) Precompression (c) Effective Load

e0k

e e0k

e

Figure 26: Physical interpretation of element misfit.

To incorporate member loads of this kind into our system equations, we can use a procedure analogous toour assembly procedure for stiffnesses. That is to say, we can loop over all elements, and add each elementsmisfit force contribution to the system loads as follows:

PI(r,e) PI(r,e) + Pe0r (92)

in which I(r, e) is the same index map used in the assembly of stiffnesses. The examples below will illustratethe application of this equation.

One other important thing to note is that these element misfit loads are not externally applied forces in

the normal sense, and so when evaluating final system reactions and joint loads, these member forces needto 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 forthe case in which the member has a misfit of e0. Note that the answers to all these questions are evidentfrom inspection: the force in the member will be zero, the reaction force at joint 2 will be zero, and thedisplacement at joint 1 will be e0. To see our analysis machinery work to arrive at these results, we startwith the system stiffness, which is just the element stiffness in this case:

[K] =

k k

k k


25/42

CEE 379 25

1 2k

Figure 27: A single-spring structure to illustrate member misfit.

In partitioned form, the system equations can thus be written:0

R2

=

k k

k k

10

(93)

in which we have used the notation R2 to indicate that system force at joint 2 is a reaction. Now we add inthe effect of the elements misfit force:

ke0R2 + ke0

=

k k

k k

10

(94)

Expanding these matrix expressions leads to the following:

k

e

0 = k1 (95)P2 = R2 + k

e0 = k1 (96)

From the first of these equations we can see that 1 = e0, as expected. The second equation then becomes

P2 = R2 + ke0 = k

e0 (97)

Note that R2 = P2 ke0 = 0, which illustrates the need to subtract back out of member misfit load fromthe computed system force (P2 in this case). The member force is calculated using equation (85):

f = k(2 1 e0) (98)

= k(0 (e0) e0) (99)

= 0 (100)

The results all turn out as expected, but we can see how it is necessary to insert and remove the misfit termsin a consistent fashion.

Now we are ready to consider some more involved examples and to look at how the approach can beimplemented 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 elongationis 0.02 inches.

1

2

3 4

kd

ka kb

kc

Figure 28: A 1-D structural system based on simple springs.

Solution The solution of problems with misfit proceeds the same as the solution to any linear structuralanalysis problem, the primary difference being the alteration of the system load to account for themisfit. The system stiffness is thus set up the same as usual:

[K] =

ka + kb kb

kb kb + kc + kd

(101)


26/42

CEE 379 26

The system loads in this case are solely due to the misfit:

{Pf} =

0.02kb

0.02kb

(102)

The free system displacements are thus given by {f} = [K]1 {Pf}. To determine the final force

in member b, we use equation (85), which accounts for the member force due the movement of themembers end joints plus the pre-existing force due to squeezing the misfitting member into place. Inparticular, we can write:

fb = kb(3 2) 0.02kb (103)

Example 2 Write a MATLAB function that adds a spring elements misfit effect to the system load, andwrite an additional function that computes a members force in terms of system displacements andmember misfit.

Solution There are various ways one might do this depending on how the data are structured. We willuse an approach similar to that in our assembly code from Section 2.3.4. In particular, we will setthings up so that the member end joint indices are passed into our function, along with the memberstiffness, ke, and a specified misfit. 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 misfit.

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 asthings can get.

Example 3 For the same structure used in Example 1 above, combine the assembly code, misfit membercode, and the support code to determine the displacements, member forces, and support reactions forthe following combination of problem parameters:

Member stiffness values as follows: ka = 100 k/in, kb = 200 k/in, kc = 300 k/in, and kd =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.


27/42

CEE 379 27

function fe = Spring_MemForce(i,j,ke, delta0, sys_Disp);

%---Input variables



% delta0 = member misfit

% sys_Disp = system displacements

%---Compute member forcefe = ke * (sys_Disp(j) - sys_Disp(i) - delta0);

Spring_MemForce = fe;

Figure 30: MATLAB script for computing member force including member misfit.

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 linear1-D spring models. If we can write code to solve this problem, we will have the framework to solve justabout 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 ithere piece by piece. The majority of the code has been seen before in earlier listings. The frameworkof the code (what each step does) is more important than the details of the code (how each step isaccomplished), 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 moregeneral file reading form7:

%%---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 ];

%%---Element definitions

%% 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 definitions, and then build the system stiffness:

%%---Set up some constants for indexing

jointi = 1;

jointj = 2;

ke = 3;

delta0 = 4;

ID = 1;

P_i = 2;

fixity = 3;

7Note that file reading code could include error checking and allow for more general input styles


28/42

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:numEltssysK = 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 effect of the member misfit loads (more general code might check whether anymisfit exists during file reading, set a flag 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, whichwe accomplish by looping over the joints and accumulating the corresponding indices into free andsupported categories:

%--- Step 5: Set up fixed and free partitions

idx_f = [];

idx_s = [];

for i=1:sysSize

if Joints(i, fixity) == freeidx_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-specific 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


29/42

CEE 379 29

As we saw earlier, we need to back out the effect of the misfit member joint loads. We do this bycalling Spring InstallP0 again using a reversed sign on the misfit:

% ---Step 9: Back out the misfit pseduo-loads

for e = 1:numElts

sysP = Spring_InstallP0(Elements(e,jointi),Elements(e,jointj ),Elements(e,ke),...

-Elements(e,delta0),sysP);

end

We can now print out the displacement and reaction results, and use these results to compute themember forces. Note that the member force function accounts for the pre-existing misfit load, andnote also how we use an alphabet string to preserve letter-based member labeling. This obviouslyrestricts us to 26 members, and so in more general contexts one must resort to numerical ids (orconstruct 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));

endfprintf(1, ---Member Forces: \n);

alphabet = abcdefghijklmnopqrstuvwxyz;

for e = 1:numElts

fe = Spring_MemForce(Elements(e,jointi),Elements(e,jointj),E lements(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:





---Joint Loads/Reactions: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 415 k 53.8k

9.7k9.7k

29.1 k

38.8k

29.1 k

9.7k

9.7k

53.8k 53.8k

Figure 31: Verification 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 worthmaking a general statement in this regard: Doing independent checks on computer-generated results isan extremely important part of engineering analysis. This is easy to state, but it is not always easy todoif it were simple to generate results independent of the computer analysis, we would not need the


30/42

CEE 379 30

computer analysis in the first place. In the context of structural analysis, it is not generally practicalto try to solve the problem by hand for a check, and so one of the most common and reliable ways ofchecking results is to ensure that the solution achieves what it set out to achieve. In particular, wecan verify that equilibrium is satisfied. For the problem at hand, Figure 31 shows free body diagramsfor each joint in which the various force quantities correspond to the computer results. It can be seenthat 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 allcomputer-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 thevarious intermediate results.

2. Change the support conditions so the problem becomes statically determinate, run variouscases, and check by hand. What is the effect of misfit or imposed support displacement inthe case of a statically determinate system?

3. Change the code to read its input from a file, 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.


31/42

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 anelement, it makes sense to return again to a mechanics of materials view of the world and consider morecarefully how a 1-D axial element can be derived from fundamental principles. In particular, we will gothrough a derivation of the stiffness coefficients for a 1-D element using a differential equation approach.

The main point is to provide a simple example that parallels the more involved derivations we will need inthe case of beams.

3.1 1-D Elasticity Formulation

Like any structural mechanics formulation, we need to address the fundamental issue of characterizingequilibrium, kinematics, and constitutive behavior. From a mechanics of materials perspective, we need tocarry out these characterizations at the level of stress and strain rather than force and displacement, andwe need to consider differential elements rather than finite 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, andthe displacement of each point from its original location denoted u(x). In general, we can have distributedapplied 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 thebody 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) = limx0

u(x + x) u(x)

x=

du

dx(105)

Lets box this result up so its easy to find:


32/42

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), variesthrough the body. Following the usual practice, we isolate a small element of material, apply equilibriumto 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

dxx +

1

2

d2

dx2 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 thatb(x) is an applied force per unit length, we can write the following expression for the balance of force on asmall 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) + Axd

dx+ . . . + b(x)x = 0 (107)

Canceling the first terms, dividing through by x, and then taking the limit x 0 we get the followingdifferential equation of equilibrium:

1-D Equation of Equilibrium

Ad

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 stressand 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 forequilibrium, we are now in a position to solve any 1-D elasticity problem. Following a similar approach tothe discrete analysis we have done so far, we will express equilibrium in terms of displacements, and use thisas our governing equation. Combining our constitutive and kinematics relations, we get

(x) = Edu

dx(108)

Substituting this expression into the equilibrium equation then leads to the desired governing equation:


33/42

CEE 379 33

1-D Elasticity Governing Equation

EAd2u

dx2+ 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, EI v

(x) = q(x), we can see that there is a great dealof similarity between the two. In both cases there is a differential relation between displacement and appliedload, with material and cross section parameters as linear multipliers. While the beam equation and itsapplications are of much more general practical interest than the 1-D rod equation, the axial equation issimpler to work with and understand. We will thus use the axial case primarily as an aid in preparingourselves 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 usefulagain later in the case of beams:

1. Deriving member stiffnesses from differential 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 first of these will provide us with a mechanism to construct general structural models from various kindsof 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 Stiffness Derivation

We have seen that the stiffness of an element provides a relation between displacement of its ends and theresulting joint reactions. Our task for our 1-D rod, then, is to determine the end reactions necessary tosustain an arbitrary set of end displacements as illustrated below:

ui uj

We have seen before that linear stiffness does not depend on loading, so we start with the generalanalytical solution of the governing equation EAu = 0 (i.e., we consider an unloaded element and takeb(x) = 0):

u(x) = c1x + c2

Next, we define equations expressing the two boundary conditions u(0) = ui and u(L) = uj. Using thesolution given above, we can write

c2 = ui

c1L + c2 = uj

We now need to solve these two equations so that we can express the constants c1, and c2 in terms of theparameters we are interested in: the end displacements. This is a matter of doing some algebra, and theexpressions we get can be put in the following form:

u(x) = uiN1(x) + ujN2(x)

The shape function expressions, Ni(x), are easily derived and are given below:

N1(x) = 1 x

L

N2(x) =x

L


34/42

CEE 379 34

We are now ready to extract the stiffness coefficients by evaluating the appropriate shape function deriva-tives at the end points. This follows from the fact that, for example, Pi = (0)A = EAu(0) =EA [uiN1(0) + ujN

2(0)] This can be summarized in matrix form as indicated below:PiPj

= AE

N1(0) N

2(0)N1(L) N

2(L)

uiuj

Carrying out the simple evaluations in the matrix above, we end up with the standard 1-D truss elementstiffness matrix:

[k] =

k k

k k

in which the single stiffness coefficient, k, is defined as follows:

k =AE

L

This is of course the exact same stiffness we had before, which should not be surprising. The key here is tosee how we used the fundamental differential equation with imposed displacement boundary conditions todetermine the necessary reactions, and thus the corresponding stiffness 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 needa means for incorporating such loadings into our models. From the perspective of our 1-D elasticity model,we must figure out how to handle cases in which b(x) = 0.

Our approach will once again rely on adapting some basic results from differential equations. In particular,we will use the fact that for linear differential equations we can consider the solution to equations with anon-zero right-hand side (b(x) in the present case) as the sum of a homogeneous and particular part:

u(x) = uh(x) + up(x) (109)

The key to making this work is in defining carefully what each solution satisfies in terms of boundaryconditions as well as the right hand side. The expressions below show how we set things up:

EAuH = 0 EAu

p = b(x)

uH(0) = ui up(0) = 0uH(L) = uj up(L) = 0

Note that the homogeneous solution takes account of the non-zero boundary conditions, while the particularsolution accounts for the load, but keeps the end displacements fixed. When we add the solutions togetherwe get:

EA(uH + u

p) = b(x) (110)

uH(0) + up(0) = ui (111)

uH(L) + up(L) = uj (112)

This is just what we need: a solution accounting for applied load (b(x)) and arbitrary joint displacements(ui and uj).

To adapt these results to our structural analysis framework, note that uH

(x) is just the solution weobtained in the previous section. Expressing the relation between system loads and system displacementsincluding the particular solution terms gives us the following:

PiePje

=

k k

k k

uieuje

+

AEup(0)AEup(L)

(113)

Remember that the system-level analysis is responsible for determining the joint displacements, and notethat b(x) is a known loading function, so in principle we know up(x). This means that the effect of thein-span load is to add some additional joint loading to the system load:

PiePje

PiePje

+

Fe1Fe2

(114)


35/42

CEE 379 35

in which Fe1 = AEu

p(0) and Fe2 = AEu

p(L). Note the close similarity between this result and what we sawearlier in the case of member misfit (c.f. equation (92)). This indicates that as far as our overall structuralsystem model goes, we handle in-span member loads by simply computing the equivalent end reactionscaused by the in-span loads in the case of zero end displacements, and then assemble these additional loadsinto the system loads in the usual fashion. As in the case of member misfit loads, we then need to properlyaccount 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 loadsfrom the joint loads, and in computing member end reactions, we must use relations of the form:

fe1 = k(uie uje) Fe1 (115)

fe2 = k(uje uie) Fe2 (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 memberb, and the reaction at supports 1 and 3.

12

3

b0

E, A, L E, A, La b

Figure 35: A 1-D rod assemblage with in-span loading.

Solution The system stiffness is simple to compute in this case, especially since the member properties areidentical:

1 d Structures basic concepts

Documents

Transcript of 1 d Structures basic concepts