Browse by Topic

# Simulating Zero Gravity to Demonstrate the Dzhanibekov Effect and Other Surprising Physics Models

Explore the contents of this article with a free Wolfram System Modeler trial. Wolfram System Modeler 12.2 was just released, featuring things such as personalization of plots, new model libraries and extended GUI support for advanced modeling. One of the other additions is a new workflow for generating 3D models from 3D shapes. We will use this feature to illustrate some bizarre and counterintuitive physics.

In 1985, cosmonaut Vladimir Dzhanibekov had been tasked with rescuing the Salyut 7 space station. He unpacked supplies sent from Earth, which were locked down with a wingnut. When the wingnut spun off the bolt, he noticed how the wingnut maintained its orientation for a short time, and then it flipped 180 degrees. This “Dzhanibekov effect,” or tennis racket theorem, had been known for at least 150 years, but for most of us, it still defies common sense. What causes this effect, and can we repeat the behavior?

We need zero gravity to duplicate it, which is hard to accomplish for most of us. However, it’s easy to do with System Modeler, so let’s perform a virtual experiment.

First, we need the geometry of a wingnut. Almost any CAD model of a wingnut will work, and in this case, we will use a gigantic wingnut with a Spikey on it. It’s about 30 meters in diameter—since we will perform this experiment in space, we might as well go big:

Now let’s use the new functionality to create a system model from this shape:

 ✕ `CreateSystemModel["Wingnut", wingnut];`

That’s it! We now have a model that not only has the desired shape, but also the needed physical properties, including inertias, center of mass and density. We just need to put it in space and give it an initial movement to test the Dzhanibekov effect. We will initialize the wingnut with a translational velocity of 2 meters per second and an angular velocity of 10 radians per second:

 ✕ ```ConnectSystemModelComponents["DzhanibekovEffect", {"wingnut" \[Element] "Wingnut", "world" \[Element] "Modelica.Mechanics.MultiBody.World"}, {}, <|"ParameterValues" -> {"world.g" -> 0}, "InitialValues" -> {"wingnut.body.v_0" -> {0, 2, 0}, "wingnut.body.w_a" -> {0, 10, 0}}|>];```

Of course, you can do this graphically in Model Center too, as shown in this video.

With the model ready, we can now simulate:

 ✕ `simWingnut = SystemModelSimulate["DzhanibekovEffect", 30];`

As there are no external forces, one might expect that velocities should remain constant—but do they? Let’s start by looking at the velocities:

 ✕ ```SystemModelPlot[simWingnut, {"wingnut.body.v_0[1]", "wingnut.body.v_0[2]", "wingnut.body.v_0[3]"}]```

As expected, they stay constant, but now let’s look at the angular velocities:

 ✕ ```SystemModelPlot[simWingnut, {"wingnut.body.w_a[1]", "wingnut.body.w_a[2]", "wingnut.body.w_a[3]"}]```

It is easier to see what’s actually happening with an animation:

 ✕ ```SetSystemModel[ "DzhanibekovEffect", <| "SimulationSettings" -> {"StopTime" -> 30}|>]; SystemModeler["DzhanibekovEffect", "Animation"]```

That’s exactly the bizarre effect that Dzhanibekov observed in 1985! As we are not applying any external forces at all, this effect is—at least for most of us—counterintuitive. What is it caused by? When creating the model from the CAD shape, corresponding inertias were calculated automatically. Let us take a look at them:

 ✕ ```simWingnut["wingnut.body.I_11"] simWingnut["wingnut.body.I_22"] simWingnut["wingnut.body.I_33"]```

They are all different, which together with a small disturbance (in this case, a small numerical disturbance) is actually what causes the effect.

Whether the object will start flipping or not depends on which axis we are rotating around. Let’s take a look at a space shuttle and how it behaves depending on the initial axis or rotation, and trace three different points of the shuttle using System Modeler’s Simulation Center:

When rotating around the x and z axes, the shuttle behaves as expected, but rotating around y and y-z, it starts to flip in the same bizarre way as the wingnut. When the space shuttle is spun around the axis with either the largest or smallest moment of inertia, the spin is stable. However, when spun around an intermediate axis, where the moment of inertia is in between these two, the flipping behavior starts. That’s why this effect is also called the intermediate axis theorem.

If you have a tennis racket or similar, you can actually easily test it at home. Or you can create a racket in the Wolfram Language and test it in System Modeler:

 ✕ ```pingpongRacket = Region[RegionUnion[{Cylinder[{{0, 0, 0}, {0.10, 0, 0}}, 0.015], Cylinder[{{0.18, 0, 0}, {0.18, 0.005, 0}}, 0.09], Cylinder[{{0.18, -0.005, 0}, {0.18, 0, 0}}, 0.09]}]]```

We can now set this into action. In this case, we will stay on Earth, i.e. keep gravity on:

 ✕ ```CreateSystemModel["PingpongRacket", pingpongRacket]; ConnectSystemModelComponents["TennisRacketTheorem", {"pingpongRacket" \[Element] "PingpongRacket", "world" \[Element] "Modelica.Mechanics.MultiBody.World"}, {}, <|"InitialValues" -> {"pingpongRacket.body.v_0" -> {0, 5, 0}, "pingpongRacket.body.w_a" -> {0, 0, 30}}|>]; SystemModeler["TennisRacketTheorem", "Animation"]```

If you look carefully, you can see how the racket flips. Yet again, this is caused when rotating around the intermediate axis when an object has three different moments of inertia.

So, does this mean that there’s no problem if we have a symmetric object, i.e. if we do not have an intermediate axis? Actually, no. As it turns out, space is a great place to study simple but counterintuitive effects.

When the US launched its first satellite, Explorer 1, on January 31, 1958, it learned this the hard way. The satellite was designed to spin around its long axis and had four flexible antennas, as seen in the following picture:

Image from Wikipedia

It looked great to begin with, but within hours it flipped and started to spin end over end. As opposed to our previous examples, the satellite never flipped back again; instead it was stuck in this undesired spin. How come?

In order to test this, we created a very simple model of the satellite using a cylinder as a body and then attaching four antennas (smaller cylinders) to the satellite using joints with spring dampers:

A simulation of the system replicated the behavior of Explorer 1—just faster, as we have exaggerated some settings:

So why did this happen? The spring damper system will add loss to the system. This means that the satellite will seek to spin around the axis that achieves the minimum amount of kinetic energy, i.e. the one with the largest amount of moment of inertia—in other words, when it’s rotating end over end.

To conclude, this simple example of a wingnut behaving completely counterintuitively is a great illustration of how system models can be used to test and understand the behavior of dynamic systems, hopefully finding better solutions at an earlier stage of the design process.

## Reference

This blog was inspired by this YouTube video.

 Visit the Wolfram System Modeler Documentation Center to explore and see what’s new in the latest release or try a free trial of System Modeler.