The Double Pendulum and Past: Investigating Chaos With Multi-Armed Pendulums | by Oliver W. Johnson | Apr, 2024

Utilizing VPython simulations to mannequin chaotic movement and examine what defines a chaotic system.

Any physics scholar has examined the lowly pendulum, in all probability greater than they needed to. Together with the mass on a spring, pendulums are the quintessential instance of easy harmonic movement. The key phrase there’s easy. They, as you could know, are extremely straightforward to mannequin mathematically. The interval of the pendulum could be represented by the method under, the place g is the drive of gravity and L is the size of the pendulum.

The angular displacement is considerably extra fascinating however nonetheless not too deep. The equation itself is extra complicated, however in actuality it’s only a cosine wave. The equation under represents the angular displacement of a single pendulum, the place θ is the angular displacement, A is the utmost angular displacement (generally that is simply the discharge angle), ω is the angular frequency, and t is time.

With that out of the way in which, let’s get to the extra fascinating, albeit successfully inconceivable (you’ll see), arithmetic and physics.

Odds are, should you’ve labored with an everyday pendulum, you’re a minimum of considerably acquainted with the double pendulum, which is harking back to the notorious three-body problem. The three-body downside represents the concept that an analytical answer to the movement of three our bodies in a system the place all our bodies’ forces have an effect on one another is inconceivable to resolve, for the reason that forces of every physique work together with the others concurrently. Briefly, the double pendulum is inconceivable to resolve analytically. When it comes to the pendulum equations acknowledged above, the one that you simply actually can’t clear up is the equation for θ, or the angular displacement of each pendulums. You additionally can’t clear up for the interval, however that’s largely as a result of a double pendulum doesn’t precisely have an everyday interval. Under is a visible illustration of the double pendulum system we’ve mentioned, the place the pivot level is anchored to the wall, the angles are marked with θ1 and θ2, and the hanging plenty are marked m1 and m2.

To reiterate– in our present physics, we can’t predict the movement of a double pendulum analytically. However why? Properly, the movement is just not merely random, however fairly chaotic. How will we show that chaotic and random aren’t the identical? That’s the query we are going to search to reply afterward.

You’ve seemingly seen some YouTube title about chaos or Chaos Theory, and I’m keen to wager the thumbnail picture appeared one thing like this:

That picture, together with many different butterfly wing-esque drawings, are mostly related to chaos concept. One thing not generally regarded as a part of chaos concept is the double, triple, and every other pendulum with a couple of arm. Let’s discover a few of the properties of chaotic movement and attempt to be taught extra about it as greatest we are able to, with assist from a pc program that we’ll dive into later.

One property we are able to examine is the impact that making a small change in beginning situations has on the top end result. Will the change be negligible in the long run, or will it yield a solution completely end result from the unique?Under is a pc simulation of a double pendulum at t=50, the place the beginning angles have been 80° and 0° respectively for θ1 and θ2. (Angles are the identical as proven within the diagram above)

Now, let’s run the actual identical simulation, the picture is of t=50, all of the plenty and arm lengths are utterly an identical. Nevertheless, the angles are 79° and 0° for θ1 and θ2. There’s a 1° change within the beginning worth of θ1, let’s see the way it impacts the end result.

Unsurprisingly (or surprisingly, I don’t know what you anticipated), with a change of simply 1° the system has dramatically modified to the purpose the place the ultimate place of the system and the road traced by it don’t resemble the primary picture in any respect. That’s impartial of any outdoors variables, as in our simulation there isn’t a friction, air resistance, or every other hindrances. This instance exhibits the concept that when a system reveals chaotic movement, as in a double pendulum, even probably the most minute change in situations may cause an infinite change within the end result.

So, we’ve nailed down one fascinating facet of chaotic movement– a tiny change in beginning situation may cause an infinite change in end result. Let’s attempt to establish just a few extra. What would occur if we have been to run the identical double pendulum experiment once more? Experimentally, that is all however inconceivable; it could contain having an infinite diploma of precision when measuring issues like gravitational subject, mass, air resistance, and each single different variable within the experiment, after which utilizing your magical infinite precision knowledge to arrange the experiment once more, identically. We, nonetheless, have a pleasant simulation to make use of which makes that problem disappear.

