Maple 2020 Questions and Posts

These are Posts and Questions associated with the product, Maple 2020

Custom Palettes and Palette Entries on windows Pro 7 
Read a tutorial from a user @les 185

https://www.mapleprimes.com/posts/207781-Custom-Palettes-And-Palette-Entries

Is this still valid this tutorial from 2015  in the current version of Maple ?
This seems to be userunfriendly.

I am learning Typesetting so I can get better Latex.

I'd like to have all derivatives generated as y'(x) and not dy/dx regardless of what the derivative variable is. (It is more clear this way).

I found I can't even give Maple a list of the variables. But must do it each time one at a time.

I have thousands of ODE's I need to typeset, (they use different variables (depending on the textbook), and not always x or t, but the set of variables is not large).

so having to check and keep changing this setting each time is awkward (but I think is doable, as I know what the independent variable is for each ode so I can call Typesetting at start of each ode processing, once I know what the variable is).   

It wil be much easier if there is a way to tell Maple to do this for all variables. May be there is a good reason why Maple does not seem to allow such an option?

Here is an example

Typesetting:-Settings(usedot=false,prime=t,typesetprime=true):
ode:=diff(y(t),t$2)+diff(y(t),t)+y(t)= 0:
Physics:-Latex(ode);

Which gives the Latex I want

But if the variable was x instead of t, I have to do this

Typesetting:-Settings(usedot=false,prime=x,typesetprime=true):
ode:=diff(y(x),x$2)+diff(y(x),x)+y(x)= 0:
Physics:-Latex(ode);

I tried doing prime=[x,t] but Maple did not like this.

Is there a way or trick to tell Maple to use typesetprime=true for any letter?  I looked at https://fr.maplesoft.com/support/help/Maple/view.aspx?path=Typesetting%2fSettings but do not see a way so far.

Maple 2020.1 with Physics 776

I am trying the new Physics:-Latex command in version 774.

Couple of isssues I found:

1) One test I have failed with this error

Error, (in anonymous procedure called from anonymous procedure called from anonymous procedure called from anonymous procedure called from Physics:-*) invalid boolean expression: NULL
 

Using the normal latex() command works OK. I hope it is not too hard to fix since this new version seems to have fixed the fraction problem in latex(). Please see

restart;
sol:=dsolve(t*(t-2)^2*diff(diff(y(t),t),t)+t*diff(y(t),t)+y(t) = 0,y(t));
latex(sol);  #OK

Physics:-Latex(sol); #error

 

2) Maple now generates Latex using maple macro, which I do not know what it is.  Comparing

restart;
ode:=t*(t-2)^2*diff(diff(y(t),t),t)+t*diff(y(t),t)+y(t) = 0;
latex(ode)

which gives 

t \left( t-2 \right) ^{2}{\frac {{\rm d}^{2}}{{\rm d}{t}^{2}}}y
 \left( t \right) +t{\frac {\rm d}{{\rm d}t}}y \left( t \right) +y
 \left( t \right) =0

compare to

Physics:-Latex(ode)

which gives

t \left(t -2\right)^{2} \Mapleoverset{\ldots}{y}\left(t \right)
      +t \Mapleoverset{.}{y}\left(t \right)+y \left(t \right) = 0

What is \Mapleoverset ? googling around, these look like part of internal Maple style sheet for Latex?

Does this mean when using the new Physics Latex command, now one needs to use the package maplestd2e.sty?  With the normal latex() command, this was not needed. 

Just trying to understand the new setup.

Hello

I am trying to reproduce a simple result from Linear Control Theory using Laplace Transform.  Here are the steps:

assume(omega>0);assume(zeta>0 and zeta<1);
tf:=omega^2/(s^2+2*zeta*omega*s+omega^2);
y:=tf*1/s;
yt:=inttrans:-invlaplace(y,s,t);
dyt:=diff(yt,t);

So far, so good.  Now I need to find the values of t (time) such that the dyt=0.  

 

solve(dyt=0,t);

but Maple returns only the trivial solution, that is, zero.   How can I find the next one (Tp - peak time = Pi/(omega*sqrt(1-zetaˆ2)))?  

 

Many thanks

 

We have just released an update to Maple, Maple 2020.1.1. This update includes the following:

  • Correction to a problem that occurred when printing or exporting documents to PDF. If the document included a 3-D plot, nearby text was sometimes missing from the printed/exported document.
  • Correction to an issue that prevented users from installing between-release updates to the Physics package

This update is available through Tools>Check for Updates in Maple, and is also available from our website on the Maple 2020.1.1 download page. If you are a MapleSim user, you can obtain this update from the corresponding MapleSim menu or MapleSim 2020.1.1  download page.

In particular, please note that this update fixes the problems reported on MaplePrimes in Maple 2020.1 issue with print to PDF  and installing the Maplesoft Physics updates. As always, we appreciate the feedback.

I am a new user of Maple 2020. I have found that when I create a 3D plot, the point probe does not return the coordinates of the point that I click on.  I would appreciate any help in using the point probe in a 3d plot. Thanks.

 

Dear All,

I want to apply the ‘simplify’ command, in parallel, for the simplification of some parameters. Both Grid:-Map and Grid:-Run commands are tested. There is no error in both, whereas no simplification is implemented. It seems that the ‘simplify’ command correctly works on only ‘Master’ node, namely anywhere we are typing.

Can anyone help me to simplify in parallel. I examined two following codes.

1)

with (Grid);

for i from 1 to nops(dummy_UU1) do

freenode:=WaitForFirst():

Run(freenode,simplify,[dummy_UU1[i]],assignto='dummy_UU2'[i]):

end do:

Wait();

2)

dummy_UU2:=Map[tasksize=1](simplify,[seq(dummy_UU1[i],i=1..nops(dummy_UU1))]):

 

 

The following code is correctly executed and resulted in the simplification of dummy_UU1 components in serial.

for i from 1 to nops(dummy_UU1) do

dummy_UU2[i]:=simplify(dummy_UU1[i]):

end do:

 

The strandbeest is a walking machine developed by Theo Jansen. Its cleverly designed legs consist of single-degree-of-freedom linkage mechanisms, actuated by the turning of a wind-powered crankshaft.

His working models are generally large - something of the order of the size of a bus. Look for videos on YouTube.  Commercially made small toy models are also available.  This one sells for under $10 and it's fun to assemble and works quite well. Beware that the kit consists of over 100 tiny pieces - so assembling it is not for the impatient type.

Here is a Maple worksheet that produces an animated strandbeest. Link lengths are taken from Theo Jansen's video (go to his site above and click on Explains) where he explains that he calculated the optimal link lengths by applying a genetic algorithm.

Here is a Maple animation of a single leg.  The yellow disk represents the crankshaft.

And here are two legs working in tandem:

Here is the complete beest, running on six legs. The crankshaft turns at a constant angular velocity.

The toy model noted above runs on twelve legs for greater stability.

Download the worksheet: strandbeest.mw

 

This may be of interest to anyone curious about why the effective area of an isotropic antenna is λ^2/4π.


 

Friis Transmission Equation

NULL

Initialise

   

NULL``

The Hertzian Dipole antenna

 

The Hertzian Dipole is a conceptual antenna that carries a constant current along its length.

 

 

By laying a number of these small current elements end to end, it is possible to model a physical antenna (such as a half-wave dipole for example).  But since we are only interested in obtaining an expression for the effective area of an Isotropic Antenna (in order to derive The Friis Transmission Equation) the Hertzian Dipole will be sufficient for our needs.``

NULL

``

Maxwell's Equations

 

Since the purpose of a radio antenna is to either launch or to receive radio waves, we know that both the antenna, and the space surrounding the antenna, must satisfy Maxwell's Equations. We define Maxwell's Equations in terms of vector functions using spherical coordinates:

 

Maxwell–Faraday equation:

Maxwell_1 := Curl(E_(r, theta, `&varphi;`, t)) = -mu*(diff(H_(r, theta, `&varphi;`, t), t))

Physics:-Vectors:-Curl(E_(r, theta, varphi, t)) = -mu*(diff(H_(r, theta, varphi, t), t))

(3.1)

Ampère's circuital law (with Maxwell's addition):

Maxwell_2 := Curl(H_(r, theta, `&varphi;`, t)) = J_(r, theta, `&varphi;`, t)+epsilon*(diff(E_(r, theta, `&varphi;`, t), t))

Physics:-Vectors:-Curl(H_(r, theta, varphi, t)) = J_(r, theta, varphi, t)+varepsilon*(diff(E_(r, theta, varphi, t), t))

(3.2)

Gauss' Law:

Maxwell_3 := Divergence(E_(r, theta, `&varphi;`, t)) = rho/epsilon

Physics:-Vectors:-Divergence(E_(r, theta, varphi, t)) = rho/varepsilon

(3.3)

Gauss' Law for Magnetism:

Maxwell_4 := Divergence(H_(r, theta, `&varphi;`, t)) = 0

Physics:-Vectors:-Divergence(H_(r, theta, varphi, t)) = 0

(3.4)

Where:

        E is the electric field strength [Volts/m]

        H is the magnetic field strength [Amperes/m]

        J is the current density (current per unit area) [Amperes/m2]

        ρ is the charge density (charge per unit volume) [Coulombs/m3]

        ε is Electric Permittivity

        μ is Magnetic Permeability

NULL

Helmholtz decomposition

 

The Helmholtz Decomposition Theorem states that providing a vector field, (F) satisfies appropriate smoothness and decay conditions, it can be decomposed as the sum of components derived from a scalar field, (Φ) called the "scalar potential", and a vector field (A) called the "vector potential".

 

F = -VΦ + V×A

 

And that the scalar (Φ) and vector (A) potentials can be calculated from the field (F) as follows (image from https://en.wikipedia.org/wiki/Helmholtz_decomposition):

 

Where:

        r is the vector from the origin to the observation point (P) at which we wish to know the scalar or vector potential.

        r' is the vector from the origin to the source of the scalar or vector potential (i.e. a point on the Hertzian Dipole antenna).

        V'·F(r')  is the Divergence of the vector field (F) at source position r'.

        V'×F(r')  is the Curl of the vector field (F) at source position r'.

 

 

Calculating the Scalar Potential for the magnetic Field, H

 

We know that the Divergence of the magnetic field (H) is zero:

Maxwell_4

Physics:-Vectors:-Divergence(H_(r, theta, varphi, t)) = 0

(4.1.1)

And so the magnetic field (H) must have a scalar vector potential of zero:

`&Phi;__H` := 0

0

(4.1.2)

 

Calculating the Vector Potential for the magnetic Field, H

 

We know that the Curl of the magnetic field (H) is equal to the sum of current density (J) and the rate of change of the electric filled (E):

Maxwell_2

Physics:-Vectors:-Curl(H_(r, theta, varphi, t)) = J_(r, theta, varphi, t)+varepsilon*(diff(E_(r, theta, varphi, t), t))

(4.2.1)

Since the Hertzian Dipole is a conductor, we need only concern ourselves with the current density (J) when calculating the vector potential (A). Integrating current density (J) over the volume of the antenna, is equivalent to integrating current along the length of the antenna (L).

 

We know that Maxwell's Equations can be solved for single frequency (monochromatic) fields, so we will excite our antenna with a single frequency current:

