__The Curvature of
Spinning, Translating Rods__

** Abstract.**
Any rod-shaped
object, spinning around the origin of its center's rest frame, K, will be curved from the perspective of
moving frame K’. This can be demonstrated using the Lorentz
transformations.

If we consider the object lying along the x-axis in K at time t=0, we can easily transform the coordinates to K’ using the standard Lorentz transformation. For example, if we divide the object into 100 parts in K, then from the perspective of K each part will lie on the x’-axis in K’. However, from the perspective of K, the momentarily coincident K’ clocks will all be observed to have different times. We would like to know where the parts were when the K’ clocks all read t’=0. Knowledge of those coordinates will collectively specify the object’s shape in K’ at t'=0.

If the object is at rest in K, then the transformation is straightforward. At time t=0 the object is found to lie all along the x’-axis in K’. It is length contracted and traveling toward –x’.

If, however, the object is * spinning* in
K, then we must "creep up" to each part’s
position in K’. The iterations in such a creeping-up exercise are best
performed on a computer. The steps in the creeping-up algorithm are as follows:

*1. Compute
each part’s x, y, v _{x},
v_{y}, a_{x}, a_{y} at
time t=0 by using the part’s motion in K.
*

2. Transform t to t’.

3. Divide the initial t’ into M incremements, where M is suitably large (say M=10,000). Call each increment dt’.

*
4. Transform x,
y, v _{x}, v_{y}, a_{x}, a_{y} into
x’, y’, v_{x}’, v_{y}’, a_{x}’, a_{y}’*

5. Compute x’ and y’ a time dt’
later by assuming that **a**’
is constant over that short increment of time.

6. Add dt’ to t’.

7. Transform t’ back to t, but using t in lieu of t=0.

8. Iterate to Step 1.

9. After M iterations, save x’ and y’ for plotting purposes.

10. Repeat for every other part.

11. Plot y’ vs. x’ to see the object’s shape in K’ at the single instant t’=0.

Appendix A of this article contains the relevant transformations. Appendix B contains the Visual Basic code that implements the algorithm. A few of the x’y’ plots are included below. Note in each case that the y’-axis is scaled so that the curvature is evident on inspection. In general u, the speed of K’ relative to K, determines the amount of length contraction in K’. w, the angular spin rate of the object around the origin of K, determines the amount of curvature.

__Figure 1
__

u = 5 m/sec, w = 0/sec

Figure 2

u = .99c, w = 0/sec

Figure 3

u = .99c, w = 60,000,000/sec

*** Appendix A ***

Lorentz Transformations

__t’ = g(t
– ux / c__^{2})

x’ = g(x – ut)

y’ = y

v_{x}’ = (v_{x} –
u) / (1 – uv_{x}/c^{2})

v_{y}’ = v_{y} / g /
(1 – uv_{x}/c^{2})

a_{x}’ = a_{x} / g^{3} /
(1 – uv_{x}/c^{2})^{3}

a_{y}’ = a_{y} / g^{2} /
(1 – uv_{x}/c^{2})^{2} +
uv_{y}a_{x} / g^{2}c^{2} /
(1 – uv_{x}/c^{2})^{3}

*** Appendix B ***

Visual Basic Code for Computing y’ vs. x’ at t’=0

Option Explicit

Private Sub cmdTransform_Click()

Const c As Double = 300000000#

Const u As Double = 5

'Const u As Double = 0.99 * c

Const L As Double = 1

'Use this value of omega to compute curvature.

'Const omega As Double = 0

Const omega As Double = 5

'Const omega As Double = 60000000

Const N As Long = 100 'Number of parts in rod

Const M As Long = 10000# 'Number of dtprimes

Const deltax As Double = L / N 'Length of part

Dim xp(N) As Double 'xprime coordinates of parts

Dim yp(N) As Double 'yprime coordinates of parts

Dim t As Double 'K time

Dim x As Double 'K kinematic variables

Dim y As Double

Dim vx As Double

Dim vy As Double

Dim ax As Double

Dim ay As Double

Dim gamma As Double

Dim tp As Double 'Kprime time

Dim deltatp As Double

Dim dtp As Double 'Incremental period for updating Kprime coords.

Dim vxp As Double 'Kprime kinematic variables

Dim vyp As Double

Dim axp As Double

Dim ayp As Double

Dim MIndex As Long

Dim NIndex As Long

Dim hypot As Double 'Triangle hypotenuse

gamma = 1 / Sqr(1 - u ^ 2 / c ^ 2)

'For each part of the rod ...

For NIndex = 0 To N - 1

Debug.Print NIndex

t = 0 'Initial time

'...Compute the K space coords;

hypot = (NIndex + 1 / 2) * deltax

x = hypot

y = 0

'compute the amount of Kprime time you must work through

deltatp = -gamma * (t - u * x / c ^ 2)

dtp = deltatp / M

'Then for each part...

For MIndex = 0 To M - 1

'...Compute the K variables;

x = hypot * Cos(omega * t)

y = hypot * Sin(omega * t)

vx = -omega * y

vy = omega * x

ax = -omega ^ 2 * x

ay = -omega ^ 2 * y

'Transform the K variables to Kprime variables

tp = gamma * (t - u * x / c ^ 2)

xp(NIndex) = gamma * (x - u * t)

yp(NIndex) = y

vxp = (vx - u) / (1 - u * vx / c ^ 2)

vyp = vy / gamma / (1 - u * vx / c ^ 2)

axp = ax / gamma ^ 3 / (1 - u * vx / c ^ 2) ^ 3

ayp = ay / gamma ^ 2 / (1 - u * vx / c ^ 2) ^ 2 + u * vy * ax / c ^ 2 / gamma ^ 2 / (1 - u * vx / c ^ 2) ^ 3

'Compute follow-on Kprime variables (assuming constant acceleration)

xp(NIndex) = xp(NIndex) + vxp * dtp + 1 / 2 * axp * dtp ^ 2

yp(NIndex) = yp(NIndex) + vyp * dtp + 1 / 2 * axp * dtp ^ 2

tp = tp + dtp

'update K time and iterate.

t = gamma * (tp + u * xp(NIndex) / c ^ 2)

Next MIndex

Next NIndex

'Output the Kprime x and y coordinates for plotting.

Open "c:\WINMCADC\Physics\Spinner.PRN" For Output As #1

For NIndex = 0 To N - 1

Write #1, xp(NIndex), yp(NIndex)

Next NIndex

Close

MsgBox ("Ready for plotting")

Stop

End Sub