MechanicsExplorers`Beam`

A User-friendly Exploration Program for the Bending of Beams

Stephan Kaufmann
Institute of Mechanics
Swiss Federal Institute of Technology, ETH Zürich
CH-8092 Zürich, Switzerland
Email: kaufmann@ifm.mavt.ethz.ch
URL: http://www.ifm.ethz.ch/~kaufmann/
© 1997 by Stephan Kaufmann
Version 1.0, March 1997

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

Copy the file BeamPalette.nb (or a link to it) into the directory <Mathematica installation directory>/Configuration/FrontEnd/Palettes.

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 multi-user systems, a personal installation can be accomplished by copying the file Beam.m to the directory <personal Mathematica directory>/Kernel and the file BeamPalette.nb to the directory <personal Mathematica directory>/Configuration/FrontEnd/Palettes, where <personal Mathematica directory> usually is ~/.Mathematica/3.0. In this case, the documentation will not be available through the Function Browser.

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.

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

The basic function of this package is SolveBeam. It calculates the shear force (Subscript[S, y]), the bending moment (Subscript[M, z]), and the deflection d (as well as its slope s) for beams with given loads (discrete forces, distributed forces, and discrete moments), supports (simple or fixed), and possibly hinges. The bending stiffness (Subscript[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, (Subscript[I, z]) the main moment of inertia about the z-axis.

The solution is calculated by integrating the following well known differential relations ((Subscript[f, z]) is the distributed force in z-direction):

((∂(Subscript[S, y])(x))/(∂x))==-(Subscript[f, z])(x)

((∂(Subscript[M, z])(x))/(∂x))==-(Subscript[S, y])(x)

(((∂^2)d(x))/(∂(x^2)))==((M(x))/(Subscript[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 (Subscript[x, 0]):

d((Subscript[x, 0]))==0

In a fixed support at (Subscript[x, 0]):

d((Subscript[x, 0]))==0

((∂d(x))/(∂x))/.x->(Subscript[x, 0])==0

In a hinge at (Subscript[x, 0]):

(Subscript[M, z])((Subscript[x, 0]))==0

Furthermore, the limits of (Subscript[S, y]) and (Subscript[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.

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:

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.

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.

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 following symbols are used to represent supports and loads of beams.

A simple support:

A fixed support:

A hinge:

A positive discrete force:

A positive distributed force:

Moments (positive and negative):

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:

Positive[meter]^=True;

Positive[newton]^=True;

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.

Needs["MechanicsExplorers`Beam`"]

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.

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 beam is automatically drawn after each modification}, {Do not Draw each Modification, SetDrawEach[False], no automatic drawing takes place}, {Input by Dialogs, SetInputDialogs[True], the input is requested by dialogs}, {Input by Evaluating Expressions, SetInputDialogs[False], 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.

SetInputDialogs[False]

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, NewWorkBeam[], set the work beam to a beam with end points 0 and 1 (and a  constant bending stiffness), without any supports or loads.}, {Remove Last Element, RemoveLastElement[], remove the support or load defined last; the removal can be done repeatedly}, {Define End Points, DefineEndPoints[], define the left and right end points}, {Define Bending Stiffness, DefineBendingStiffness[], define the bending stiffness; the bending stiffness should either be given as a pure function (e.g., 1+UnitStep[#-.5]&), or as a list containing an expression in a given variable and the variable (e.g., {1+UnitStep[x-.5],x}); discontinuities should be expressed as linear combinations of UnitStep functions}, {Add Simple Support, AddSimpleSupport[], add a simple support by giving its position}, {Add Fixed Support, AddFixedSupport[], add a fixed support by giving its position}, {Add Hinge, AddHinge[], add a hinge by giving its position}, {Add Moment, AddMoment[], add a discrete moment by entering the position and the value of the momente (positive moment vectors point into the screen)}, {Add Discrete Force, AddForce[], add a discrete force by entering the position and the value of the force (positive forces point downwards)}, {Add Distributed Force, AddDistributedForce[], add a distributed forceby entering the interval in which the force is definined and function defining the force; the function should either be a pure function (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).

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.

AddFixedSupport[0]

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

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.

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.

AddMoment[1,1]

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, DrawBeam[], draw a sketch of the work beam}, {Draw Solution, DrawSolution[], draw a sketch of the work solution, showing the deflection and all forces and moments}, {Plot Shearing Force, PlotShearingForce[], plot the shearing force}, {Plot Bending Moment, PlotBendingMoment[], plot the bending moment}, {Plot Slope, PlotSlope[], plot the slope}, {Plot Deflection, PlotDeflection[], plot the deflection}, {Plot Bending Stiffness, PlotBendingStiffness[], plot the bending stiffness}, {Plot and Draw All, DrawAll[], draw the work beam and the work 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.

DrawAll[]

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 Shearing Force, PrintShearingForce[], print the shearing force}, {Print Bending Moment, PrintBendingMoment[], print the bending moment}, {Print Slope, PrintSlope[], 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.

PrintShearingForce[]

PrintBendingMoment[]

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}, {Return Shearing Force, ShearingForce[], return the shearing force}, {Return Bending Moment, BendingMoment[], return the bending moment}, {Return Slope, Slope[], return 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).

Deflection[]

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

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

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.

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.

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], set the work beam to the Beam object b}, {GetWorkSolution[], 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.)

GetWorkBeam[]

GetWorkSolution[]

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

({{NewWorkBeam[], reset the work beam to a beam with end points 0 and 1, and with a constant bending stiffness}, {RemoveLastElement[], remove the support or load defined last; the removal can be done repeatedly}, {DefineEndPoints[l,r], define the leftend point of the work beam to be l, and the right end point to be r}, {DefineBendingStiffness[f], define the bending stiffness of the work beam; the bendings stiffness should either be given as a pure function (e.g., 1+UnitStep[#-.5]&), or as a list containing an expression in a given variable and the variable (e.g., {1+UnitStep[x-.5],x}); discontinuities should be expressed as linear combinations of UnitStep functions}, {AddSimpleSupport[p], add a simple support at position p}, {AddFixedSupport[p], add a fixed support at position p}, {AddHinge[p], add a hinge at position p}, {AddMoment[p,v], add a moment of value v at position p}, {AddForce[p,v], add a discrete force of value v at position p}, {AddForce[{l,r},f], add a distributed force in the interval [l,r], defined by the expression f; f is either a pure function (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.

RemoveLastElement[]

Instead, we add a distributed force.

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

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.

SolveBeam[]

({{DrawBeam[], draw a sketch of the work beam}, {DrawSolution[], draw a sketch of the work solution, showing the deflection and all forces and moments}, {PlotShearingForce[], plot the shearing force}, {PlotBendingMoment[], plot the bending moment}, {PlotSlope[], plot the slope}, {PlotDeflection[], plot the deflection}, {PlotBendingStiffness[], plot the bending stiffness}, {DrawAll[], draw the work beam and the work 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.

PlotDeflection[]

The plot is a little bit clearer than the sketch.

DrawSolution[]

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

({{PrintBendingStiffness[], print the bending stiffness}, {PrintShearingForce[], print the shearing force}, {PrintBendingMoment[], print the bending moment}, {PrintSlope[], print the slope}, {PrintDeflection[], print the deflection}})

Printing results in a nicely readable form.

The slope now hat the following form.

PrintSlope[]

({{BendingStiffness[], return the bending stiffness}, {ShearingForce[], return the shearing force}, {BendingMoment[], return the bending moment}, {Slope[], 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.

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

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

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.

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

({{NewBeam[], return a new Beam object (with end points 0 and 1, constant bending stiffness, without loads and supports)}, {NewBeam[b], define the variable b to be a new Beam object}, {RemoveElement[b,e], remove the element e from the beam b;b can be a Simple[…], Fixed[…], Hinge[…], Force[…], or Moment[…] object, see  Definition of Beams; the objects contain patterns}, {DefineEndPoints[b,{l,r}], the left end  point of beam b is set to l, the right end point to r}, {DefineBendingStiffness[b,f], the bending stiffness of the beam b is set to f;}, {AddSimpleSupport[b,p], add a simple support at position p}, {AddFixedSupport[b,p], add a fixed support at position p}, {AddHinge[b,p], add a hinge at position p}, {AddMoment[b,p,v], add a moment of value v  at position p (positive moment vectors point into the screen)}, {AddForce[b,p,v], add a discrete force of value v  at position p (positive force vectors point downwards)}, {AddForce[b,{l,r},f], add a distributed force in the interval [l,r]  ,  f is either a pure function (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.

NewBeam[b1]

b1

We now add two simple supports and a force.

AddSimpleSupport[b1,.1]

AddSimpleSupport[b1,.9]

AddForce[b1,.5,1]

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

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

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 Beam object, representing a beam with end points l and r,  bending stiffness b (a pure function), and any number of support and load elements e}, {Simple[p], a simple support at position p}, {Fixed[p], a fixed support at position p}, {Hinge[p], a hinge at position p}, {Moment[p,v], a moment of value v at position p}, {Force[p,v], a force of value v at position p}, {Force[{l,r},f], 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.

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

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.

s1=SolveBeam[b1]

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}], the solution of a beam problem contains the shearing force S, the bending moment M, the slope s, the deflection d, and a Beam object with the original elements plus the forces and moments in the supports}})

The structure of a beam solution.

({{DrawBeam[b], draw a sketch of the beam b}, {DrawSolution[s], draw a sketch of the solution s, showing the deflection and all forces and moments}, {PlotShearingForce[s], plot the shearing force of the solution s}, {PlotBendingMoment[s], plot the bending moment of the solution s}, {PlotSlope[s], plot the slope of the solution s}, {PlotDeflection[s], plot the deflection of the solution s}, {PlotBendingStiffness[s], plot the bending stiffness of the solution s}, {DrawAll[b,s], draw the beam b, the solution s, and plot 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.

DrawAll[b1,s1]

({{PrintBendingStiffness[b], print the bending stiffness of the beam b}, {PrintShearingForce[s], print the shearing force of the solution s}, {PrintBendingMoment[s], print the bending moment of the solution s}, {PrintSlope[s], print the slope of the 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.

PrintDeflection[s1]

({{BendingStiffness[b], return the bending stiffness of the beam b}, {ShearingForce[s], return the shearing force of the solution s}, {BendingMoment[]s, return the bending moment of the solution s}, {Slope[s], return the slope of the 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.

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

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

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

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

(Subscript[beam, 1])=Beam[{0,1,1&},{Simple[0],Simple[1],Force[(1/2),1]}];

DrawBeam[(Subscript[beam, 1])]

(Subscript[solution, 1])=SolveBeam[(Subscript[beam, 1])];

PrintDeflection[(Subscript[solution, 1])]

DrawAll[(Subscript[beam, 1]),(Subscript[solution, 1])]

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

(Subscript[beam, 2])=Beam[{0,L,1&},{Fixed[0],Force[L,f]}];

A numerical value has to be given for a drawing.

DrawBeam[(Subscript[beam, 2])/.L->1]

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

(Subscript[solution, 2])=SolveBeam[(Subscript[beam, 2])];

The deflection can be printed with the symbolic parameters.

PrintDeflection[(Subscript[solution, 2])]

But plotting is only possible if all parameters are numerical.

DrawAll@@({(Subscript[beam, 2]),(Subscript[solution, 2])}/.{L->1,f->1})

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

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

DrawBeam[(Subscript[beam, 3])]

(Subscript[solution, 3])=SolveBeam[(Subscript[beam, 3])];

The deflection function looks like this:

PrintDeflection[(Subscript[solution, 3])]

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

DrawAll@@({(Subscript[beam, 3]),(Subscript[solution, 3])}/.m->-.2)

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

(Subscript[beam, 4])=Beam[{0,1,1&},{Fixed[0],Simple[1],Hinge[(1/2)],Force[(1/2),f]}];

DrawBeam[(Subscript[beam, 4])]

(Subscript[solution, 4])=SolveBeam[(Subscript[beam, 4])];

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

PrintBendingMoment[(Subscript[solution, 4])]

DrawAll@@({(Subscript[beam, 4]),(Subscript[solution, 4])}/.f->1)

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

(Subscript[beam, 51])=Beam[{0,1,1&},{Fixed[0],Force[1,1]}];

DrawBeam[(Subscript[beam, 51])]

(Subscript[solution, 51])=SolveBeam[(Subscript[beam, 51])];

DrawAll[(Subscript[beam, 51]),(Subscript[solution, 51])]

The shearing force is constant.

PrintShearingForce[(Subscript[solution, 51])]

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

(Subscript[beam, 52])=Beam[{0,1,1&},{Force[1,1],Simple[0],Simple[0.02],Simple[0.04],Simple[0.06],Simple[0.08]}];

DrawBeam[(Subscript[beam, 52])]

(Subscript[solution, 52])=SolveBeam[(Subscript[beam, 52])];

DrawAll[(Subscript[beam, 52]),(Subscript[solution, 52])]

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

PrintShearingForce[(Subscript[solution, 52])]

Let us look at a beam with a hinge.

(Subscript[beam, 61])=Beam[{0,1,1&},{Fixed[0],Simple[1],Hinge[(1/2)],Force[(2/5),1]}];

DrawBeam[(Subscript[beam, 61])]

(Subscript[solution, 61])=SolveBeam[(Subscript[beam, 61])];

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

(Subscript[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));

DrawBeam[(Subscript[beam, 62])]

PrintBendingStiffness[(Subscript[beam, 62])]

(Subscript[solution, 62])=SolveBeam[(Subscript[beam, 62])];

This shows the solution of the beam with the hinge.

DrawAll[(Subscript[beam, 61]),(Subscript[solution, 61])]

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

DrawAll[(Subscript[beam, 62]),(Subscript[solution, 62])]

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

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

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

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]

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