MechanicsExplorers`Beam`

A User-friendly Exploration Program for the Bending of Beams

Author's Address

Stephan Kaufmann
Institute of Mechanical Systems
Swiss Federal Institute of Technology, ETH Zürich
CH-8092 Zürich, Switzerland
E-mail:
stephan.kaufmann@imes.mavt.ethz.ch
URL:
http://www.zfm.ethz.ch/~kaufmann/
© 2004 by Stephan Kaufmann
Version 1.8, May 2004

Requirements

This package is written for Mathematica Version 3.0 or higher. It does not work with earlier versions.

Installation

Copy the directory MechanicsExplorers with its all contents into the directory <Mathematica installation directory>/AddOns/Autoload.
You can also use the AddOns/Applications directory. In this case, you have to manually load the package before using its functions.

Rebuild your help index (use the command Rebuild Help Index in the menu Help).

On a multi-user systems, you can use your <personal Mathematica directory> instead of the <Mathematica installation directory>. Your <personal Mathematica directory> is identical to the value of the global variable $PreferencesDirectory.

If you are using Mathematica 3.0, you must copy the file FrontEnd/Palettes/BeamPalette.nb to the directory <Mathematica installation directory>/Configuration/FrontEnd/Palettes or <personal Mathematica directory>/FrontEnd/Palettes.

Theoretical Information

Assumptions

This package uses the Euler-Bernoulli theory for (small) deflections of thin elastic straight beams.

The coordinate system is chosen such that the x-axis lies parallel to the beam and points to the right, the y-axis points vertically downwards, and the z-axis points backwards into the screen.

[Graphics:HTMLFiles/BeamDocumentation_1.gif]

The z-axis coincides with the axis of a main moment of inertia (I_z ). Only forces in the y-direction and moments in the z-direction are considered. Torsion and elongation are neglected.

The Algorithm