Let’s run the double pendulum simulation much like earlier than, however with some variables modified so the picture isn’t the identical: t=50, θ1=80°, θ2=15°, and the bodily properties of the pendulum are the identical (size, mass). Right here is the end result:

Spoiler alert, it was the very same the second time… And the third, fourth fifth, and sixth time. Simply to show some extent, let’s additionally do that train with a triple pendulum. We’ll use the identical beginning situations, though now we have now a 3rd angle, θ3, so we’ll use θ1=80°, θ2=15°, θ3=0°. A triple pendulum is rather more computationally intensive, although, so the picture might be taken at t=10.

Though it’s much more complicated than the double pendulum simulation, the truth that the triple pendulum reveals the identical tendency to repeat its sample beneath an identical beginning situations is essential. That concept of an an identical end result beneath an identical situations proves that chaotic movement and chaotic methods are deterministic, thus not random. Once more, since that is so onerous to show experimentally or use in observe it doesn’t have an effect on our understanding of the true world very a lot. We do, nonetheless, now know that chaotic methods should not random and could be predicted with the best information. Moreover, since we proved {that a} small change can have a big impact, we all know that an extremely excessive diploma of precision is required to successfully predict the end result of a chaotic system.

We’ve now recognized two vital properties of chaotic movement: the primary is {that a} tiny change can have enormous implications within the end result of the system, and the second is that chaotic movement is just not random however fairly it’s deterministic. Let’s attempt to discover yet one more– as we mentioned on the very starting of the article, the variable you actually can’t clear up for in a double pendulum is the angular displacement. Nevertheless, we additionally stated that fixing for interval was futile as a result of a double pendulum doesn’t repeat– let’s take a look at that concept.

First, let’s run the double pendulum experiment with the next situations: θ1=30°, θ2=30°, with the identical plenty and lengths as earlier than. This time, let’s use VPython’s graphing capabilities to file a chart of the peak of the underside mass as a perform of time:

When you ask me, that appears fairly periodic. So, does this imply that the system described above is just not a chaotic system? And if the movement is just not chaotic, does that imply we might attain an analytical answer to the movement of the double pendulum when it has lower than some threshold power wanted to develop into chaotic? I’ll go away that as an train to the reader. To try this although, you would possibly want the assistance of this system I wrote and used on this article, so let’s stroll via it. This program is written in VPython utilizing GlowScript, so ensure that you’re operating it on the WebVPython system, and never simply any python editor.

First, let’s outline the bodily constants we’ll use in this system. These embrace the plenty, lengths of arms, and drive of gravity. Moreover, we’ll outline the beginning situations of the system, the place theta1 and theta2 are the beginning angles, and theta1dot and theta2dot are the beginning angular velocities of the arms. Lastly we’ll additionally set the beginning time to 0, and outline dt, which is the period of time we’ll step forwards in every iteration of our loop later.

#lengths of the strings
L1 = 1.5 #high string
L2 = 1 #center string
#plenty
M1 = 2 #high transferring ball
M2 = 1 #center transferring ball
#g
g = 9.8
#beginning angles and velocities
theta1=30*pi/180 #launch angle high ball
theta2= 30*pi/180 #launch angle center ball
theta1dot = 0
theta2dot = 0
t = 0
dt = 0.001

Subsequent we outline all of the components of our system, the pivot level, mass 1 (m1), arm 1 (stick1), and the identical for the second set of mass and stick (m2, stick2).

pivot = sphere(pos=vector(0,L1,0), radius=0.05)
m1 = sphere(pos=pivot.pos-vector(0,L1,0),radius=0.05,shade=shade.white)
stick1 = cylinder(pos=pivot.pos,axis=m1.pos-pivot.pos,radius=0.015,shade=shade.yellow)
m2 = sphere(pos=m1.pos-vector(0,L2,0),radius=0.05,shade=shade.white)
stick2 = cylinder(pos=m1.pos, axis=m2.pos-m1.pos, radius=0.015,shade=shade.yellow)