"`I__antenna`(t):=`I__0`*(e)^(j*omega*t);"

proc (t) options operator, arrow, function_assign; Physics:-`*`(I__0, exp(Physics:-`*`(I, omega, t))) end proc

(4.2.2)

We can simplify the integral for the vector potential (A) by recognising that:

 

1. 

Our observation point (P) will be a long way from the antenna and so (r) will be very large.

2. 

The length of the antenna (L) will be very small and so (r') will be very small.

 

Since |r|>>|r'|, we can substitute |r-r'| with r.

 

Because we have decided that the observation point at r will be a long way from the antenna, we must allow for the fact that the observed antenna current will be delayed.  The delay will be equal to the distance from the antenna to the observation point |r-r'| (which we have simplified to r), divided by the speed of light (c).  The time delay will therefore be approximately equal to r/c and so the observed antenna current becomes:

"`I__observed`(t):=`I__0`*(e)^(j*omega*(t-r/(c)));"

proc (t) options operator, arrow, function_assign; Physics:-`*`(I__0, exp(Physics:-`*`(I, omega, Physics:-Vectors:-`+`(t, -Physics:-`*`(r, Physics:-`^`(c, -1)))))) end proc

(4.2.3)

 

Since the length, L of the antenna will be very small, we can assume that the current is in phase at all points along its length.  Working in the Cartesian coordinate system, the final integral for the vector potential for the magnetic field is therefore:

A__H_ := (int(I__0*exp(I*omega*(t-r/c))*_k/r, z = -(1/2)*L .. (1/2)*L))/(4*Pi)

(1/4)*I__0*exp(I*omega*(t-r/c))*_k*L/(Pi*r)

(4.2.4)

 

We will now convert to the spherical coordinate system, which is more convenient when working with radio antenna radiation patterns:

The radial component of the observed current (and therefore vector potential), will be at a maximum when the observer is on the z-axis (that is when θ=0 or θ=π) and will be zero when the observer is in the x-y-plane:

A__Hr := (A__H_._k)*cos(theta)

(1/4)*I__0*exp(I*omega*t-I*omega*r/c)*L*cos(theta)/(Pi*r)

(4.2.5)

The angular component of the observed current (and therefore vector potential), in the θ direction will be zero when the observer is on the z-axis (that is when θ=0 or θ=π) and will be at a maximum when the observer is in the x-y-plane:

`A__H&theta;` := -(A__H_._k)*sin(theta)

-(1/4)*I__0*exp(I*omega*t-I*omega*r/c)*L*sin(theta)/(Pi*r)

(4.2.6)

Since the observed current (and therefore vector potential) flows along the z-axis, there will be no variation in the ϕ direction.  That is to say, that varying ϕ will have no impact on the observed vector potential.

`A__H&varphi;` := 0

0

(4.2.7)

And so the vector potential for the magnetic field (H) expressed using spherical coordinate system is:

A__H_ := A__Hr*_r+_theta*`A__H&theta;`+`A__H&varphi;`*`_&varphi;`

(1/4)*I__0*exp(I*omega*t-I*omega*r/c)*L*cos(theta)*_r/(Pi*r)-(1/4)*I__0*exp(I*omega*t-I*omega*r/c)*L*sin(theta)*_theta/(Pi*r)

(4.2.8)

NULLNULL

Calculating the Magnetic Field components

 

The Helmholtz Decomposition Theorem states that providing a vector field (F) satisfies appropriate smoothness and decay conditions, it can be decomposed as the sum of components derived from a scalar field (Φ) called "scalar potential", and a vector field (A) called the vector potential.

 

F = -VΦ + V×A

NULL

And so the magnetic field, H will be:

NULL

H_ = -(Gradient(`&Phi;__H`))+Curl(A__H_)

H_ = ((1/4)*I)*I__0*L*exp(I*omega*t-I*omega*r/c)*sin(theta)*omega*_phi/(c*Pi*r)+(1/4)*I__0*L*exp(I*omega*t-I*omega*r/c)*sin(theta)*_phi/(Pi*r^2)

(4.3.1)

We see that the magnetic field comprises two components, one is inversely proportional to the distance from the antenna (r) and the other falls off with r2.  Since we are interested in the far-field radiation pattern for the antenna, we can ignore the r2 component and so the expression for the magnetic field reduces to:

H_ := I*omega*I__0*L*exp(I*omega*(t-r/c))*sin(theta)*_phi/(4*Pi*c*r)

((1/4)*I)*omega*I__0*L*exp(I*omega*(t-r/c))*sin(theta)*_phi/(Pi*c*r)

(4.3.2)

We can further simplify by substituting ω/c for 2π/λ:``

H_ := (I*2)*Pi*L*I__0*exp(I*omega*t-(I*2)*Pi*r/lambda)*sin(theta)*_phi/(4*Pi*lambda*r)

((1/2)*I)*L*I__0*exp(I*omega*t-(2*I)*Pi*r/lambda)*sin(theta)*_phi/(lambda*r)

(4.3.3)

````

````

 

Calculating the Poynting Vector

 

We know that the magnitude of the Poynting Vector (S) can be calculated as the cross product of the electric field vector (E) and the magnetic field vector (H) :

        S = -E x H which is analogous to a resistive circuit where power is the product of voltage and current: P=V*I.

We also know that the impedance of free space (Z) can be calculated as the ratio of the electric field (E) and magnetic field (H) vectors: Z = E /H = "sqrt((mu)/(`&epsilon;`))."

This is analogous to a resistive circuit where resistance is the ratio of voltage and current: R=V/I.

 

This provides two more methods for calculating the Poynting Vector (S):

        S = -E·E/Z which is analogous to a resistive circuit where power, P=V2/R, and:

        S = -H·H*Z which is analogous to a resistive circuit where power, P=I2R.

 

Since we have obtained an expression for the magnetic field vector (H), we can derive an expression for the Poynting Vector (S):

S_ = -(H_.H_)*Z*_r

S_ = (1/4)*L^2*I__0^2*(exp(I*omega*t-(2*I)*Pi*r/lambda))^2*sin(theta)^2*Z*_r/(lambda^2*r^2)

(5.1)

We can separate out the time variable part to yield:

S_ := S__0*(exp(I*omega*t-(I*2)*Pi*r/lambda))^2*_r

S__0*(exp(I*omega*t-(2*I)*Pi*r/lambda))^2*_r

(5.2)

Where:

S__0 := L^2*I__0^2*sin(theta)^2*Z/(4*lambda^2*r^2)

(1/4)*L^2*I__0^2*sin(theta)^2*Z/(lambda^2*r^2)

(5.3)

And we can visualise this radiation pattern using Maple's plotting tools:

AntennaAxis := arrow(`<,>`(0, 0, -1), `<,>`(0, 0, 1), difference, color = "LightSteelBlue")``

AntennaPattern := plot3d(sin(theta)^2, phi = 0 .. 2*Pi, theta = 0 .. Pi, coords = spherical, scaling = constrained, size = [800, 800], labels = [x, y, z], title = ["The Electromagnetic radiation pattern of a Hertzian Dipole\n\nThe blue arrow represents the axis of the antenna", font = [Times, bold, 20]])
``

display(AntennaAxis, AntennaPattern, scaling = constrained, axes = frame)

 

So the Hertzian Dipole produces a electromagnetic radiation pattern with a pleasing doughnut shape :-)``

NULL``

Calculating Antenna Gain

 

We can calculate the total power radiated by the Hertzian Dipole by integrating the power flux density over all solid angles dΩ=sin(θ) dθ dφ.  Since we have expressed power flux density in terms of watts per square meter, we multiply the solid angle by r2 to convert the solid angle expressed in steradians into an area expressed in m2.

NULL

P__tx := int(int(S__0*r^2*sin(theta), theta = 0 .. Pi), phi = 0 .. 2*Pi)

(2/3)*L^2*I__0^2*Z*Pi/lambda^2

(6.1)

We can now use this power to calculate the power flux density that would be produced by an isotropic antenna by dividing the total transmitted power by the area of a sphere with radius r:

S__Isotropic := P__tx/(4*Pi*r^2)

(1/6)*L^2*I__0^2*Z/(lambda^2*r^2)

(6.2)

``

``

The Gain of the Hertzian Dipole is defined as the ratio between the maximum power flux density produced by the Hertzian Dipole and the maximum power flux density produced by the isotropic antenna:

G__HertzianDipole := S__0/S__Isotropic

(3/2)*sin(theta)^2

(6.3)

AntennaAxis := arrow(`<,>`(-1, 0), `<,>`(1, 0), difference, color = "LightSteelBlue")

Gain := polarplot(G__HertzianDipole, theta = -Pi .. Pi, axis[radial] = [color = "Blue"], angularorigin = top, angulardirection = clockwise, size = [800, 800], labels = [x, z], title = ["The Gain of a Hertzian Dipole over an isotropic antenna  \n\nThe blue arrow represents the axis of the antenna", font = [Times, bold, 20]])

display(AntennaAxis, Gain, scaling = constrained, axes = frame)

 

````

````

Calculating Radiation Resistance

 

The input impedance of the Hertzian Dipole will have both a real and a reactive part.  The reactive part will be associated with energy storage in the near field and will not contribute to the Poynting Vector in the far-field.  For an ideal antenna (with no resistive power loss) the real part will be responsible for the radiated power:

P__tx = I__0^2*R__rad

(2/3)*L^2*I__0^2*Z*Pi/lambda^2 = I__0^2*R__rad

(7.1)

R__rad := solve((2/3)*L^2*I__0^2*Z*Pi/lambda^2 = I__0^2*R__rad, R__rad)

(2/3)*L^2*Z*Pi/lambda^2

(7.2)

````

``

Calculating the power received by a Hertzian Dipole

 

If an electromagnetic field (E) is incident on the Hertzian Dipole antenna, it will generate an Electro-Motive Force (EMF) at the antenna terminals.  The EMF will be at a maximum when the transmitter is on the x-y-plane (that is when θ=π/2) and will be zero when the transmitter is on the z-axis.

 

For and incident E-field:

E := E__0*exp(I*omega*t)

E__0*exp(I*omega*t)

(8.1)

The z-axis component will be:

E__z := E*sin(theta)

E__0*exp(I*omega*t)*sin(theta)

(8.2)

The z-axis component of the E-field will create an EMF at the antenna terminals that will draw charge out of the receiver to each tip of the antenna. We can calculate the work done per unit charge by integrating the z-axis component of (E) over the length of the antenna (L):

V__emf := int(E__z, z = -(1/2)*L .. (1/2)*L)

E__0*exp(I*omega*t)*sin(theta)*L

(8.3)

In order to extract the maximum possible power from the antenna, we will form a conjugate match between the impedance of the antenna and the load.  This means that the load resistance must be the same as the radiation resistance of the antenna.  The voltage developed across the load resistance will therefore be half of the open circuit EMF:

V__pd := (1/2)*V__emf

(1/2)*E__0*exp(I*omega*t)*sin(theta)*L

(8.4)

And so the power delivered to the load will be:

P__rx := V__pd^2/R__rad

(3/8)*E__0^2*(exp(I*omega*t))^2*sin(theta)^2*lambda^2/(Pi*Z)

(8.5)

NULL

``

Calculating the Effective area of an Isotropic Antenna

 