The basic function of this package is SolveBeam. It calculates the shear force S_y, the bending moment M_z, and the deflection y (as well as its slope y') for beams with given loads (discrete forces, distributed forces, and discrete moments), supports (simple or fixed), and possibly hinges. The bending stiffness EI_z can be described by arbitrary functions; discontinuities have to be expressed with the help of UnitStep functions (from the standard package Calculus`DiracDelta`). E is Young's modulus, I_z  the main moment of inertia about the z-axis.

The solution is calculated by integrating the following well known differential relations (f_y is the distributed force in y-direction):

∂S_y(x)/∂x == -f_y(x)

∂M_z(x)/∂x == -S_y(x)

∂^2y(x)/∂x^2 == M_z(x)/EI_z

Discrete forces and moments (either given externally or in the supports) are added in the form of UnitStep functions. An unknown force has to be added in a simple support, an unknown force and an unknown moment in a fixed support.

The unknown forces and moments, as well as the constants of integration, can be determined by taking into account the following relations.

In a simple support at x_0:

y(x_0) == 0

In a fixed support at x_0:

y(x_0) == 0

∂y(x)/∂x/.xx_0 == 0

In a hinge at x_0:

M_z(x_0) == 0

Furthermore, the limits of S_y and M_z, as x approaches the end points of the beam from outside of the beam, have to vanish.

This works for statically determinate and statically indeterminate systems.

Using the Package

The functions of this package work best if the positions and values of supports and loads are dimensionless numerical quantities. As far as possible, the solutions can also be derived for symbolic values. But, in this case, the results tend to be complicated, and the plotting functions will not work. If you want to use units, please read the remark below.

All functions defined in the package can be used from the BeamPalette which appears in the File > Palette menu after the installation. There are three levels of simplicity for the interaction with the package:

Simple

You are guided through the use of the functions, either by dialogs, or by text which is pasted into your notebook. The corresponding switch (Input by Dialogs or Input by Evaluating Expressions) can be set from the palette. All calculations are done with hidden work objects.

Medium

The medium level also uses hidden work objects for the definitions and calculations. But here, the palettes only paste templates into the notebook. You are expected to supply the parameters and to evaluate the expressions.

Advanced

The advanced level basically uses the same functions as above, but you are requested to give a name for the beam and for the solution. Instead of constructing a beam step by step, you can directly define the end points, supports, and loads in a Beam object.

In the advanced mode, the solution has to be calculated explicitly with the function SolveBeam. The resulting object can then be plugged into the drawing, printing, and plotting functions.

The Symbols for Supports and Loads

The following symbols are used to represent supports and loads of beams.

A simple support: [Graphics:HTMLFiles/BeamDocumentation_23.gif]

A fixed support:[Graphics:HTMLFiles/BeamDocumentation_24.gif]

A hinge:[Graphics:HTMLFiles/BeamDocumentation_25.gif]

A positive discrete force: [Graphics:HTMLFiles/BeamDocumentation_26.gif]

A positive distributed force:[Graphics:HTMLFiles/BeamDocumentation_27.gif]

Moments (positive and negative): [Graphics:HTMLFiles/BeamDocumentation_28.gif][Graphics:HTMLFiles/BeamDocumentation_29.gif]

Remark about Units

It is possible to add units; the unit names are just treated as symbolic quantities. But the package cannot differentiate between units and other symbol names. In order to simplify the results, additional information should be given in the form of positivity definitions for the unit names. For example:

In[1]:=

Positive[meter]^=True ;

In[2]:=

Positive[newton]^=True ;

General :: spell1 : Possible spelling error: new symbol name \"newton\" is similar to existing symbol \"Newton\".  More…

Loading the Package

The package has to be loaded manually, if it is not installed in the AddOns/Autoload directory.

Needs[MechanicsExplorers`Beam`]   load the package

Loading the package.

In[3]:=

Needs["MechanicsExplorers`Beam`"]

The Simple User Mode

In the simple user mode, all functions operate on hidden work beams and work solutions. When necessary, the solutions are calculated automatically.

Usually, in the simple user mode, the palette buttons are used. But it is also possible to call the functions directly, normally by giving an empty argument. Except for the construction functions, this coincides with the medium user mode.

After loading the package (see Installation), you can either use at the default work beam (it has a fixed left end and a force at the right end) or start constructing your own beam. The construction is done by adding supports and loads, and possibly defining the end points of the beam, or the bending stiffness. After the construction phase, various plots can be drawn, or the results can be printed in a nicely readable form, or they can be returned as pure functions for further calculations.

Setting the Switches

By default, every change of the loads and supports of the work beam is drawn into your notebook. And also by default, your input is requested by dialogs. This default behavior can be changed with the Switches palette.

Draw each Modification                                           SetDrawEach[True]             ...                                     the input is given by filling the place holders and evaluating

Setting the switches.

The input mode using dialogs is not very useful for the examples in this notebook. Therefore, we click at Input by Evaluating Expressions.

In[4]:=

SetInputDialogs[False]

Out[4]=

False

Constructing Beams

A beam consists of the left and right end points, a bending stiffness function, and definitions for supports (simple or fixed) and (moments or forces), and, possibly hinges. The default end points are 0 and 1, the default bending stiffness is a constant. A beam is "constructed" by adding definitions for the elements.

New Work Beam                                                                                  ... nction (e . g ., #^2&) or a list containing an expression and the variable (e . g ., {x^2, x})

Constructing a beam.

We clear the work beam (New Work Beam).

In[5]:=

NewWorkBeam[]

Now we define a fixed support at 0 (Add Fixed Support) and a simple support at 4/5 (Add Simple Support) and introduce a force at 2/5 (Add Discrete Force) and a moment at 1 (Add Moment). The text cells are automatically pasted into the notebook.

Replace the placeholder in the following input cell by the position of the fixed support. Then evaluate the cell.

In[6]:=

AddFixedSupport[0]

Replace the placeholder in the following input cell by the position of the simple support. Then evaluate the cell.

[Graphics:HTMLFiles/BeamDocumentation_50.gif]

Out[6]=

⁃Graphics⁃

In[7]:=

AddSimpleSupport[4/5]

Replace the placeholders in the following input cell by the position and the value of the force. Forces pointing downwards are positive. Then evaluate the cell.

[Graphics:HTMLFiles/BeamDocumentation_53.gif]

Out[7]=

⁃Graphics⁃

In[8]:=

AddForce[2/5, 2]

Replace the placeholders in the following input cell by the position and the value of the moment. Moment vectors pointing into the screen are positive. Then evaluate the cell.

[Graphics:HTMLFiles/BeamDocumentation_56.gif]

Out[8]=

⁃Graphics⁃

In[9]:=

AddMoment[1, 1]

[Graphics:HTMLFiles/BeamDocumentation_59.gif]

Out[9]=

⁃Graphics⁃

Drawing and Plotting Beams and Results

The drawing and plotting functions automatically solve the work beam, if necessary, and display the requested result. The positive (y-) axis in the representation of deflections and slopes points downwards (see the definition of the coordinates).

Draw Beam                                                                                      ... rk solution, and plot the bending stiffness, the shearing force, the bending moment, and the slope

Plots and drawings of beams and solutions.

By using the Plot and Draw All button, we can draw all relevant results in one step. The solution is calculated automatically.

In[10]:=

DrawAll[]

[Graphics:HTMLFiles/BeamDocumentation_64.gif]

Out[10]=

⁃GraphicsArray⁃

Printing Results

These functions print the results in a nicely readable form. Discontinuities are represented by printing the formulas and the corresponding intervals. The printed results cannot be used for further calculations, because they are written in term of a string "x" (to avoid possible conflicts with a global variable x).

Print Bending Stiffness       PrintBendingStiffness[]       print the bending stiffness  Print ...  print the slope  Print Deflection              PrintDeflection[]             print the deflection

Printing results in a nicely readable form.

Let us look at the shearing force (Print Shearing Force) and at the bending moment (Print Bending Moment) of our work beam. The results already have been determined.

In[11]:=

PrintShearingForce[]

S_y =   1                                        2                --                   ...        4                              -                0      ,      5      <   x      <   1

In[12]:=

PrintBendingMoment[]

M_z =   1   x                                                            2             ...               -                1          ,          5          <       x          <       1

Results as Pure Functions

The results can be requested in the form of pure functions containing UnitStep functions. These results can be used for further calculations.

Return Bending Stiffness       BendingStiffness[]             return the bending stiffness  Re ... urn the slope  Return Deflection              Deflection[]                   return the deflection

Results in the form of pure functions.

The deflection of the beam, written as a pure function, has the following form (Return Displacement).

In[13]:=

Deflection[]

Out[13]=

(25 #1^2 (-6 + 5 #1) - 5 (-4 + 5 #1)^3 UnitStep[-4/5 + #1] + 4 (-2 + 5 #1)^3 UnitStep[-2/5 + #1])/1500&

This function can, e.g., be evaluated for a couple of values.

In[14]:=

Table[%[x], {x, 0, 1, 1/10}]

Out[14]=

{0, -11/12000, -1/300, -27/4000, -4/375, -57/4000, -23/1500, -137/12000, 0, 21/1000, 13/250}

The Medium User Mode

The medium level also uses hidden work objects for the definitions and calculations. But, here, the palettes only paste templates into your notebooks. You are expected to supply the parameters and to evaluate the expressions. This level is preferable once you have learned which parameters should be inserted into the construction functions.

Setting the Switch

Only the switch SetDrawEach makes sence here. If set True, all changes of supports and loads are automatically reflected by a drawing.

SetDrawEach[v]                                                             set the switch to True (draw all changes of supports and loads) or False

Setting the switch to draw or not to draw all changes of supports and loads.

Accessing the Work Objects

Advanced users can access to the hidden work beam and work solution. The SetWorkBeam and SetWorkSolution functions require the knowledge Beam objects and solutions. They are mainly useful when working with the advanced form of the functions.

GetWorkBeam[]                            return the work beam as a Beam object  SetWorkBeam[b] ...      return the work solution  SetWorkSolution[s]                       set the work solution to s

Accessing the work beam and the work solution.

Let us glimpse at the work beam and at the work solution. (Their structure will be explained in the section for advanced users.)

In[15]:=

GetWorkBeam[]

Out[15]=

Beam[{0, 1, 1&}, {Fixed[0], Force[2/5, 2], Moment[1, 1], Simple[4/5]}]

In[16]:=

GetWorkSolution[]

Out[16]=

{{1/2 (-1 + 5 UnitStep[-4/5 + #1] - 4 UnitStep[-2/5 + #1]) &, 1/10 (-5 (-4 + 5 #1) UnitSte ... d[0], Force[0, 1/2], Moment[0, 1/5], Force[2/5, 2], Moment[1, 1], Simple[4/5], Force[4/5, -5/2]}]}

In this solution, we can see the forces and moments in the supports. The force at 0 is 1/2, the moment at 0 1/5. The force at 4/5 is -5/2.

Constructing Beams

NewWorkBeam[]                                                                                  ... nction (e . g ., #^2&) or a list containing an expression and the variable (e . g ., {x^2, x})

Constructing a beam.

We can remove the moment which has been added last to the work beam.

In[17]:=

RemoveLastElement[]

[Graphics:HTMLFiles/BeamDocumentation_91.gif]

Out[17]=

⁃Graphics⁃

Instead, we add a distributed force.

In[18]:=

AddForce[{4/5, 1}, 10 (# - 4/5) &]

[Graphics:HTMLFiles/BeamDocumentation_94.gif]

Out[18]=

⁃Graphics⁃

Solving Beams

The solution of the work beam can be requested explicitly, even though it is calculated automatically when necessary.

SolveBeam[]                                                                 solve the work beam ; the work solution is the result of this calculation

Solving the work beam.

We can request the solution for the new work beam.

In[19]:=

SolveBeam[]

Out[19]=

{{53/40 + (-93/40 + 8 #1 - 5 #1^2) UnitStep[-4/5 + #1] - 2 UnitStep[-2/5 + #1] &, 43/150 - ... 0, -43/150], Force[2/5, 2], Force[{4/5, 1}, 10 (#1 - 4/5) &], Simple[4/5], Force[4/5, -7/8]}]}

Drawing and Plotting Beams and Results

DrawBeam[]                                                                                     ... rk solution, and plot the bending stiffness, the shearing force, the bending moment, and the slope

Drawing and plotting beams and solutions.

This produces a plot of the deflection.

In[20]:=

PlotDeflection[]

[Graphics:HTMLFiles/BeamDocumentation_101.gif]

Out[20]=

⁃Graphics⁃

The plot is a little bit clearer than the sketch.

In[21]:=

DrawSolution[]

[Graphics:HTMLFiles/BeamDocumentation_104.gif]

Out[21]=

⁃Graphics⁃

But the forces and moments in the supports are visible here.

Printing Results

PrintBendingStiffness[]       print the bending stiffness  PrintShearingForce[]          print ...  PrintSlope[]                  print the slope  PrintDeflection[]             print the deflection

Printing results in a nicely readable form.

The slope now hat the following form.

In[22]:=

PrintSlope[]

y ' =                  (344 - 795 x) x                                                 ... t;                             x                                <                             1

Results as Pure Functions

BendingStiffness[]             return the bending stiffness  ShearingForce[]                re ... pe[]                        return the slope  Deflection[]                   return the deflection

Results in the form of pure functions.

Except at the positions of discrete forces and moments, the derivative of the bending moment is the negative shearing force.

In[23]:=

Simplify[BendingMoment[] '[x] + ShearingForce[][x]]

Out[23]=

0

In[24]:=

Plot[%, {x, 0, 1}]

[Graphics:HTMLFiles/BeamDocumentation_113.gif]

Out[24]=

⁃Graphics⁃

The Advanced User Mode

The advanced level basically uses the same functions as above, but you are requested to give a name for the beam and for the solution. Instead of constructing a beam step by step, you can directly define the length, supports, and loads in a Beam object.

In the advanced mode, the solution has to be calculated explicitly with the function SolveBeam. The resulting object can then be plugged into the drawing, printing, and plotting functions.

Constructing Beams

All construction functions can either be used to manipulate a Beam variable, or their result can be assigned to a variable.

NewBeam[]                                                                                      ... nction (e . g ., #^2&) or a list containing an expression and the variable (e . g ., {x^2, x})

Constructing beams.

This defines the variable b1 to be an empty beam of length 1.

In[25]:=

NewBeam[b1]

Out[25]=

Beam[{0, 1, 1&}, {}]

In[26]:=

b1

Out[26]=

Beam[{0, 1, 1&}, {}]

We now add two simple supports and a force.

In[27]:=

AddSimpleSupport[b1, .1]

Out[27]=

RowBox[{Beam, [, RowBox[{{0, 1, 1&}, ,, RowBox[{{, RowBox[{Simple, [, 0.1, ]}], }}]}], ]}]

In[28]:=

AddSimpleSupport[b1, .9]

Out[28]=

RowBox[{Beam, [, RowBox[{{0, 1, 1&}, ,, RowBox[{{, RowBox[{RowBox[{Simple, [, 0.1, ]}], ,, RowBox[{Simple, [, 0.9, ]}]}], }}]}], ]}]

In[29]:=

AddForce[b1, .5, 1]

Out[29]=

RowBox[{Beam, [, RowBox[{{0, 1, 1&}, ,, RowBox[{{, RowBox[{RowBox[{Force, [, RowBox[{0.5, ,, 1}], ]}], ,, RowBox[{Simple, [, 0.1, ]}], ,, RowBox[{Simple, [, 0.9, ]}]}], }}]}], ]}]

The same could have been achieved in one step by a functional approach.

In[30]:=

AddForce[AddSimpleSupport[AddSimpleSupport[NewBeam[], .1], .9], .5, 1]

Out[30]=

RowBox[{Beam, [, RowBox[{{0, 1, 1&}, ,, RowBox[{{, RowBox[{RowBox[{Force, [, RowBox[{0.5, ,, 1}], ]}], ,, RowBox[{Simple, [, 0.1, ]}], ,, RowBox[{Simple, [, 0.9, ]}]}], }}]}], ]}]

The Definition of Beam Objects

Instead of constructing beam step by step, they can also be defined directly. Beams are represented by Beam objects. A Beam object contains two lists.

The first list defines the left and right end points and the bending stiffness (given as a pure function with UnitStep expressions defining the discontinuities).

The second list defines the supports (Simple and Fixed elements), hinges (Hinge elements) and loads (Force and Moments elements).

Beam[{l, r, b}, {e}]                                                                           ...              a distributed force in the interval [ l, r]   defined by the pure fuction f

The structure of Beam objects.

This defines the beam from above.

In[31]:=

RowBox[{b1, =, RowBox[{Beam, [, RowBox[{{0, 1, 1&}, ,, RowBox[{{, RowBox[{RowBox[{Force, [ ... [{0.5, ,, 1}], ]}], ,, RowBox[{Simple, [, 0.1, ]}], ,, RowBox[{Simple, [, 0.9, ]}]}], }}]}], ]}]}]

Out[31]=

RowBox[{Beam, [, RowBox[{{0, 1, 1&}, ,, RowBox[{{, RowBox[{RowBox[{Force, [, RowBox[{0.5, ,, 1}], ]}], ,, RowBox[{Simple, [, 0.1, ]}], ,, RowBox[{Simple, [, 0.9, ]}]}], }}]}], ]}]

Solving Beams

When working with several beam objects, it is useful to assign the solutions to variables. These solution variables can the be analyzed with the plot and print functions.

SolveBeam[b]                            return the solution of a beam problem

Calculating the solution of a beam problem.

We solve the beam b1 from above.

In[32]:=

s1 = SolveBeam[b1]

Out[32]=

RowBox[{{, RowBox[{RowBox[{{, RowBox[{RowBox[{RowBox[{RowBox[{0.5,  , RowBox[{UnitStep, [, Row ... le, [, 0.9, ]}], ,, RowBox[{Force, [, RowBox[{0.9, ,, RowBox[{-, 0.5}]}], ]}]}], }}]}], ]}]}], }}]

The solution is a list with two elements. The first element is a list containing the shearing force, the bending moment, the slope, and the deflection (written as pure functions). The second element is a Beam object containing the original elements plus Force and Moment elements for the forces and moments in the supports.

{{S, M, s, d}, Beam[{l, r, f}, {e}]                                                            ... ection d, and a Beam object with the original elements plus the forces and moments in the supports

The structure of a beam solution.

Drawing and Plotting Beams and Results

DrawBeam[b]                                                                                    ... the bending  stiffness, the  shearing force, the bending moment, and the slope

Drawing and plotting beams and solutions.

We can look at all relevant results.

In[33]:=

DrawAll[b1, s1]

[Graphics:HTMLFiles/BeamDocumentation_137.gif]

Out[33]=

⁃GraphicsArray⁃

Printing Results

PrintBendingStiffness[b]                     print the bending stiffness of the beam b  PrintS ... he solution s  PrintDeflection[s]                           print the deflection of the solution s

Printing results in a nicely readable form.

This is the formula for the deflection.

In[34]:=

PrintDeflection[s1]

y =  -0.004000000000000002` + 0.04000000000000002` x                                   ...                                                                                                  1

Results as Pure Functions

BendingStiffness[b]                           return the bending stiffness of the beam b  Shea ...  solution s  Deflection[s]                                 return the deflection of the solution s

Results in the form of pure functions.

Between the supports, the deflection is a cubic polynomial.

In[35]:=

Exponent[Deflection[s1][x], x]

Out[35]=

3

Some Simple Examples

We will use similar names for the beams. To avoid warnings, we turn off the spelling checker.

In[36]:=

Off[General :: "spell", General :: "spell1"]

This is a simply supported beam with a load in the middle.

In[37]:=

beam_1 = Beam[{0, 1, 1&}, {Simple[0], Simple[1], Force[1/2, 1]}] ;

In[38]:=

DrawBeam[beam_1]

[Graphics:HTMLFiles/BeamDocumentation_148.gif]

Out[38]=

⁃Graphics⁃

In[39]:=

solution_1 = SolveBeam[beam_1] ;

In[40]:=

PrintDeflection[solution_1]

y =  1            3                                                                    ...     <                           x                              <                           1

In[41]:=

DrawAll[beam_1, solution_1]

[Graphics:HTMLFiles/BeamDocumentation_154.gif]

Out[41]=

⁃GraphicsArray⁃

We might use symbolic values for the length and the force in this statically determinate beam with a fixed support.

In[42]:=

beam_2 = Beam[{0, L, 1&}, {Fixed[0], Force[L, f]}] ;

A numerical value has to be given for a drawing.

In[43]:=

DrawBeam[beam_2/.L1]

[Graphics:HTMLFiles/BeamDocumentation_158.gif]

Out[43]=

⁃Graphics⁃

The solution can be calculated with the symbolic parameters. We can ignore the warning.

In[44]:=

solution_2 = SolveBeam[beam_2] ;

Beam :: symbends : Warning: Your beam contains symbolic end points. All supports and loads are ... en the end points. You will not be able to plot the results without defining numerical end points.

The deflection can be printed with the symbolic parameters.

In[45]:=

PrintDeflection[solution_2]

y = 1/6 x^2 f (-x + 3 L) , 0 < x < L

But plotting is only possible if all parameters are numerical.

In[46]:=

DrawAll @@ ({beam_2, solution_2}/.{L1, f1})

[Graphics:HTMLFiles/BeamDocumentation_165.gif]

Out[46]=

⁃GraphicsArray⁃

We now consider a statically indeterminate system with a distributed load and a moment.

In[47]:=

beam_3 = Beam[{0, 1, 1&}, {Fixed[0], Simple[1], Moment[1/3, m], Force[{1/2, 1}, (1 - #1) &]}] ;

In[48]:=

DrawBeam[beam_3]

[Graphics:HTMLFiles/BeamDocumentation_169.gif]

Out[48]=

⁃Graphics⁃

In[49]:=

solution_3 = SolveBeam[beam_3] ;

The deflection function looks like this:

In[50]:=

PrintDeflection[solution_3]

y =   2              x  (51 - 57 x + 160 (3 + 5 x) m)                                  ...                     <                                                                         1

With a numerical value for m, we can draw and plot the results.

In[51]:=

DrawAll @@ ({beam_3, solution_3}/.m -.2)

[Graphics:HTMLFiles/BeamDocumentation_175.gif]

Out[51]=

⁃GraphicsArray⁃

The following beam contains a hinge, which makes it statically determinate.

In[52]:=

beam_4 = Beam[{0, 1, 1&}, {Fixed[0], Simple[1], Hinge[1/2], Force[1/2, f]}] ;

In[53]:=

DrawBeam[beam_4]

[Graphics:HTMLFiles/BeamDocumentation_179.gif]

Out[53]=

⁃Graphics⁃

In[54]:=

solution_4 = SolveBeam[beam_4] ;

Because there are no loads to the right of the hinge, the bending moment vanishes.

In[55]:=

PrintBendingMoment[solution_4]

M_z =  1                                                                               ...  0               ,               2               <            x               <            1

In[56]:=

DrawAll @@ ({beam_4, solution_4}/.f1)

[Graphics:HTMLFiles/BeamDocumentation_185.gif]

Out[56]=

⁃GraphicsArray⁃

Simulating a Fixed Support

We now consider a statically determinate beam with a fixed support.

In[57]:=

beam_51 = Beam[{0, 1, 1&}, {Fixed[0], Force[1, 1]}] ;

In[58]:=

DrawBeam[beam_51]

[Graphics:HTMLFiles/BeamDocumentation_189.gif]

Out[58]=

⁃Graphics⁃

In[59]:=

solution_51 = SolveBeam[beam_51] ;

In[60]:=

DrawAll[beam_51, solution_51]

[Graphics:HTMLFiles/BeamDocumentation_193.gif]

Out[60]=

⁃GraphicsArray⁃

The shearing force is constant.

In[61]:=

PrintShearingForce[solution_51]

S_y = 1 , 0 < x < 1

In a physical system, the fixed support might be realized by a sequence of simple supports.

In[62]:=

RowBox[{RowBox[{beam_52, =, RowBox[{Beam, [, RowBox[{{0, 1, 1&}, ,, RowBox[{{, RowBox[{For ... , 0.04, ]}], ,, RowBox[{Simple, [, 0.06, ]}], ,, RowBox[{Simple, [, 0.08, ]}]}], }}]}], ]}]}], ;}]

In[63]:=

DrawBeam[beam_52]

[Graphics:HTMLFiles/BeamDocumentation_199.gif]

Out[63]=

⁃Graphics⁃

In[64]:=

solution_52 = SolveBeam[beam_52] ;

In[65]:=

DrawAll[beam_52, solution_52]

[Graphics:HTMLFiles/BeamDocumentation_203.gif]

Out[65]=

⁃GraphicsArray⁃

In such a system, the forces in the supports can become much larger than one might expect from the idealization by a fixed support.

In[66]:=

PrintShearingForce[solution_52]

S_y =  0.8214285714285563`   ,                     0                     <          ...          0.08`                 <                  x                     <                  1

Simulating a Hinge by an Interval of Small Bending Stiffness

Let us look at a beam with a hinge.

In[67]:=

beam_61 = Beam[{0, 1, 1&}, {Fixed[0], Simple[1], Hinge[1/2], Force[2/5, 1]}] ;

In[68]:=

DrawBeam[beam_61]

[Graphics:HTMLFiles/BeamDocumentation_209.gif]

Out[68]=

⁃Graphics⁃

In[69]:=

solution_61 = SolveBeam[beam_61] ;

The hinge is similar to having a very small bending stiffness in a small interval.

In[70]:=

beam_62 = Beam[{0, 1, 1 - (1 - ϵ) UnitStep[#1 - 1/2 + .01] + (1 - ϵ) UnitStep[#1 - 1/2 - .01] &}, {Fixed[0], Simple[1], Force[2/5, 1]}]/.ϵ1/10^4 ;

In[71]:=

DrawBeam[beam_62]

[Graphics:HTMLFiles/BeamDocumentation_214.gif]

Out[71]=

⁃Graphics⁃

In[72]:=

PrintBendingStiffness[beam_62]

EI_z =                    1       ,       0       <    x       <    0.49`        ... <    x       <    0.51`                    1       ,       0.51`   <    x       <    1

In[73]:=

solution_62 = SolveBeam[beam_62] ;

This shows the solution of the beam with the hinge.

In[74]:=

DrawAll[beam_61, solution_61]

[Graphics:HTMLFiles/BeamDocumentation_220.gif]

Out[74]=

⁃GraphicsArray⁃

And this shows the simulation of the hinge by an interval of small bending stiffness.

In[75]:=

DrawAll[beam_62, solution_62]

[Graphics:HTMLFiles/BeamDocumentation_223.gif]

Out[75]=

⁃GraphicsArray⁃

But neither should the interval size be reduced with the same scale as the bending stiffness.

In[76]:=

DrawAll @@ NestList[SolveBeam, Beam[{0, 1, 1 - (1 - ϵ) UnitStep[#1 - 1/2 + ϵ] + (1 ... tStep[#1 - 1/2 - ϵ] &}, {Fixed[0], Simple[1], Force[2/5, 1]}]/.ϵ1/10^8, 1]

[Graphics:HTMLFiles/BeamDocumentation_226.gif]

Out[76]=

⁃GraphicsArray⁃

Nor should the bending stiffness be made too small (if there is a non-vanishing bending moment on both sides of the "hinge").

In[77]:=

DrawAll @@ NestList[SolveBeam, Beam[{0, 1, 1 - (1 - ϵ) UnitStep[#1 - 1/2 + .01] + (1 - & ...  UnitStep[#1 - 1/2 - .01] &}, {Fixed[0], Simple[1], Force[3/5, 1]}]/.ϵ1/10^8, 1]

[Graphics:HTMLFiles/BeamDocumentation_229.gif]

Out[77]=

⁃GraphicsArray⁃

The explanation of these two effects is left to the reader.


Created by Mathematica  (May 3, 2004)