Now we place the plenty and sticks in order that they replicate the beginning angles, as should you ran the code earlier than it could simply be two vertical rods. To do that we simply use some trigonometry to place the mass the top of the place the stick will go, then set the follow go the space between every mass. Right here we additionally use VPython’s ‘attach_trail’ technique to make the underside mass generate a path.

m1.pos = pivot.pos+vector(L1*sin(theta1),-L1*cos(theta1),0)
m2.pos = m1.pos+vector(L2*sin(theta2),-L2*cos(theta2),0)
stick1.axis = m1.pos - pivot.pos
stick2.pos = m1.pos
stick2.axis = m2.pos - m1.pos
attach_trail(m2, retain=200, shade=shade.pink)

Subsequent we start the primary loop of our program; on this simulation, as in lots of physics simulations we’ll use some time loop with an exit situation at t=50. We’ll additionally use the the speed() technique to set the pace that this system will run at.

whereas t <= 50:  
charge(1000)

Now we have now to dive into the true math. We’ll use a little bit of calculus (not likely, however we do take care of derivatives), trigonometry, and algebra to first calculate the angular acceleration, which we are going to then use to increment the angular velocity, after which apply that angular velocity to the place of the plenty and rods to maneuver them in line with their calculated accelerations.

To calculate the highest mass’s acceleration, let’s use this method to signify the angular acceleration, or second spinoff of θ1:

You too can signify the identical equation utilizing the next code:

theta1ddot = (-g*(2*M1 + M2)*sin(theta1) -M2*g*sin(theta1 -2*theta2)-2*sin(theta1 - theta2)*M2*(L2*theta2dot**2 + L1*cos(theta1 - theta2)*theta1dot**2))/(L1*(2*M1 + M2 - M2*cos(2*theta1 -2*theta2)))

For the second mass’s acceleration, we should use a distinct method because it represents a distinct a part of the system.

That equation is written in this system as:

theta2ddot = (2*sin(theta1 - theta2)*((M1 + M2)*L1*theta1dot**2 + g*(M1 + M2)*cos(theta1) + L2*M2*cos(theta1 - theta2)*theta2dot**2))/(L2*(2*M1 + M2 - M2*cos(2*theta1 -2*theta2)))

Subsequent let’s increment the variables for angular velocity, ‘theta1dot’ and ‘theta2dot.’ To do that we merely use the equation under, which increments the angular velocity by the angular acceleration instances dt. Though the picture solely states the equation for theta1dot, it’s the identical for each θ1 and θ2.

Let’s signify this with code for our functions:

theta1dot = theta1dot + theta1ddot*dt
theta2dot = theta2dot + theta2ddot*dt

For the ultimate a part of our calculations for the movement of the double pendulum should increment the angles θ1 and θ2 by the angular velocity. That is represented by the equation under, the place we set the angle θ equal to the earlier θ plus the angular velocity instances dt. Once more, the calculation is the very same for θ1 and θ2.

In code, we write the equation as:

theta1 = theta1 + theta1dot*dt
theta2 = theta2 + theta2dot*dt

Now we should replace the place of the plenty and the rods in this system, in order that we are able to see the end result of this system. First we are going to replace the place of the plenty. We’ll take an intuitive strategy to updating these positions; since one factor that may by no means change within the system is the size of the rods, the center mass (m1) might be a distance equal to L1 away from the pivot level. Logically we are able to then assemble the next equation for the place of mass m1:

The identical method can be utilized to replicate the method for the place of m2, solely with θ2 and L2, and it’s primarily based off of the place of m1, not the pivot. See this equation under.

These two formulation are written in our program very merely, since one function of VPython is that it makes vector calculations quite simple. All objects have already got their positions saved as vectors, so all you should do is use the vector() technique to outline a brand new vector, and use it in your computation.

m1.pos = pivot.pos + vector(L1*sin(theta1),-L1*cos(theta1),0)
m2.pos = m1.pos + vector(L2*sin(theta2),-L2*cos(theta2),0)