We can also calculate the power received by the Hertzian Dipole by multiplying the power flux density arriving at the antenna with the effective area of an isotropic antenna and the gain of the Hertzian Dipole relative to an isotropic antenna:

P__rx = G__HertzianDipole*A__Isotropic*S__rx

(3/8)*E__0^2*(exp(I*omega*t))^2*sin(theta)^2*lambda^2/(Pi*Z) = (3/2)*sin(theta)^2*A__Isotropic*S__rx

(9.1)

We can express the incident power flux density in terms of electric field strength and wave impedance:

subs(S__rx = E^2/Z, (3/8)*E__0^2*(exp(I*omega*t))^2*sin(theta)^2*lambda^2/(Pi*Z) = (3/2)*sin(theta)^2*A__Isotropic*S__rx)

(3/8)*E__0^2*(exp(I*omega*t))^2*sin(theta)^2*lambda^2/(Pi*Z) = (3/2)*sin(theta)^2*A__Isotropic*E__0^2*(exp(I*omega*t))^2/Z

(9.2)

Rearranging, we obtain an expression for the effective area of the isotropic antenna:

A__Isotropic := solve((3/8)*E__0^2*(exp(I*omega*t))^2*sin(theta)^2*lambda^2/(Pi*Z) = (3/2)*sin(theta)^2*A__Isotropic*E__0^2*(exp(I*omega*t))^2/Z, A__Isotropic)

(1/4)*lambda^2/Pi

(9.3)

NULL

``

The Friis Transmission Equation

 

P__tx := 'P__tx'

We can calculate the power flux density that would be produced by an isotropic antenna at a distance r from the antenna by dividing the total transmitted power Ptx by the area of a sphere with radius r:

P__tx/(4*Pi*r^2)

(1/4)*P__tx/(Pi*r^2)

(10.1)

And so the power flux density that would be produced by an antenna with gain Gtx is:

S__tx := (1/4)*G__tx*P__tx/(Pi*r^2)

(1/4)*G__tx*P__tx/(Pi*r^2)

(10.2)

We can calculate the power received by an isotropic antenna by multiplying the power flux density incident onto the antenna with the effective area of an isotropic antenna:

S__tx*A__Isotropic

(1/16)*G__tx*P__tx*lambda^2/(Pi^2*r^2)

(10.3)

And so the power that would be received by an antenna with gain Grx is:

P__rx := (1/16)*G__rx*G__tx*P__tx*lambda^2/(Pi^2*r^2)

(1/16)*G__rx*G__tx*P__tx*lambda^2/(Pi^2*r^2)

(10.4)

The free space path loss is defined as the ratio between the received power and the transmitted power:

P__rx/P__tx

(1/16)*G__rx*G__tx*lambda^2/(Pi^2*r^2)

(10.5)

And so:

PathLoss := G__tx*G__rx*(lambda/(4*Pi*r))^2

(1/16)*G__rx*G__tx*lambda^2/(Pi^2*r^2)

(10.6)

````

````

NULL


 

Download Friis_Transmission_Equation.mw

Question about deflection and vibration of beams occur with some regularity in this forum.  Search for "beam" to see several pages of hits.

In this post I present a general approach to calculating the vibrational modes of a beam that applies to both single-span and multi-span beams.  The code is not perfectly polished, but it is sufficiently documented to enable the interested user to modify/extend it as needed.

Vibrational modes of multi-span Euler-Bernoulli beams

through Krylov-Dunction functions

Rouben Rostamian
2020-07-19

restart;

Note:  Maple defines the imaginary unit I = sqrt(-1). We want to use the
symbol I as the beam's cross-sectional moment of inertia.
Therefore we redefine the imaginary unit (for which we have no

use) as II and free up the symbol I for our use.

interface(imaginaryunit=II):

with(LinearAlgebra):

 

The Euler-Bernoulli beam equation
"rho*A*((&PartialD;)^2u)/((&PartialD;)^( )t^2)+E*I*((&PartialD;)^(4)u)/((&PartialD;)^( )x^(4))=0".

 

We wish to determine the natural modes of vibration of

a possibly multi-span Euler-Bernoulli beam.


Separate the variables by setting u(x, t) = X(x)*T(t).   We get
-
"(rho*A)/(E*I)*(T ' ')/(T)=(X^((4)))/(X)=mu^(4)  "
whence
"T ' ' +(E*I)/(rho*A)*mu^(4)*T =0,           X^((4))-mu^(4)*X=0".

Let omega = sqrt(I*E/(rho*A))*mu^2.  Then

T(t) = C__1*cos(omega*t)+C__2*sin(omega*t)

 and
"X(x)=`c__1`*cosh(mu*x)+`c__2`*sinh(mu*x)+`c__3`*sin(mu*x)+`c__4`*cos(mu*x)."

 

The idea behind the Krylov-Duncan technique is to express X(x) 

in terms an alternative (and equivalent) set of basis
functions K__1 through K__4,, as
X(x) = a__1*K__1(mu*x)+a__2*K__2(mu*x)+a__3*K__3(mu*x)+a__4*K__4(mu*x),

where the functions K__1 through K__4 are defined in the next section.

In some literature the symbols S, T, U, V, are used for these

functions but I find it more sensible to use the indexed function

notation.

The Krylov-Duncan approach is particularly effective in formulating
and finding a multi-span beam's natural modes of vibration.

 

 

The Krylov-Duncan functions

 

The K[i](x) defined by this proc evaluates to the ith

Krylov-Duncan function.

 

Normally the index i will be in the set{1, 2, 3, 4}, however the proc is

set up to accept any integer index (positive or negative).  The proc evaluates

the index modulo 4 to bring the index into the set {1, 2, 3, 4}.   For

instance, K[5](x) and K[-3](x)i are equivalent to K[1](x) .

K := proc(x)
        local n := op(procname);

        if not type(n, integer) then
                return 'procname'(args);
        else
                n := 1 + modp(n-1,4);  # reduce n modulo 4
        end if;

        if n=1 then
                (cosh(x) + cos(x))/2;
        elif n=2 then
                (sinh(x) + sin(x))/2;
        elif n=3 then
                 (cosh(x) - cos(x))/2;
        elif n=4 then
                (sinh(x) - sin(x))/2;
        else
                error "shouldn't be here!";
        end if;

end proc:

Here are the Krylov-Duncan basis functions:

seq(print(cat(`K__`,i)(x) = K[i](x)), i=1..4);

K__1(x) = (1/2)*cosh(x)+(1/2)*cos(x)

K__2(x) = (1/2)*sinh(x)+(1/2)*sin(x)

K__3(x) = (1/2)*cosh(x)-(1/2)*cos(x)

K__4(x) = (1/2)*sinh(x)-(1/2)*sin(x)

and here is what they look like.  All grow exponentially for large x
but are significantly different near the origin.

plot([K[i](x) $i=1..4], x=-Pi..Pi,
        color=["red","Green","blue","cyan"],
        thickness=2,
        legend=['K[1](x)', 'K[2](x)', 'K[3](x)', 'K[4](x)']);

The cyclic property of the derivatives: 
We have diff(K__i(x), x) = `K__i-1`.  Let's verify that:

diff(K[i](x),x) - K[i-1](x) $i=1..4;

0, 0, 0, 0

The fourth derivative of each K__i  function equals itself. This is a consequence of the cyclic property:

diff(K[i](x), x$4) - K[i](x) $ i=1..4;

0, 0, 0, 0

The essential property of the Krylov-Duncan basis function is that their

zeroth through third derivatives at x = 0 form a basis for R^4:

seq((D@@n)(K[1])(0), n=0..3);
seq((D@@n)(K[2])(0), n=0..3);
seq((D@@n)(K[3])(0), n=0..3);
seq((D@@n)(K[4])(0), n=0..3);

1, 0, 0, 0

0, 1, 0, 0

0, 0, 1, 0

0, 0, 0, 1

As noted earlier, in the case of a single-span beam, the modal  shapes

are expressed as
X(x) = a__1*K__1(mu*x)+a__2*K__2(mu*x)+a__3*K__3(mu*x)+a__4*K__4(mu*x).

Then, due to the cyclic property of the derivatives of the Krylov-Duncan

functions, we see that:
"X '(x) = mu*(`a__1`*`K__4`(mu*x)+`a__2`*`K__1`(mu*x)+`a__3`*`K__2`(mu*x)+`a__4`*`K__3`(mu*x))".
X*('`&InvisibleTimes;`')(x) = mu^2*(a__1*K__3(mu*x)+a__2*K__4(mu*x)+a__3*K__1(mu*x)+a__4*K__2(mu*x)).
"X ' ' '(x) = mu^(3)*(`a__1`*`K__2`(mu*x)+`a__2`*`K__3`(mu*x)+`a__3`*`K__4`(mu*x)+`a__4`*`K__1`(mu*x))".
Let us note, in particular, that
X(0) = a__1,
"X '(0)=mu*`a__2`",
X*('`&InvisibleTimes;`')(0) = mu^2*a__3,
"X ' ' '(0)=mu^(3)*`a__4`".

 

A general approach for solving multi-span beams

 

In a multi-span beam, we write X__i(x) for the deflection of the ith span, where

0 < x and x < L__i and where L__i is the span's length.  The x coordinate indicates the

location within the span, with x = 0 corresponding to the span's left endpoint.

Thus, each span has its own x coordinate system.

 
We assume that the interface of the two adjoining spans is supported on springs