Now we should take one remaining step to understand the end result of our calculations by updating the place of the rods. Technically this isn’t completely essential, because the plenty will nonetheless present and observe the sample they need to. For visible impact although, let’s write this code. The mathematics isn’t too fascinating, so the code is as follows. First we set the axis of the primary stick in order that it fills the space between the pivot level and mass m1. Subsequent, we set the second stick’s place equal to mass m1. Lastly, we set the axis of the second stick equal to the space between the primary and second mass. The ultimate line is incrementing t by dt to make this system go forwards.

stick1.axis = m1.pos - pivot.pos
stick2.pos = m1.pos
stick2.axis = m2.pos - m1.pos
t += dt

Right here is the ultimate code for ease of copying and pasting:

Internet VPython 3.2
#lengths of the strings
L1 = 1.5 #high string
L2 = 1 #center string
#plenty
M1 = 2 #high transferring ball
M2 = 1 #center transferring ball
#g
g = 9.8
t = 0
dt = 0.001
#beginning angles and velocities
theta1=80.5*pi/180 #launch angle high ball
theta2= 0*pi/180 #launch angle center ball
theta1dot = 0
theta2dot = 0
pivot = sphere(pos=vector(0,L1,0), radius=0.05)
m1 = sphere(pos=pivot.pos-vector(0,L1,0),radius=0.05,shade=shade.white)
stick1 = cylinder(pos=pivot.pos,axis=m1.pos-pivot.pos,radius=0.015,shade=shade.yellow)
m2 = sphere(pos=m1.pos-vector(0,L2,0),radius=0.05,shade=shade.white)
stick2 = cylinder(pos=m1.pos, axis=m2.pos-m1.pos, radius=0.015,shade=shade.yellow)
m1.pos = pivot.pos+vector(L1*sin(theta1),-L1*cos(theta1),0)
m2.pos = m1.pos+vector(L2*sin(theta2),-L2*cos(theta2),0)
stick1.axis = m1.pos - pivot.pos
stick2.pos = m1.pos
stick2.axis = m2.pos - m1.pos
attach_trail(m2, retain=200, shade=shade.pink)
eChart = gdisplay(x=500, y=0, width=600, top=400, title="", xtitle="", ytitle="", foreground=shade.black, background=shade.white)
ePlot = gdots(shade=shade.pink)
whereas t < 50:  
charge(1000)
#angular acceleration
theta1ddot = (-g*(2*M1 + M2)*sin(theta1) -M2*g*sin(theta1 -2*theta2)-2*sin(theta1 - theta2)*M2*(L2*theta2dot**2 + L1*cos(theta1 - theta2)*theta1dot**2))/(L1*(2*M1 + M2 - M2*cos(2*theta1 -2*theta2)))
theta2ddot = (2*sin(theta1 - theta2)*((M1 + M2)*L1*theta1dot**2 + g*(M1 + M2)*cos(theta1) + L2*M2*cos(theta1 - theta2)*theta2dot**2))/(L2*(2*M1 + M2 - M2*cos(2*theta1 -2*theta2)))
#angular velocity
theta1dot = theta1dot + theta1ddot*dt
theta2dot = theta2dot + theta2ddot*dt
#angular place
theta1 = theta1 + theta1dot*dt
theta2 = theta2 + theta2dot*dt
m1.pos = pivot.pos + vector(L1*sin(theta1),-L1*cos(theta1),0)
m2.pos = m1.pos + vector(L2*sin(theta2),-L2*cos(theta2),0)
stick1.axis = m1.pos - pivot.pos
stick2.pos = m1.pos
stick2.axis = m2.pos - m1.pos
t = t+dt

Thanks for making it this far, I hope you loved my evaluation of chaotic movement via the double and triple pendulums. In the long run, I’m neither knowledgeable physicist nor programmer, so in case you have options for the way I can enhance my work please don’t hesitate to let me know.

Moreover, all imaged used within the article have been created by me, utilizing Python and Microsoft Phrase, each of which have unbelievable capabilities.

Lastly, I’d like to finish on a chewy thought, which is able to play into my subsequent undertaking. When you took a multi-armed pendulum which was already experiencing chaotic movement, how would its movement change should you have been to seamlessly add one other arm of very excessive mass (perhaps 50x the biggest already in a system), at a beginning θ of 0°?