which (a) resist transverse displacement proportional to the displacement (constant of

proportionality of k__d  (d for displacement), and (b) resist rotation proportional to the
slope (constant of proportionality of k__t  (t for torsion or twist). The spans are numbered

from left to right. The interface conditions between spans i and i+1 are

 

1. 

The displacements at the interface match:
X__i(L__i) = `X__i+1`(0).

2. 

The slopes at the interface match
X*`'i`(L__i) = X*`'i+1`(0).

3. 

The difference of the moments just to the left and just to the right of the
support is due to the torque exerted by the torsional spring:
"E*I*(X ' `'i+1`(0)-X ' `'i `(`L__i`))=-`k__t` * X `'i+1`(0),"

4. 

The difference of the shear forces just to the left and just to the right of the
support is due to the force exerted by the linear spring:

"E*I*(X ' ' `'i+1`(0)-X ' ' '(`L__i`))= -`k__d` * `X__i+1`(0).  "

The special case of a pinned support corresponds to k__t = 0 and k__d = infinity.
In that case, condition 3 above implies that X*'`'i+1`(0) = X'*`'i`(L__i),
and condition 4 implies that `X__i+1`(0) = 0.


Let us write the displacements X__i and `X__i+1` in terms of the Krylov-Duncan

functions as:

 

"`X__i`(x)=`a__i,1`*`K__1`(mu*x)+`a__i,2`*`K__2`(mu*x)+`a__i,3`*`K__3`(mu*x)+`a__i,4`*`K__4`(mu*x),  "
"`X__i+1`(x)=`a__i+1,1`*`K__1`(mu*x)+`a__I+1,2`*`K__2`(mu*x)+`a__i+1,3`*`K__3`(mu*x)+`a__i+1,4`*`K__4`(mu*x)."


Then applying the cyclic properties of the Krylov-Duncan functions described

earlier, the four interface conditions translate to the following system of four
equations involving the eight coefficients `a__i,1`, `a__i,2`, () .. (), `a__i+13`, `a__i+1,4`.

"`a__i,1`*`K__1`(mu*`L__i`)+ `a__i,2`*`K__2`(mu*`L__i`)+`a__i,3`*`K__3`(mu*`L__i`)+`a__i,4`*`K__4`(mu*`L__i`)=`a__i+1,1`,"
mu*(`a__i,1`*K__4(mu*L__i)+`a__i,2`*K__1(mu*L__i)+`a__i,3`*K__2(mu*L__i)+`a__i,4`*K__3(mu*L__i)) = mu*`a__i+1,2`,
mu^2*(`a__i,1`*K__3(mu*L__i)+`a__i,2`*K__4(mu*L__i)+`a__i,3`*K__1(mu*L__i)+`a__i,4`*K__2(mu*L__i)-`a__i+1,3`) = -k__t*mu*`a__i+1,2`/(I*E)
mu^3*(`a__i,1`*K__2(mu*L__i)+`a__i,2`*K__3(mu*L__i)+`a__i,3`*K__4(mu*L__i)+`a__i,4`*K__1(mu*L__i)-`a__i+1,4`) = -k__d*`a__i+1,1`/(I*E)

which we write as a matrix equation
(Matrix(4, 8, {(1, 1) = K__1(mu*L__i), (1, 2) = K__2(mu*L__i), (1, 3) = K__3(mu*L__i), (1, 4) = K__4(mu*L__i), (1, 5) = -1, (1, 6) = 0, (1, 7) = 0, (1, 8) = 0, (2, 1) = K__4(mu*L__i), (2, 2) = K__1(mu*L__i), (2, 3) = K__2(mu*L__i), (2, 4) = K__3(mu*L__i), (2, 5) = 0, (2, 6) = -1, (2, 7) = 0, (2, 8) = 0, (3, 1) = K__3(mu*L__i), (3, 2) = K__4(mu*L__i), (3, 3) = K__1(mu*L__i), (3, 4) = K__2(mu*L__i), (3, 5) = 0, (3, 6) = -I*k__t/(mu*E), (3, 7) = -1, (3, 8) = 0, (4, 1) = K__2(mu*L__i), (4, 2) = K__3(mu*L__i), (4, 3) = K__4(mu*L__i), (4, 4) = K__1(mu*L__i), (4, 5) = -I*k__d/(mu^3*E), (4, 6) = 0, (4, 7) = 0, (4, 8) = -1}))*(Vector(8, {(1) = `a__i,1`, (2) = `a__i,2`, (3) = `a__i,3`, (4) = `a__i,4`, (5) = `a__i+1,1`, (6) = `a__i+1,2`, (7) = `a__i+1,3`, (8) = `a__i+1,4`})) = (Vector(8, {(1) = 0, (2) = 0, (3) = 0, (4) = 0, (5) = 0, (6) = 0, (7) = 0, (8) = 0})).

That 4*8 coefficient matrix plays a central role in solving

for modal shapes of multi-span beams.  Let's call it M__interface.

Note that the value of I*E enters that matrix only in combinations with
k__d and k__t.  Therefore we introduce the new symbols

K__d = k__d/(I*E),    K__t = k__t/(I*E).

 

The following proc generates the matrix `#msub(mi("M"),mi("interface"))`.  The parameters K__d and K__t 

are optional and are assigned the default values of infinity and zero, which

corresponds to a pinned support.

 

The % sign in front of each Krylov function makes the function inert, that is, it
prevents it from expanding into trig functions.  This is so that we can

see, visually, what our expressions look like in terms of the K functions.  To

force the evaluation of those inert function, we will apply Maple's value function,

as seen in the subsequent demos.

M_interface := proc(mu, L, {Kd:=infinity, Kt:=0})
        local row1, row2, row3, row4;
        row1 := %K[1](mu*L), %K[2](mu*L), %K[3](mu*L), %K[4](mu*L), -1,  0, 0, 0;
        row2 := %K[4](mu*L), %K[1](mu*L), %K[2](mu*L), %K[3](mu*L),  0, -1, 0, 0;
        row3 := %K[3](mu*L), %K[4](mu*L), %K[1](mu*L), %K[2](mu*L),  0, Kt/mu, -1, 0;
        if Kd = infinity then
                row4 := 0, 0, 0, 0, 1, 0, 0, 0 ;
        else
                row4 := %K[2](mu*L), %K[3](mu*L), %K[4](mu*L), %K[1](mu*L), Kd/mu^3, 0, 0, -1;
        end if:
                return < <row1> | <row2> | <row3> | <row4> >^+;
end proc:

Here is the interface matrix for a pinned support:

M_interface(mu, L);

Matrix(4, 8, {(1, 1) = %K[1](L*mu), (1, 2) = %K[2](L*mu), (1, 3) = %K[3](L*mu), (1, 4) = %K[4](L*mu), (1, 5) = -1, (1, 6) = 0, (1, 7) = 0, (1, 8) = 0, (2, 1) = %K[4](L*mu), (2, 2) = %K[1](L*mu), (2, 3) = %K[2](L*mu), (2, 4) = %K[3](L*mu), (2, 5) = 0, (2, 6) = -1, (2, 7) = 0, (2, 8) = 0, (3, 1) = %K[3](L*mu), (3, 2) = %K[4](L*mu), (3, 3) = %K[1](L*mu), (3, 4) = %K[2](L*mu), (3, 5) = 0, (3, 6) = 0, (3, 7) = -1, (3, 8) = 0, (4, 1) = 0, (4, 2) = 0, (4, 3) = 0, (4, 4) = 0, (4, 5) = 1, (4, 6) = 0, (4, 7) = 0, (4, 8) = 0})

And here is the interface matrix for a general springy support:

M_interface(mu, L, 'Kd'=a, 'Kt'=b);

Matrix(4, 8, {(1, 1) = %K[1](L*mu), (1, 2) = %K[2](L*mu), (1, 3) = %K[3](L*mu), (1, 4) = %K[4](L*mu), (1, 5) = -1, (1, 6) = 0, (1, 7) = 0, (1, 8) = 0, (2, 1) = %K[4](L*mu), (2, 2) = %K[1](L*mu), (2, 3) = %K[2](L*mu), (2, 4) = %K[3](L*mu), (2, 5) = 0, (2, 6) = -1, (2, 7) = 0, (2, 8) = 0, (3, 1) = %K[3](L*mu), (3, 2) = %K[4](L*mu), (3, 3) = %K[1](L*mu), (3, 4) = %K[2](L*mu), (3, 5) = 0, (3, 6) = b/mu, (3, 7) = -1, (3, 8) = 0, (4, 1) = %K[2](L*mu), (4, 2) = %K[3](L*mu), (4, 3) = %K[4](L*mu), (4, 4) = %K[1](L*mu), (4, 5) = a/mu^3, (4, 6) = 0, (4, 7) = 0, (4, 8) = -1})

Note:  In Maple's Java interface, inert quantities are shown in gray.


Note:  The L in this matrix is the length of the span to the left of the interface.
Recall that it is L__i , not `L__i+1`, in the derivation that leads to that matrix.

In a beam consisting of N spans, we write the ith span's deflection X__i(x) as
"`X__i`(x)=`a__i 1`*`K__1`(mu*x)+`a__i 2`*`K__2`(mu*x)+`a__i 3`*`K__3`(mu*x)+`a__i 4`*`K__4`(mu*x)."

Solving the beam amounts to determining the 4*N unknowns `a__i j`, i = 1 .. N, j = 1 .. 4.

which we order as

 

`a__1,1`, `a__1,2`, `a__1,3`, `a__1,4`, `a__2,1`, `a__2,2`, () .. (), `a__N,1`, `a__N,2`, `a__N,3`, `a__N,4`

At each of the N-1 interface supports we have a set of four equations as derived
above, for a total of 4*(N-1) equations.  Additionally, we have four user-supplied

boundary conditions -- two at the extreme left and two at the extreme right of the

overall beam.  Thus, altogether we have 4*N equations which then we solve for the
4*N
 unknown coefficients a__ij.   

The user-supplied boundary conditions at the left end are two equations, each in the
form of a linear combination of the coefficients a__11, a__12, a__13, a__14.  We write M__left for the
2*4 coefficient matrix of that set of equations.  Similarly, the user-supplied boundary
conditions at the right end are two equations, each in the form of a linear combination
of the coefficients a__N1, a__N2, a__N3, a__N4.  We write M__right for the 2*4 coefficient matrix of
that set of equations.   Putting these equations together with those obtained at the interfaces,

we get a linear set of equations represented by a (4*N*4)*N matrix Mwhich can be assembled

easily from the matrices M__left, M__right, and M__interface.  In the case of a 4-span beam the

assembled 16*16matrix Mlooks like this:

The pattern generalizes to any number of spans in the obvious way.

For future use, here we record a few frequently occurring M__left and M__right matrices.

M_left_pinned := <
        1, 0, 0, 0;
        0, 0, 1, 0 >;

Matrix(2, 4, {(1, 1) = 1, (1, 2) = 0, (1, 3) = 0, (1, 4) = 0, (2, 1) = 0, (2, 2) = 0, (2, 3) = 1, (2, 4) = 0})

M_right_pinned := (mu,L) -> <
        %K[1](mu*L), %K[2](mu*L), %K[3](mu*L), %K[4](mu*L);
        %K[3](mu*L), %K[4](mu*L), %K[1](mu*L), %K[2](mu*L) >;  

proc (mu, L) options operator, arrow; `<,>`(`<|>`(%K[1](L*mu), %K[2](L*mu), %K[3](L*mu), %K[4](L*mu)), `<|>`(%K[3](L*mu), %K[4](L*mu), %K[1](L*mu), %K[2](L*mu))) end proc

M_left_clamped := <
        1, 0, 0, 0;
                0, 1, 0, 0 >;

Matrix(2, 4, {(1, 1) = 1, (1, 2) = 0, (1, 3) = 0, (1, 4) = 0, (2, 1) = 0, (2, 2) = 1, (2, 3) = 0, (2, 4) = 0})

M_right_clamped := (mu,L) -> <
        %K[1](mu*L), %K[2](mu*L), %K[3](mu*L), %K[4](mu*L);
        %K[4](mu*L), %K[1](mu*L), %K[2](mu*L), %K[3](mu*L) >;

proc (mu, L) options operator, arrow; `<,>`(`<|>`(%K[1](L*mu), %K[2](L*mu), %K[3](L*mu), %K[4](L*mu)), `<|>`(%K[4](L*mu), %K[1](L*mu), %K[2](L*mu), %K[3](L*mu))) end proc

M_left_free := <
        0, 0, 1, 0;
                0, 0, 0, 1 >;

Matrix(2, 4, {(1, 1) = 0, (1, 2) = 0, (1, 3) = 1, (1, 4) = 0, (2, 1) = 0, (2, 2) = 0, (2, 3) = 0, (2, 4) = 1})

M_right_free := (mu,L) -> <
        %K[3](mu*L), %K[4](mu*L), %K[1](mu*L), %K[2](mu*L);
        %K[2](mu*L), %K[3](mu*L), %K[4](mu*L), %K[1](mu*L) >;

proc (mu, L) options operator, arrow; `<,>`(`<|>`(%K[3](L*mu), %K[4](L*mu), %K[1](L*mu), %K[2](L*mu)), `<|>`(%K[2](L*mu), %K[3](L*mu), %K[4](L*mu), %K[1](L*mu))) end proc

The following proc builds the overall matrixM in the general case.  It takes
two or three arguments.  The first two arguments are the 2*4 matrices
which are called M__left and M__right in the discussion above.  If the beam
consists of a single span, that's all the information that need be supplied.
There is no need for the third argument.

 

In the case of a multi-span beam, in the third argument we supply the
list of the interface matrices M__interface , as in [M__1, M__2, () .. ()], listed in order
of the supports,  from left to right.   An empty list is also
acceptable and is interpreted as having no internal supports,
i.e., a single-span beam.

build_matrix := proc(left_bc::Matrix(2,4), right_bc::Matrix(2,4), interface_matrices::list)
        local N, n, i, M;

        # n is the number of internal supports
        n := 0;

        # adjust n if a third argument is supplied
        if _npassed = 3 then
                n := nops(interface_matrices);
                if n > 0 then
                        for i from 1 to n do
                                if not type(interface_matrices[i], 'Matrix(4,8)') then
                                        error "expected a 4x8 matrix for element %1 in the list of interface matrices", i;
                                end if;
                        end do;
                end if;
        end if;

        N := n + 1;                     # number of spans

        M := Matrix(4*N);
        M[1..2, 1..4] := left_bc;
        for i from 1 to n do
                M[4*i-1..4*i+2, 4*i-3..4*i+4] := interface_matrices[i];
        end do;
        M[4*N-1..4*N, 4*N-3..4*N] := right_bc;
                
        return M;
end proc:

For instance, for a single-span cantilever beam of length L we get the following M matrix:

build_matrix(M_left_clamped, M_right_free(mu,L));

Matrix(4, 4, {(1, 1) = 1, (1, 2) = 0, (1, 3) = 0, (1, 4) = 0, (2, 1) = 0, (2, 2) = 1, (2, 3) = 0, (2, 4) = 0, (3, 1) = %K[3](L*mu), (3, 2) = %K[4](L*mu), (3, 3) = %K[1](L*mu), (3, 4) = %K[2](L*mu), (4, 1) = %K[2](L*mu), (4, 2) = %K[3](L*mu), (4, 3) = %K[4](L*mu), (4, 4) = %K[1](L*mu)})

For a two-span beam with with span lengths of L__1 and L__2, and all three
supports pinned,  we get the following M matrix:

build_matrix(M_left_pinned, M_right_pinned(mu,L[2]), [M_interface(mu, L[1])]);

Matrix(%id = 18446884696906262398)

The matrix M represents a homogeneous linear system (i.e., the right-hand side vector

is zero.)  To obtain a nonzero solution, we set the determinant of M equal to zero.

That gives us a generally transcendental equation in the single unknown mu.  Normally

the equation has infinitely many solutions.  We call these `&mu;__n `, n = 1, 2, () .. () 

Remark: In the special case of pinned supports at the interfaces, that is, when
Kd = infinity, Kt = 0, the matrix M depends only on the span lengths "`L__1`, `L__2`. ..., `L__N`".
It is independent of the parameters rho, A, E, I that enter the Euler-Bernoulli
equations.  The frequencies `&omega;__n` = sqrt(I*E/(rho*A))*`&mu;__n`^2, however, depend on those parameters.

This proc plots the calculated modal shape corresponding to the eigenvalue mu.
The params argument is a set of equations which define the  numerical values

of all the parameters that enter the problem's description, such as the span

lengths.

 

It is assumed that in a multi-span beam, the span lengths are named "L[1], L[2]," etc.,
and in a single-span beam, the length is named L.

plot_beam := proc(M::Matrix,mu::realcons, params::set)
        local null_space, N, a_vals, i, j, A, B, P;
        eval(M, params);
        eval(%, :-mu=mu);
        value(%);  #print(%);
        null_space := NullSpace(%);  #print(%);
        if nops(null_space) <> 1 then
                error "Calculation failed. Increasing Digits and try again";
        end if;

        N := Dimension(M)[1]/4;  # number of spans
        a_vals := convert([seq(seq(a[i,j], j=1..4), i=1..N)] =~ null_space[1], list);

        if N = 1 then
                eval(add(a[1,j]*K[j](mu*x), j=1..4), a_vals);
                P[1] := plot(%, x=0..eval(L,params));
        else
                A := 0;
                B := 0;
                for i from 1 to N do
                        B := A + eval(L[i], params);
                        eval(add(a[i,j]*K[j](mu*x), j=1..4), a_vals);
                        eval(%, x=x-A):
                        P[i] := plot(%, x=A..B);
                        A := B;
                end do;
                unassign('i');
        end if;
        plots:-display([P[i] $i=1..N]);

end proc:

 

A single-span pinned-pinned beam

 

Here we calculate the natural modes of vibration of a single span

beam, pinned at both ends.  The modes are of the form
"X(x) = `a__11``K__1`(mu*x) + `a__12`*`K__2`(mu*x)+`a__13``K__3`(mu*x) + `a__14`*`K__4`(mu*x)."

The matrix M is:

M := build_matrix(M_left_pinned, M_right_pinned(mu,L));

Matrix(4, 4, {(1, 1) = 1, (1, 2) = 0, (1, 3) = 0, (1, 4) = 0, (2, 1) = 0, (2, 2) = 0, (2, 3) = 1, (2, 4) = 0, (3, 1) = %K[1](L*mu), (3, 2) = %K[2](L*mu), (3, 3) = %K[3](L*mu), (3, 4) = %K[4](L*mu), (4, 1) = %K[3](L*mu), (4, 2) = %K[4](L*mu), (4, 3) = %K[1](L*mu), (4, 4) = %K[2](L*mu)})

The characteristic equation:

Determinant(M);
eq := simplify(value(%)) = 0;

-%K[2](L*mu)^2+%K[4](L*mu)^2

-sinh(L*mu)*sin(L*mu) = 0

solve(eq, mu, allsolutions);

Pi*_Z1/L, I*Pi*_Z2/L

We conclude that the eigenvalues are `&mu;__n` = n*Pi/L, n = 1, 2, 3, () .. ().

 

A non-trivial solution of the system M*A = 0 is in the null-space of M:

eval(value(M), mu=n*Pi/L) assuming n::integer;
N := NullSpace(%);

Matrix(4, 4, {(1, 1) = 1, (1, 2) = 0, (1, 3) = 0, (1, 4) = 0, (2, 1) = 0, (2, 2) = 0, (2, 3) = 1, (2, 4) = 0, (3, 1) = (1/2)*cosh(n*Pi)+(1/2)*(-1)^n, (3, 2) = (1/2)*sinh(n*Pi), (3, 3) = (1/2)*cosh(n*Pi)-(1/2)*(-1)^n, (3, 4) = (1/2)*sinh(n*Pi), (4, 1) = (1/2)*cosh(n*Pi)-(1/2)*(-1)^n, (4, 2) = (1/2)*sinh(n*Pi), (4, 3) = (1/2)*cosh(n*Pi)+(1/2)*(-1)^n, (4, 4) = (1/2)*sinh(n*Pi)})

{Vector[column](%id = 18446884696899531350)}

Here are the weights that go with the Krylov functions:

a_vals := convert([a[1,j] $j=1..4] =~ N[1], set);

{a[1, 1] = 0, a[1, 2] = -1, a[1, 3] = 0, a[1, 4] = 1}

and here is the deflection:

add(a[1,j]*K[j](mu*x), j=1..4);
eval(%, a_vals);       # plug in the a_vals calculated above
eval(%, mu=n*Pi/L);    # assert that n is an integer

a[1, 1]*((1/2)*cosh(mu*x)+(1/2)*cos(mu*x))+a[1, 2]*((1/2)*sinh(mu*x)+(1/2)*sin(mu*x))+a[1, 3]*((1/2)*cosh(mu*x)-(1/2)*cos(mu*x))+a[1, 4]*((1/2)*sinh(mu*x)-(1/2)*sin(mu*x))

-sin(mu*x)

-sin(n*Pi*x/L)

We see that the shape functions are simple sinusoids.

 

 

A single-span free-free beam

 

Here we calculate the natural modes of vibration of a single span

beam, free at both ends.  The modes are of the form
X(x) = a__11*K__1(mu*x)+a__12*K__2(mu*x)+a__13*K__3(mu*x)+a__14*K__4(mu*x).

The reasoning behind the calculations is very similar to that in the

previous section, therefore we don't comment on many details.

M := build_matrix(M_left_free, M_right_free(mu,L));

Matrix(4, 4, {(1, 1) = 0, (1, 2) = 0, (1, 3) = 1, (1, 4) = 0, (2, 1) = 0, (2, 2) = 0, (2, 3) = 0, (2, 4) = 1, (3, 1) = %K[3](L*mu), (3, 2) = %K[4](L*mu), (3, 3) = %K[1](L*mu), (3, 4) = %K[2](L*mu), (4, 1) = %K[2](L*mu), (4, 2) = %K[3](L*mu), (4, 3) = %K[4](L*mu), (4, 4) = %K[1](L*mu)})

The characteristic equation:

Determinant(M);
simplify(value(%)) = 0;
eq_tmp := isolate(%, cos(L*mu));

%K[3](L*mu)^2-%K[2](L*mu)*%K[4](L*mu)

1/2-(1/2)*cosh(L*mu)*cos(L*mu) = 0

cos(L*mu) = 1/cosh(L*mu)

Let lambda = L*mu.  Then the characteristic equation takes the form

eq := algsubs(L*mu=lambda, eq_tmp);

cos(lambda) = 1/cosh(lambda)

Here are the graphs of the two sides of the characteristic equation:

plot([lhs,rhs](eq), lambda=0..4*Pi, color=["red","Green"]);

The first three roots are:

lambda__1, lambda__2, lambda__3 :=
        fsolve(eq, lambda=Pi/2..4*Pi, maxsols=3);

4.730040744, 7.853204624, 10.99560783

params := { L=1 };

{L = 1}

mu__1, mu__2, mu__3 := (lambda__1, lambda__2, lambda__3) /~ eval(L, params);

4.730040744, 7.853204624, 10.99560783

plots:-display([
        plot_beam(M, mu__1, params),
        plot_beam(M, mu__2, params),
        plot_beam(M, mu__3, params)],
        color=["red","Green","blue"],
        legend=[mode1, mode2, mode3]);

 

 

A single-span clamped-free cantilever

 

We have a cantilever beam of length L.  It is clamped at the

left end, and free at the right end.

M := build_matrix(M_left_clamped, M_right_free(mu,L));

Matrix(4, 4, {(1, 1) = 1, (1, 2) = 0, (1, 3) = 0, (1, 4) = 0, (2, 1) = 0, (2, 2) = 1, (2, 3) = 0, (2, 4) = 0, (3, 1) = %K[3](L*mu), (3, 2) = %K[4](L*mu), (3, 3) = %K[1](L*mu), (3, 4) = %K[2](L*mu), (4, 1) = %K[2](L*mu), (4, 2) = %K[3](L*mu), (4, 3) = %K[4](L*mu), (4, 4) = %K[1](L*mu)})

Determinant(M);
simplify(value(%)) = 0;
eq_tmp := isolate(%, cos(L*mu));

%K[1](L*mu)^2-%K[2](L*mu)*%K[4](L*mu)

1/2+(1/2)*cosh(L*mu)*cos(L*mu) = 0

cos(L*mu) = -1/cosh(L*mu)

Let lambda = L*mu.  Then the characteristic equation takes the form

eq := algsubs(L*mu=lambda, eq_tmp);

cos(lambda) = -1/cosh(lambda)

Here are the graphs of the two sides of the characteristic equation:

plot([lhs,rhs](eq), lambda=0..3*Pi, color=["red","Green"]);

lambda__1, lambda__2, lambda__3 :=
        fsolve(eq, lambda=Pi/2..3*Pi, maxsols=3);

1.875104068, 4.694091132, 7.854757438

params := { L=1 };

{L = 1}

mu__1, mu__2, mu__3 := (lambda__1, lambda__2, lambda__3) /~ eval(L, params);

1.875104068, 4.694091132, 7.854757438

plots:-display([
        plot_beam(M, mu__1, params),
        plot_beam(M, mu__2, params),
        plot_beam(M, mu__3, params)],
        color=["red","Green","blue"],
        legend=[mode1, mode2, mode3]);

 

 

A dual-span pinned-pinned-free cantilever beam

 

We have a two-span beam of span lengths L__1 and L__2, with the left end of the
first span pinned, the right end of the second span free, and the interface

between the spans on a pinned support.  .

M := build_matrix(
        M_left_pinned,
        M_right_free(mu,L[2]),
                [ M_interface(mu,L[1])] );

Matrix(8, 8, {(1, 1) = 1, (1, 2) = 0, (1, 3) = 0, (1, 4) = 0, (1, 5) = 0, (1, 6) = 0, (1, 7) = 0, (1, 8) = 0, (2, 1) = 0, (2, 2) = 0, (2, 3) = 1, (2, 4) = 0, (2, 5) = 0, (2, 6) = 0, (2, 7) = 0, (2, 8) = 0, (3, 1) = %K[1](L[1]*mu), (3, 2) = %K[2](L[1]*mu), (3, 3) = %K[3](L[1]*mu), (3, 4) = %K[4](L[1]*mu), (3, 5) = -1, (3, 6) = 0, (3, 7) = 0, (3, 8) = 0, (4, 1) = %K[4](L[1]*mu), (4, 2) = %K[1](L[1]*mu), (4, 3) = %K[2](L[1]*mu), (4, 4) = %K[3](L[1]*mu), (4, 5) = 0, (4, 6) = -1, (4, 7) = 0, (4, 8) = 0, (5, 1) = %K[3](L[1]*mu), (5, 2) = %K[4](L[1]*mu), (5, 3) = %K[1](L[1]*mu), (5, 4) = %K[2](L[1]*mu), (5, 5) = 0, (5, 6) = 0, (5, 7) = -1, (5, 8) = 0, (6, 1) = 0, (6, 2) = 0, (6, 3) = 0, (6, 4) = 0, (6, 5) = 1, (6, 6) = 0, (6, 7) = 0, (6, 8) = 0, (7, 1) = 0, (7, 2) = 0, (7, 3) = 0, (7, 4) = 0, (7, 5) = %K[3](L[2]*mu), (7, 6) = %K[4](L[2]*mu), (7, 7) = %K[1](L[2]*mu), (7, 8) = %K[2](L[2]*mu), (8, 1) = 0, (8, 2) = 0, (8, 3) = 0, (8, 4) = 0, (8, 5) = %K[2](L[2]*mu), (8, 6) = %K[3](L[2]*mu), (8, 7) = %K[4](L[2]*mu), (8, 8) = %K[1](L[2]*mu)})

The characteristic equation:

Determinant(M);
eq_tmp1 := simplify(value(%)) = 0;

%K[4](L[1]*mu)^2*%K[4](L[2]*mu)*%K[2](L[2]*mu)-%K[4](L[1]*mu)^2*%K[1](L[2]*mu)^2-%K[4](L[1]*mu)*%K[1](L[1]*mu)*%K[4](L[2]*mu)*%K[1](L[2]*mu)+%K[4](L[1]*mu)*%K[1](L[1]*mu)*%K[3](L[2]*mu)*%K[2](L[2]*mu)+%K[4](L[2]*mu)*%K[1](L[2]*mu)*%K[3](L[1]*mu)*%K[2](L[1]*mu)-%K[4](L[2]*mu)*%K[2](L[2]*mu)*%K[2](L[1]*mu)^2+%K[1](L[2]*mu)^2*%K[2](L[1]*mu)^2-%K[3](L[2]*mu)*%K[2](L[2]*mu)*%K[3](L[1]*mu)*%K[2](L[1]*mu)

(1/4)*(-cos(L[1]*mu)*sinh(L[2]*mu)*cos(L[2]*mu)+cos(L[1]*mu)*sin(L[2]*mu)*cosh(L[2]*mu)+2*sin(L[1]*mu)*cosh(L[2]*mu)*cos(L[2]*mu)+2*sin(L[1]*mu))*sinh(L[1]*mu)+(1/4)*sin(L[1]*mu)*cosh(L[1]*mu)*(sinh(L[2]*mu)*cos(L[2]*mu)-sin(L[2]*mu)*cosh(L[2]*mu)) = 0

That equation does not seem to be amenable to simplification.  The special case of L__1 = L__2, however,

is much nicer:

eval(eq_tmp1, {L[1]=L, L[2]=L}):
eq_tmp2 := simplify(%*4);

(4*cosh(L*mu)*cos(L*mu)+2)*sinh(L*mu)*sin(L*mu)+cos(L*mu)^2-cosh(L*mu)^2 = 0

Let L*mu = lambda:

eq_tmp3 := algsubs(L*mu=lambda, eq_tmp2);

(4*cosh(lambda)*cos(lambda)+2)*sinh(lambda)*sin(lambda)+cos(lambda)^2-cosh(lambda)^2 = 0

That expression grows like cosh(lambda)^2, so we divide through by that to obtain

a better-behaved equation

eq := eq_tmp3/cosh(lambda)^2;

((4*cosh(lambda)*cos(lambda)+2)*sinh(lambda)*sin(lambda)+cos(lambda)^2-cosh(lambda)^2)/cosh(lambda)^2 = 0

plot(lhs(eq), lambda=0..2*Pi);

Here are the first three roots:

lambda__1, lambda__2, lambda__3 :=
         fsolve(eq, lambda=1e-3..2*Pi, maxsols=3);

1.505915458, 3.413100675, 4.437274304

params := { L[1]=1, L[2]=1 };

{L[1] = 1, L[2] = 1}

mu__1, mu__2, mu__3 := (lambda__1, lambda__2, lambda__3) /~ eval(L[1], params);

1.505915458, 3.413100675, 4.437274304

plots:-display([
        plot_beam(M, mu__1, params),
        plot_beam(M, mu__2, params),
        plot_beam(M, mu__3, params)],
        color=["red","Green","blue"],
        legend=[mode1, mode2, mode3]);

 

 

A dual-span clamped-pinned-free cantilever beam

 

We have a two-span beam of span lengths L__1 and L__2, with the left end of the
first span clamped, the right end of the second span free, and the interface

between the spans on a pinned support.  This is different from the previous

case only in the nature of the left boundary condition.

M := build_matrix(
        M_left_clamped,
        M_right_free(mu,L[2]),
        [ M_interface(mu,L[1])] );

Matrix(8, 8, {(1, 1) = 1, (1, 2) = 0, (1, 3) = 0, (1, 4) = 0, (1, 5) = 0, (1, 6) = 0, (1, 7) = 0, (1, 8) = 0, (2, 1) = 0, (2, 2) = 1, (2, 3) = 0, (2, 4) = 0, (2, 5) = 0, (2, 6) = 0, (2, 7) = 0, (2, 8) = 0, (3, 1) = %K[1](L[1]*mu), (3, 2) = %K[2](L[1]*mu), (3, 3) = %K[3](L[1]*mu), (3, 4) = %K[4](L[1]*mu), (3, 5) = -1, (3, 6) = 0, (3, 7) = 0, (3, 8) = 0, (4, 1) = %K[4](L[1]*mu), (4, 2) = %K[1](L[1]*mu), (4, 3) = %K[2](L[1]*mu), (4, 4) = %K[3](L[1]*mu), (4, 5) = 0, (4, 6) = -1, (4, 7) = 0, (4, 8) = 0, (5, 1) = %K[3](L[1]*mu), (5, 2) = %K[4](L[1]*mu), (5, 3) = %K[1](L[1]*mu), (5, 4) = %K[2](L[1]*mu), (5, 5) = 0, (5, 6) = 0, (5, 7) = -1, (5, 8) = 0, (6, 1) = 0, (6, 2) = 0, (6, 3) = 0, (6, 4) = 0, (6, 5) = 1, (6, 6) = 0, (6, 7) = 0, (6, 8) = 0, (7, 1) = 0, (7, 2) = 0, (7, 3) = 0, (7, 4) = 0, (7, 5) = %K[3](L[2]*mu), (7, 6) = %K[4](L[2]*mu), (7, 7) = %K[1](L[2]*mu), (7, 8) = %K[2](L[2]*mu), (8, 1) = 0, (8, 2) = 0, (8, 3) = 0, (8, 4) = 0, (8, 5) = %K[2](L[2]*mu), (8, 6) = %K[3](L[2]*mu), (8, 7) = %K[4](L[2]*mu), (8, 8) = %K[1](L[2]*mu)})

The characteristic equation:

Determinant(M);
eq_tmp1 := simplify(value(%)) = 0;

%K[2](L[1]*mu)*%K[4](L[1]*mu)*%K[4](L[2]*mu)*%K[1](L[2]*mu)-%K[2](L[1]*mu)*%K[4](L[1]*mu)*%K[3](L[2]*mu)*%K[2](L[2]*mu)+%K[2](L[1]*mu)*%K[3](L[1]*mu)*%K[4](L[2]*mu)*%K[2](L[2]*mu)-%K[2](L[1]*mu)*%K[3](L[1]*mu)*%K[1](L[2]*mu)^2-%K[1](L[1]*mu)*%K[4](L[1]*mu)*%K[4](L[2]*mu)*%K[2](L[2]*mu)+%K[1](L[1]*mu)*%K[4](L[1]*mu)*%K[1](L[2]*mu)^2-%K[3](L[1]*mu)^2*%K[4](L[2]*mu)*%K[1](L[2]*mu)+%K[3](L[1]*mu)^2*%K[3](L[2]*mu)*%K[2](L[2]*mu)

(1/4)*((-cos(L[1]*mu)*sin(L[2]*mu)-sin(L[1]*mu)*cos(L[2]*mu))*cosh(L[2]*mu)+cos(L[1]*mu)*sinh(L[2]*mu)*cos(L[2]*mu)-sin(L[1]*mu))*cosh(L[1]*mu)+(1/4)*(sinh(L[1]*mu)*cos(L[1]*mu)*cos(L[2]*mu)+sin(L[2]*mu))*cosh(L[2]*mu)+(1/4)*sinh(L[1]*mu)*cos(L[1]*mu)-(1/4)*sinh(L[2]*mu)*cos(L[2]*mu) = 0

That equation does not seem to be amenable to simplification.  The special case of L__1 = L__2, however,

is much nicer:

eval(eq_tmp1, {L[1]=L, L[2]=L}):
eq_tmp2 := simplify(%*4);

-2*cosh(L*mu)*cos(L*mu)*(sin(L*mu)*cosh(L*mu)-sinh(L*mu)*cos(L*mu)) = 0

Let L*mu = lambda:

eq_tmp3 := algsubs(L*mu=lambda, eq_tmp2);

-2*cosh(lambda)*cos(lambda)*(sin(lambda)*cosh(lambda)-sinh(lambda)*cos(lambda)) = 0

That expression grows like cosh(lambda)^2, so we divide through by that to obtain

a better-behaved equation

eq := eq_tmp3/cosh(lambda)^2;

-2*cos(lambda)*(sin(lambda)*cosh(lambda)-sinh(lambda)*cos(lambda))/cosh(lambda) = 0

plot(lhs(eq), lambda=0..2*Pi);

Here are the first three roots:

lambda__1, lambda__2, lambda__3 :=
         fsolve(eq, lambda=1e-3..2*Pi, maxsols=3);

1.570796326, 3.926602312, 4.712388980

params := { L[1]=1, L[2]=1 };

{L[1] = 1, L[2] = 1}

mu__1, mu__2, mu__3 := (lambda__1, lambda__2, lambda__3) /~ eval(L[1], params);

1.570796326, 3.926602312, 4.712388980

plots:-display([
        plot_beam(M, mu__1, params),
        plot_beam(M, mu__2, params),
        plot_beam(M, mu__3, params)],
        color=["red","Green","blue"],
        legend=[mode1, mode2, mode3]);

 

 

A triple-span free-pinned-pinned-free beam

 

We have a triple-span beam with span lengths of L__1, L__2, L__3.  The beam is supported

on two internal pinned supports.  The extreme ends of the beam are free.

The graphs of the first three modes agree with those

in Figure 3.22 on page 70 of the 2007 article of
Henrik Åkesson, Tatiana Smirnova, Thomas Lagö, and Lars Håkansson.

In the caption of Figure 2.12 on page 28 the span lengths are given
as "`L__1`="3.5, "`L__2`="5.0, "`L__3`="21.5.

interface(rtablesize=12):

M := build_matrix(
        M_left_free,
        M_right_free(mu,L[3]),
        [ M_interface(mu,L[1]), M_interface(mu,L[2])] );

Matrix(12, 12, {(1, 1) = 0, (1, 2) = 0, (1, 3) = 1, (1, 4) = 0, (1, 5) = 0, (1, 6) = 0, (1, 7) = 0, (1, 8) = 0, (1, 9) = 0, (1, 10) = 0, (1, 11) = 0, (1, 12) = 0, (2, 1) = 0, (2, 2) = 0, (2, 3) = 0, (2, 4) = 1, (2, 5) = 0, (2, 6) = 0, (2, 7) = 0, (2, 8) = 0, (2, 9) = 0, (2, 10) = 0, (2, 11) = 0, (2, 12) = 0, (3, 1) = %K[1](L[1]*mu), (3, 2) = %K[2](L[1]*mu), (3, 3) = %K[3](L[1]*mu), (3, 4) = %K[4](L[1]*mu), (3, 5) = -1, (3, 6) = 0, (3, 7) = 0, (3, 8) = 0, (3, 9) = 0, (3, 10) = 0, (3, 11) = 0, (3, 12) = 0, (4, 1) = %K[4](L[1]*mu), (4, 2) = %K[1](L[1]*mu), (4, 3) = %K[2](L[1]*mu), (4, 4) = %K[3](L[1]*mu), (4, 5) = 0, (4, 6) = -1, (4, 7) = 0, (4, 8) = 0, (4, 9) = 0, (4, 10) = 0, (4, 11) = 0, (4, 12) = 0, (5, 1) = %K[3](L[1]*mu), (5, 2) = %K[4](L[1]*mu), (5, 3) = %K[1](L[1]*mu), (5, 4) = %K[2](L[1]*mu), (5, 5) = 0, (5, 6) = 0, (5, 7) = -1, (5, 8) = 0, (5, 9) = 0, (5, 10) = 0, (5, 11) = 0, (5, 12) = 0, (6, 1) = 0, (6, 2) = 0, (6, 3) = 0, (6, 4) = 0, (6, 5) = 1, (6, 6) = 0, (6, 7) = 0, (6, 8) = 0, (6, 9) = 0, (6, 10) = 0, (6, 11) = 0, (6, 12) = 0, (7, 1) = 0, (7, 2) = 0, (7, 3) = 0, (7, 4) = 0, (7, 5) = %K[1](L[2]*mu), (7, 6) = %K[2](L[2]*mu), (7, 7) = %K[3](L[2]*mu), (7, 8) = %K[4](L[2]*mu), (7, 9) = -1, (7, 10) = 0, (7, 11) = 0, (7, 12) = 0, (8, 1) = 0, (8, 2) = 0, (8, 3) = 0, (8, 4) = 0, (8, 5) = %K[4](L[2]*mu), (8, 6) = %K[1](L[2]*mu), (8, 7) = %K[2](L[2]*mu), (8, 8) = %K[3](L[2]*mu), (8, 9) = 0, (8, 10) = -1, (8, 11) = 0, (8, 12) = 0, (9, 1) = 0, (9, 2) = 0, (9, 3) = 0, (9, 4) = 0, (9, 5) = %K[3](L[2]*mu), (9, 6) = %K[4](L[2]*mu), (9, 7) = %K[1](L[2]*mu), (9, 8) = %K[2](L[2]*mu), (9, 9) = 0, (9, 10) = 0, (9, 11) = -1, (9, 12) = 0, (10, 1) = 0, (10, 2) = 0, (10, 3) = 0, (10, 4) = 0, (10, 5) = 0, (10, 6) = 0, (10, 7) = 0, (10, 8) = 0, (10, 9) = 1, (10, 10) = 0, (10, 11) = 0, (10, 12) = 0, (11, 1) = 0, (11, 2) = 0, (11, 3) = 0, (11, 4) = 0, (11, 5) = 0, (11, 6) = 0, (11, 7) = 0, (11, 8) = 0, (11, 9) = %K[3](L[3]*mu), (11, 10) = %K[4](L[3]*mu), (11, 11) = %K[1](L[3]*mu), (11, 12) = %K[2](L[3]*mu), (12, 1) = 0, (12, 2) = 0, (12, 3) = 0, (12, 4) = 0, (12, 5) = 0, (12, 6) = 0, (12, 7) = 0, (12, 8) = 0, (12, 9) = %K[2](L[3]*mu), (12, 10) = %K[3](L[3]*mu), (12, 11) = %K[4](L[3]*mu), (12, 12) = %K[1](L[3]*mu)})

params := { L[1]=3.5, L[2]=5.0, L[3]=21.5 };

{L[1] = 3.5, L[2] = 5.0, L[3] = 21.5}

The characteristic equation

simplify(Determinant(M)):
value(%):
eq := simplify(eval(%, params));

(1/8)*(((2*sin(5.*mu)*sinh(5.*mu)*cos(3.5*mu)+sin(3.5*mu)*(cos(5.*mu)*sinh(5.*mu)-sin(5.*mu)*cosh(5.*mu)))*cosh(3.5*mu)-sinh(3.5*mu)*(cos(5.*mu)*sinh(5.*mu)-sin(5.*mu)*cosh(5.*mu))*cos(3.5*mu)+2*sinh(5.*mu)*sin(5.*mu))*cos(21.5*mu)+sin(21.5*mu)*(((cos(5.*mu)*sinh(5.*mu)-sin(5.*mu)*cosh(5.*mu))*cos(3.5*mu)-cos(5.*mu)*cosh(5.*mu)*sin(3.5*mu)+sin(3.5*mu))*cosh(3.5*mu)+sinh(3.5*mu)*(cos(5.*mu)*cosh(5.*mu)-1)*cos(3.5*mu)+cos(5.*mu)*sinh(5.*mu)-sin(5.*mu)*cosh(5.*mu)))*cosh(21.5*mu)-(1/8)*sinh(21.5*mu)*(((cos(5.*mu)*sinh(5.*mu)-sin(5.*mu)*cosh(5.*mu))*cos(3.5*mu)-cos(5.*mu)*cosh(5.*mu)*sin(3.5*mu)+sin(3.5*mu))*cosh(3.5*mu)+sinh(3.5*mu)*(cos(5.*mu)*cosh(5.*mu)-1)*cos(3.5*mu)+cos(5.*mu)*sinh(5.*mu)-sin(5.*mu)*cosh(5.*mu))*cos(21.5*mu)+(1/8)*(2*sin(5.*mu)*sinh(5.*mu)*cos(3.5*mu)+sin(3.5*mu)*(cos(5.*mu)*sinh(5.*mu)-sin(5.*mu)*cosh(5.*mu)))*cosh(3.5*mu)-(1/8)*sinh(3.5*mu)*(cos(5.*mu)*sinh(5.*mu)-sin(5.*mu)*cosh(5.*mu))*cos(3.5*mu)+(1/4)*sinh(5.*mu)*sin(5.*mu)

plot(eq, mu=0..0.4);

That graphs grows much too fast to be useful.  We moderate it by dividing through
the fastest growing cosh term:

plot(eq/cosh(21.5*mu), mu=0..0.4);

Here are the first three roots:

mu__1, mu__2, mu__3 := fsolve(eq, mu=1e-3..0.4, maxsols=3);

0.8148236435e-1, .2065743153, .3465175842

plots:-display([
        plot_beam(M, mu__1, params),
        plot_beam(M, mu__2, params),
        plot_beam(M, mu__3, params)],
        color=["red","Green","blue"],
        legend=[mode1, mode2, mode3]);

 

 

A triple-span free-spring-spring-free beam

 

We have a triple-span beam with span lengths of L__1, L__2, L__3.  The beam is supported

on two internal springy supports.  The extreme ends of the beam are free.
The numerical data is from the worksheet posted on July 29, 2020 at
https://www.mapleprimes.com/questions/230085-Elasticfoundation-Multispan-EulerBernoulli-Beamthreespan#comment271586

The problem is pretty much the same as the one in the previous section, but the

pinned supports have been replaced by spring supports.

This section's calculations require a little more precision than

Maple's default of 10 digits:

Digits := 15;

15

interface(rtablesize=12):

M := build_matrix(M_left_free, M_right_free(mu,L[3]),
                        [ M_interface(mu, L[1], 'Kd'=kd/(E*I), 'Kt'=kt/(E*I)),
                           M_interface(mu, L[2], 'Kd'=kd/(E*I), 'Kt'=kt/(E*I)) ]);

Matrix(12, 12, {(1, 1) = 0, (1, 2) = 0, (1, 3) = 1, (1, 4) = 0, (1, 5) = 0, (1, 6) = 0, (1, 7) = 0, (1, 8) = 0, (1, 9) = 0, (1, 10) = 0, (1, 11) = 0, (1, 12) = 0, (2, 1) = 0, (2, 2) = 0, (2, 3) = 0, (2, 4) = 1, (2, 5) = 0, (2, 6) = 0, (2, 7) = 0, (2, 8) = 0, (2, 9) = 0, (2, 10) = 0, (2, 11) = 0, (2, 12) = 0, (3, 1) = %K[1](L[1]*mu), (3, 2) = %K[2](L[1]*mu), (3, 3) = %K[3](L[1]*mu), (3, 4) = %K[4](L[1]*mu), (3, 5) = -1, (3, 6) = 0, (3, 7) = 0, (3, 8) = 0, (3, 9) = 0, (3, 10) = 0, (3, 11) = 0, (3, 12) = 0, (4, 1) = %K[4](L[1]*mu), (4, 2) = %K[1](L[1]*mu), (4, 3) = %K[2](L[1]*mu), (4, 4) = %K[3](L[1]*mu), (4, 5) = 0, (4, 6) = -1, (4, 7) = 0, (4, 8) = 0, (4, 9) = 0, (4, 10) = 0, (4, 11) = 0, (4, 12) = 0, (5, 1) = %K[3](L[1]*mu), (5, 2) = %K[4](L[1]*mu), (5, 3) = %K[1](L[1]*mu), (5, 4) = %K[2](L[1]*mu), (5, 5) = 0, (5, 6) = -I*kt/(E*mu), (5, 7) = -1, (5, 8) = 0, (5, 9) = 0, (5, 10) = 0, (5, 11) = 0, (5, 12) = 0, (6, 1) = %K[2](L[1]*mu), (6, 2) = %K[3](L[1]*mu), (6, 3) = %K[4](L[1]*mu), (6, 4) = %K[1](L[1]*mu), (6, 5) = -I*kd/(E*mu^3), (6, 6) = 0, (6, 7) = 0, (6, 8) = -1, (6, 9) = 0, (6, 10) = 0, (6, 11) = 0, (6, 12) = 0, (7, 1) = 0, (7, 2) = 0, (7, 3) = 0, (7, 4) = 0, (7, 5) = %K[1](L[2]*mu), (7, 6) = %K[2](L[2]*mu), (7, 7) = %K[3](L[2]*mu), (7, 8) = %K[4](L[2]*mu), (7, 9) = -1, (7, 10) = 0, (7, 11) = 0, (7, 12) = 0, (8, 1) = 0, (8, 2) = 0, (8, 3) = 0, (8, 4) = 0, (8, 5) = %K[4](L[2]*mu), (8, 6) = %K[1](L[2]*mu), (8, 7) = %K[2](L[2]*mu), (8, 8) = %K[3](L[2]*mu), (8, 9) = 0, (8, 10) = -1, (8, 11) = 0, (8, 12) = 0, (9, 1) = 0, (9, 2) = 0, (9, 3) = 0, (9, 4) = 0, (9, 5) = %K[3](L[2]*mu), (9, 6) = %K[4](L[2]*mu), (9, 7) = %K[1](L[2]*mu), (9, 8) = %K[2](L[2]*mu), (9, 9) = 0, (9, 10) = -I*kt/(E*mu), (9, 11) = -1, (9, 12) = 0, (10, 1) = 0, (10, 2) = 0, (10, 3) = 0, (10, 4) = 0, (10, 5) = %K[2](L[2]*mu), (10, 6) = %K[3](L[2]*mu), (10, 7) = %K[4](L[2]*mu), (10, 8) = %K[1](L[2]*mu), (10, 9) = -I*kd/(E*mu^3), (10, 10) = 0, (10, 11) = 0, (10, 12) = -1, (11, 1) = 0, (11, 2) = 0, (11, 3) = 0, (11, 4) = 0, (11, 5) = 0, (11, 6) = 0, (11, 7) = 0, (11, 8) = 0, (11, 9) = %K[3](L[3]*mu), (11, 10) = %K[4](L[3]*mu), (11, 11) = %K[1](L[3]*mu), (11, 12) = %K[2](L[3]*mu), (12, 1) = 0, (12, 2) = 0, (12, 3) = 0, (12, 4) = 0, (12, 5) = 0, (12, 6) = 0, (12, 7) = 0, (12, 8) = 0, (12, 9) = %K[2](L[3]*mu), (12, 10) = %K[3](L[3]*mu), (12, 11) = %K[4](L[3]*mu), (12, 12) = %K[1](L[3]*mu)})

Calculate the determinant of M.  The result is quite large, so we terminate the command
with a colon so that not to have to look at the result.  If we bothered to peek,  however, we
will see that the determinant has a factor of 1/mu^8.  But that quite obvious by looking at the
entries of the matrix shown above. Two of its rows have 1/mu in them and another two have
1/mu^3. When multiplied, they produce the overall factor of 1/mu^8.

DET := Determinant(M):

Here are the parameters that the determinant depends on:

indets(DET, name);   # the parameters that make up M

{E, I, kd, kt, mu, L[1], L[2], L[3]}

So we provide values for those parameters:

params := {
        L[1]=3.5, L[2]=5.0, L[3]=21.5,
    kd=4.881e9, kt=1.422e4,
    E = 2.05e11, I = 1.1385e-7 };

{E = 0.205e12, I = 0.11385e-6, kd = 0.4881e10, kt = 0.1422e5, L[1] = 3.5, L[2] = 5.0, L[3] = 21.5}

Here is the characteristic equation.  We multiply it by mu^8 to remove the singularity at mu = 0.

mu^8 * value(DET):
eq := eval(%, params):

plot(eq, mu=0..0.6);

We can't see anything useful in that graph.  Let's limit the vertical range:

plot(eq, mu=0..0.6, view=-1e8..1e8);

mu__1, mu__2, mu__3 := fsolve(eq, mu=1e-3..0.6, maxsols=3);

0.843267855136311e-1, .211829475814118, .355117213056777

plots:-display([
        plot_beam(M, mu__1, params),
        plot_beam(M, mu__2, params),
        plot_beam(M, mu__3, params)],
        color=["red","Green","blue"],
        legend=[mode1, mode2, mode3]);

Digits := 10;  # restore the default

10

 

 

 

 

 

 

Download krylov-duncan.mw

 

Hi,

Need your help to find the convergent solution of the attached problem.

Here is some information about parameters

(0 <= gamma <= 10,      0 <= rho & nu <= 200)

 

Arif_Ullah.mw
 

 

restart:

with(plots):

N:=6:

 

eq1 :=3*diff(f(eta),eta,eta,eta)+2*f(eta)*diff(f(eta),eta,eta)-(diff(f(eta),eta))^2;

3*(diff(diff(diff(f(eta), eta), eta), eta))+2*f(eta)*(diff(diff(f(eta), eta), eta))-(diff(f(eta), eta))^2

(1)

NULL

eq2 := 3*nu*diff(g(eta),eta,eta,eta)+2*g(eta)*diff(g(eta),eta,eta)-(diff(g(eta),eta))^2;

3*nu*(diff(diff(diff(g(eta), eta), eta), eta))+2*g(eta)*(diff(diff(g(eta), eta), eta))-(diff(g(eta), eta))^2

(2)

 

bc:=f(0) = 0, g(0) = 0, D(f)(0) = D(g)(0), D(D(f))(0) = -rho*nu*D(D(g))(0), D(D(f))(6) = 1, D(D(g))(N) = gamma;

f(0) = 0, g(0) = 0, (D(f))(0) = (D(g))(0), ((D@@2)(f))(0) = -rho*nu*((D@@2)(g))(0), ((D@@2)(f))(6) = 1, ((D@@2)(g))(6) = gamma

(3)

 

para:={nu=3, gamma=10};

{gamma = 10, nu = 3}

(4)

 

A1 := dsolve(subs(para,rho=2, {bc, eq1, eq2}), numeric,method = bvp[midrich],maxmesh=12500, output=array([seq( 0.01*i, i=0..100*N)])):

 

Error, (in dsolve/numeric/bvp) Newton iteration is not converging

 

pf1 := odeplot(A1, [[eta,diff(f(eta),eta), linestyle = 1, color = blue]], 0 .. N):

Error, (in plots/odeplot) input is not a valid dsolve/numeric solution

 

 

pf2 := odeplot(A1, [[eta,diff(g(eta),eta), linestyle = 3, color = red]], 0 .. N):

Error, (in plots/odeplot) input is not a valid dsolve/numeric solution

 

display({pf1,pf2}, axes = boxed,thickness=3,labels = [eta, "f' '"],labelfont = ["ROMAN", 22,Bold,Italic],axesfont = ["ROMAN", "ROMAN", 14,Bold],axis=[thickness=3]);

Error, (in plots:-display) expecting plot structures but received: {pf1, pf2}

 

NULL


 

Download Arif_Ullah.mw

 

 I'm thinking about a question about counting the total number of Eulerian trails of following graphs . 

The Seven Bridges in Gonisburg lost one bridge due to war. 

G-e7

We looked up on Wikipedia to  add some details..

For the existence of Eulerian trails it is necessary that zero or two vertices have an odd degree; this means the Königsberg graph is not Eulerian. If there are no vertices of odd degree, all Eulerian trails are circuits. If there are exactly two vertices of odd degree, all Eulerian trails start at one of them and end at the other. A graph that has an Eulerian trail but not an Eulerian circuit is called semi-Eulerian.

It's easy to know that G-e7 is semi-Eulerian. So I want find all Eulerian trails. A simple attempt, found the following one in graph (Pink label).

I feel a little tricky dealing with this through Maple. The first reason is that the Maple graph theory package does not support parallel edges. Unfortunately, eand e6 are parallel edges of G-e7.

To take a step back, what if there are no parallel edges? For considering G-e7-e6.

There are some built-in commands related like FindEulerianPath , but can only find a Euler circuits.

 

 

 

 

Hi!

If I have a list of numbers e.g, data:=[0,12,0,7,5,3,7,10,0,0,9,3,2,5,0,6]

How do I get Maple to count the values bigger or equal to seven? [ans=5]

 

 

Hi. Can someone solve for w as a general function of k, without RootOf

w^3+3w^3*(1-w)+6w^3*(1-w)^2=k, k constant

i tried

allvalues(solve(w^3+3*w^3*(1-w)+6*w^3*(1-w)^2-k,w))

and also with option explicit (edit)

 

 

I have some difficulties with exporting a 3d plot from Maple in a pdf format without loosing the whole settings. As a simple example consider the following.

plot3d(sin(x)*10^y, x = -4 .. 4, y = -2 .. 2, view = [-4 .. 4, -2 .. 2, 0 .. 2], labelfont = ["TimesNewRoman", 26], labels = [x, Typesetting:-Typeset(log[10](y)), typeset()])

I tried two approaches, each has a drawback.

1- Right clicking on the figure, choosing `Export`, then `PDF`. Unfortunately, Maple changes the font size of labels!

2- Right clicking on the figure, choosing `Export`, then `Encapsulated Postcript`. Then I open the resulted `eps` file in GSview. Convert it to pdf. The result is a large-size pdf file which is heavy to render. Even when it gets rendered, scrolling up and down (for example in Adobe reader) is not good, because it seems the picture is going to get rendered again!

So how should one export a 3d plot from Maple in a pdf format, But not loosing the settings of the plot such as the font size of the labels and also not ending up with a heavy file?

First 37 38 39 40 41 42 43 Last Page 39 of 55