Sagnac gyroscope affected by linear acceleration?

[KDP]

TL;DR Summary

A simulation seems to show that a Sagnac gyroscope can be affected by purely linear constant proper acceleration. Is this correct?

As some of you know I have been coding a 2+1D relativistic simulator that can handle (constant proper) acceleration in any direction on a plane. So far it is going quite well.

I have now decided to simulate a Sagnac gyroscope inside the simulation by sending signals in opposite directions around the square object and comparing the difference in return times of the signals. To my surprise it seems that a Sagnac gyroscope can be affected by purely linear acceleration unless the emitter and the centre of the Sagnac loop both lie on a line that is parallel to the linear acceleration. This is not ideal if the gyroscope is intended to measure rotation only, as it requires knowing or measuring the linear acceleration in order to calculate the rotation from the difference in the return times of the counter rotating signals.

This would require having to use a separate device that only measures linear acceleration in conjunction with a Sagnac gyroscope, so that the rotation can be calculated. Alternatively two Sagnac gyroscopes that are aligned with their emitters orthogonal to each other can be used, as the linear acceleration can be calculated by comparing the time differences on the two orthogonal gyroscopes. Is my conclusion correct or do I need to continue looking for bugs in my coding?

P.S. Would I be correct in thinking an ideal traditional flywheel gyroscope is not affected by linear acceleration?

 

[Dale]

I don't think a Sagnac interferometer is sensitive to linear acceleration, just rotation.

 

[Ibix]

Obvious question: did you remember that the different parts of the gyro have different proper accelerations?

I'll check a simple case later - the maths for two mirrors and an emitter in an arbitrary triangle looks not too bad.

 

[KDP]

Obvious question: did you remember that the different parts of the gyro have different proper accelerations?

Yes, my simulation animates simple squares and takes account of the fact that all 4 corners may have different proper accelerations, even though the object as whole is maintaining Born rigid motion and reproduces the expected Wigner rotation angle when two non parallel boosts are carried out. That aspect is baked into the heart of the simulation algorithm.

 

[Dale]

Did you account for the fact that the light path is curved (even though the edges are straight)?

 

[KDP]

I don't think a Sagnac interferometer is sensitive to linear acceleration, just rotation.

Just to be clear, I am talking about a pure theoretical Sagnac gyroscope and not a military/NASA grade gyroscope that may have electronic devices and correction software to correct for things like linear acceleration.

 

[KDP]

Did you account for the fact that the light path is curved (even though the edges are straight)?

I am assuming that the light path travels through free space (uncurved - no gravity) from the emitter or mirror to the next mirror is a straight line and does not care about the edges of the object. (One emitter/receiver and 3 mirrors). I am talking about the point of view of an inertial non rotating observer watching the assembly accelerate/rotate. Of course, if the two counter going signals return to the same place at the same time, this is true in all reference frames, inertial or otherwise.

 

[Dale]

I am assuming that the light path travels through free space (uncurved - no gravity) from the emitter or mirror to the next mirror is a straight line and does not care about the edges of the object.

Oh, I was thinking of a fiber optic square. I guess that probably doesn’t matter

 

[pervect]

TL;DR Summary: A simulation seems to show that a Sagnac gyroscope can be affected by purely linear constant proper acceleration. Is this correct?

As some of you know I have been coding a 2+1D relativistic simulator that can handle (constant proper) acceleration in any direction on a plane. So far it is going quite well.

I have now decided to simulate a Sagnac gyroscope inside the simulation by sending signals in opposite directions around the square object and comparing the difference in return times of the signals. To my surprise it seems that a Sagnac gyroscope can be affected by purely linear acceleration unless the emitter and the centre of the Sagnac loop both lie on a line that is parallel to the linear acceleration. This is not ideal if the gyroscope is intended to measure rotation only, as it requires knowing or measuring the linear acceleration in order to calculate the rotation from the difference in the return times of the counter rotating signals.

This would require having to use a separate device that only measures linear acceleration in conjunction with a Sagnac gyroscope, so that the rotation can be calculated. Alternatively two Sagnac gyroscopes that are aligned with their emitters orthogonal to each other can be used, as the linear acceleration can be calculated by comparing the time differences on the two orthogonal gyroscopes. Is my conclusion correct or do I need to continue looking for bugs in my coding?

P.S. Would I be correct in thinking an ideal traditional flywheel gyroscope is not affected by linear acceleration?

The only way I can imagine acceleration affecting a sagnac interferometer (ring laser gyroscope) or a conventional spinning gyroscope is if the linear acceleration causes rotation via Thomas precession. I would expect that the ring laser gyroscope and the spinning gyroscope would obey the same physics.

IIRC Thomas precession happens if the cross product of acceleration and velocity is non-zero, from memory. Wiki confirms this, see https://en.wikipedia.org/wiki/Thomas_precession, the Thomas precession is proportional to the cross product of acceleration and velocity multiplied by some function of velocity

Thus, if you're talking about linear acceleration in a constant direction, there should be no such effect as a and v should always point in the same direction. If you are talking about linear accelration that varies in direction, Thomas precession would apply.

[add]
Actually, I suppose I have some concerns about a constant coordinate acceleration, rather than a constant proper acceleration. This wouldn't actually cause rotation in the sense of a non-zero vorticity tensor, but it would cause shear, which would mean that the dimensions of your "loop" were not actually constant, as it wasn't a rigid motion. Apologies if you're not familiar with shear and vorticity, I'm not sure how to say what I'm thinking without using these terms. The concern here is that your acceleration profile is a rigid motion, basically. See for instance "Bell's spaceship paradox" for why constant coordinate accerleation is not a rigid motion.

 

[Ibix]

I've done some analysis for the free space ring-of-mirrors and I get that (plus or minus rounding error) the results are the same.

Under Born rigid linear acceleration, all components of the interferometer follow hyperbolae. I choose to work in the frame where the interferometer is accelerating in the $+x$ direction and the centers of all the hyperbolae lie along the $y$ axis. In this frame the interferometer is instantaneously at rest at $t=0$, and a component of the interferometer that is at $x=x_0$ at $t=0$ has proper acceleration $a=1/x_0$, and its $x$ position at time $t$ is given by $$\begin{align}x=\sqrt{x_0+t^2}\end{align}$$The algebra is messy (I got Maxima to do it for me - see code below) but it's straightforward to show that if you emit a light pulse at $x_e, y_e$ and time $t_e$ then it catches up with a component that started at $x_0,y_0$ at time$$
\begin{align}t={{{x_e}\sqrt{{x_e}^4+\left(-2x_{0}^2-2{t_e}^2+2 {(y_0-y_e)}^2\right){x_e}^2+x_{0}^4+\left(2{t_e}^2+2 {(y_0-y_e)}^2\right)x_{0}^2+{t_e}^4-2{(y_0-y_e)}^2{t_e}^2+ {(y_0-y_e)}^4}+{t_e}{x_e}^2+{t_e}x_{0}^2-{t_e}^3+ {(y_0-y_e)}^2{t_e}}\over{2{x_e}^2-2{t_e}^2}}\end{align}$$Here's a Minkowski diagram to illustrate the path of a component of the interferometer (red) being intercepted by a light pulse (yellow) emitted from some event. As drawn $y_0=y_e$ and the $y$ dimension is suppressed, but this is not generally the case.

Now all you need to do is list the components' starting positions, choose one as the emitter, use (2) and (1) to compute the coordinates of the pulse reaching the next component, then use these as the new emission coordinates and calculate the arrival time at the next component.

I wrote some python code to automate that. I've tested it with a couple of configurations, but feel free to mess around. Each component of the interferometer is specified by a three-element tuple containing a name and its initial $x$ and $y$ components. Make a list of such 3-ples and pass it to the analyse function (initial $x$ positions must be >0). It'll list the arrival time at each component in forward and reverse order - check that the final times are the same.

Here's the Maxima code to get (2):

x:sqrt(x0^2+t^2);
solve((t-te)^2=dy^2+(x-xe)^2,sqrt(x0^2+t^2));
solve(%[1]^2,t);
interceptT:%[1];  /* Yes, [1], I checked */

And here's the python to execute it, set up with a scalene triangle interferometer:

# Simulates a Sagnac interferometer undergoing constant proper acceleration.
# Wlog, we can choose to work in the frame where the acceleration is in the
# +x direction and the center of all the hyperbolae lies at x=0 and all the
# interferometer components were instantaneously at rest at t=0. (Note that
# this means that an interferometer component that was at x=x0 at time zero
# accelerates with proper acceleration 1/x0 to achieve Born-rigid motion.)
#
# All calculations are carried out in this frame. All x/y/t values are
# coordinates in this frame.

def x(x0, t):
    """x position of interferometer component that had x = x0 at t = 0."""
    return (x0**2 + t**2)**0.5

def t(x0, y0, xe, ye, te):
    """Calculates the time at which a flash of light emitted at x=xe, y=ye at
    time t=te and reaches an interferometer component that was at x=x0, y=y0
    at time t=0."""
    dy = y0-ye
    return (xe*(xe**4+2*(dy**2-x0**2-te**2)*xe**2+x0**4+(2*te**2+2*(y0-ye)**2)*x0**2+te**4-2*(y0-ye)**2*te**2+(y0-ye)**4)**0.5+te*xe**2+te*x0**2-te**3+(y0-ye)**2*te)/(2*xe**2-2*te**2)

def computeTime(componentList):
    """Takes a list of interferometer component [label, x0, y0] values and
    returns a list of labels and times a light pulse travelling round the
    interferometer reaches each component assuming it was emitted at t=0"""
    componentList = list(componentList)
    label, xe, ye = componentList[0]
    te = [(label, 0)]
    for component in componentList[1:]+[componentList[0]]:
        label, x0, y0 = component
        te.append((label, t(x0, y0, xe, ye, te[-1][1])))
        xe = x(x0, te[-1][1])
        ye = y0
    return te

def analyse(componentList):
    """Display the arrival times at each component in forward and reverse
    order"""
    labelWidth = max(len(c[0]) for c in componentList) + 2
    reversedList = [componentList[0]] + list(componentList[-1:0:-1])
    print("Loop forward:")
    for ci, ti in computeTime(componentList):
        print("  " + str(ci) + " "*(labelWidth-len(ci)) + str(ti))
    print("Loop reverse:")
    for ci, ti in computeTime(reversedList):
        print("  " + str(ci) + " "*(labelWidth-len(ci)) + str(ti))

# A tuple of [name,x0,y0] values defines the interferometer loop
# All x0 values must be >0
components =    ["Emitter",  1,  1], \
                ["Mirror 1", 2,  6], \
                ["Mirror 2", 3, -1]
analyse(components)

 

[KDP]

I've done some analysis for the free space ring-of-mirrors and I get that (plus or minus rounding error) the results are the same.

Wow, that was fast work! I will have to see if I can reproduce your 3 point interferometer in my simulator and see if I can discover why we differ. Thanks for the great input!

 

[KDP]

[add]
Actually, I suppose I have some concerns about a constant coordinate acceleration, rather than a constant proper acceleration. .... See for instance "Bell's spaceship paradox" for why constant coordinate accerleation is not a rigid motion.

I am basically using this equation:
$$ X(T)~ = ~\frac{ 1 }{\alpha } \left( \sqrt{ 1+\left( \alpha ~ T \right)^2 } - 1 \right), ~~~~~~~~_{(Eq1)}$$
where alpha is the constant proper acceleration and proportional to 1/x at time T=0.

 

[Ibix]

Wow, that was fast work! I will have to see if I can reproduce your 3 point interferometer in my simulator and see if I can discover why we differ. Thanks for the great input!

My program can handle arbitrarily many components - just add a fourth [name,x,y] triple to components, or even a fifth if you want four mirrors and a source.

 

[KDP]

My program can handle arbitrarily many components - just add a fourth [name,x,y] triple to components, or even a fifth if you want four mirrors and a source.

Thanks Ibix. That's handy! I copy and pasted your code into an online Python compiler and its working great.

 

[KDP]

OK, I think I found where we differ and why I was getting a discrepancy in my simulation. My simulation stops the acceleration of each vertex when they reach a given target velocity. When I was getting the discrepancy, the acceleration of some of the vertexes (mirrors/emitters) had stopped before the light signals had returned to the source. Simply reducing the acceleration so that the constant proper linear acceleration continued until after the light signals had completed their loops, ensured the counter going light signals returned simultaneously even under hard acceleration. (I guess that is an important part of the phrase "constant proper acceleration" ).

So at the moment, I agree that a Sagnac gyroscope is not sensitive to constant proper linear acceleration, but it does appear to be significantly sensitive (eg 30% discrepancy in travel times) to changes in linear acceleration.

As a side note, I found I can induce a significant delay discrepancy in the Python program of around 40% if I use these initial parameters in the program (hard acceleration):

# A tuple of [name,x0,y0] values defines the interferometer loop
components = ["Emitter", 6.05, 0], \
["Mirror 1", 0.05, 3], \
["Mirror 2", 10.05, 3]

output:
Loop forward:
Emitter 0
Mirror 1 3.7686765976386143
Mirror 2 152265.00289107673
Emitter 291698.5275249463
Loop reverse:
Emitter 0
Mirror 2 6.767404208104199
Mirror 1 9.441693760005831
Emitter 172229.00677659363

This discrepancy might be due to limitations of the numerical accuracy and accumulated rounding errors in the Python program. I'm not sure.

 

[pervect]

My suggestion is to perform some simple radar "distance" simulated measurements. Rather than considering the effect of a round trip all the way around the loop, consider the length of each side of your loop via the propagation time of a round-trip "laser pulse" that goes from one point of the loop to another and back. Sagnac effects will depend on the area of the loop, effects related to non-rigidity will change the lengths of the sides comprimsing the loop.

You can consider the trip from one point on the loop and back as another loop. But - it should have zero area, and hence be immune to the Sagnac effect, so if you get a change in propagation time along what should be the edge of a loop, you know it's not due to the Sagnac effect but a change in distance. This would be described as non-rigid motion of the loop.

From a theoretical point of view, rigid motion requires that the distance between any two infintesimally close points remains invariant as the motion proceeds. Distance between infinitesimally close points can be measured by the round-trip propagation time of a laser pulse.

"infinitesimally close" may or may not be significant, that's something you can check by varying the total distance in your simulation.

 

[KDP]

My suggestion is to perform some simple radar "distance" simulated measurements....

Thanks Pervect. I was wondering how to check and confirm that I am actually maintaining Born rigid motion in my simulations, so that's a helpful suggestion.

 

[Ibix]

As a side note, I found I can induce a significant delay discrepancy in the Python program of around 40% if I use these initial parameters in the program (hard acceleration):

Probably just rounding error (I made no effort to minimise it in the expression for $t$, which is the likely culprit), but I'll take a look when I get a minute.

Thanks Pervect. I was wondering how to check and confirm that I am actually maintaining Born rigid motion in my simulations, so that's a helpful suggestion.

Boost to the inertial frame where one of your shape's corners is at rest. Are all the other corners also at rest? Are they all in the same configuration as at the start? If not, something's wrong.

 

[KDP]

Probably just rounding error (I made no effort to minimise it in the expression for $t$, which is the likely culprit), but I'll take a look when I get a minute.

I have reformulated your expression for t in the Python program and it seems much less sensitive to rounding errors during extreme acceleration now. See below:

def t(x0, y0, xe, ye, te):
"""Calculates the time at which a flash of light emitted at x=xe, y=ye at
time t=te and reaches an interferometer component that was at x=x0, y=y0
at time t=0."""

dx = x0-xe
dx2 = dx**2
dy = y0-ye
dy2 = dy**2
x02 = x0**2
te2 = te**2
f = -xe
A = (f*f-te2)
B = te*(A-(x02+dy2))
D = (dx2+dy2)
E = 4*x0*(f*D-dx*te2)
F = 2*te2*(dx2-dy2)
C = -D*D+E+F-te**4
t = (-B+(B*B-A*C)**0.5)/(2*A)

return ( te+t )

 

[pervect]

I thought I'd give a theoretical outline of how MTW's treatment of accelerated frames might be extended to a non-uniform acceleration for an arbitrary acceleration profile restricted to one direction - i.e. the magnitude of the acceleration is arbitrary as a function of time, but the direction is fixeed.

"Rapidities" in the same spatial direction add (note - while this is true, it's not integral to MTW's treatment, just my attempt to simplify the problem). See the wiki, https://en.wikipedia.org/wiki/Rapidity, for more details. For low velocities, the rapidity w is equal to the hyperbolic arctangent of $\beta = v/c$. For low velocities, w is proportional to $\beta$, because the hyperbolic arctanh(x) is proportioanl to x to the first order for small x.

Thus we can write the rapidity of an object with an arbitrary proper acceleration profile $\alpha$ as:

$$w(\tau) = \int \alpha(\tau) d\tau$$

This will allow us to find the rapidity as a function of proper time, $w(\tau)$, and hence to find the velocity as a function of proper time, $\beta(\tau)$ and $v(\tau)$. (I prefer to use geometric units, but one can keep tract of the factors of c if one wants to use units where c is not unity).

Knowing the velocity as a function of proper time allows us to find the position as a function of proper time via integration. If the acceleration is held to be in the z direction, the position would be $z(\tau)$. We also need to find the coordinate time t as a function of $\tau$, which will be different from the proper time due to time dilation. Letting $\gamma = 1 / \sqrt{1-\beta^2}$ as usual, we can write:

$$t(\tau) = \int \frac{dt}{d\tau} d\tau = \int \gamma(\tau) d\tau = \int \cosh(w(\tau)) d\tau$$

Here we used the previous expression for w($\tau)$ we just found.

This is formally because $cosh(tanh^{-1} (\beta) ) = \gamma$. It's generally usefull to know that cosh(w) = $\gamma$ and sinh(w) =$\beta \gamma$, which makes tanh(w) = $\beta$ as it should be so that w = $tanh^{-1} \beta$.

We have just found finds the position z and coordinate time t where z and t are inertial coordiantes for our accelerating observer.

If we wished to do an arbitrary accelearation in three dimensions, we'd need to deal with Fermi-Walker transport, which is discussed in MTW, but if we keep the acceleration in one direction we don't have to worry about this (and we avoid the issue of dealing with Thomas precession).

We now have the position and time of the origin of our accelerated coordinates as a function of proper time. To make this into a coordinate system, following MTW's guidline, we need to introduce a unit spatial vector $\hat{Z}$. Then at some instant of coodinate time T=$\tau$, we will describe the set of "simultaneious" events (this is a convention and defintion of our frame) by those events given by some offset $Z \hat{Z}$ from the position of our origin, which we've just computed. We label all these "simultaneous" events with the time coordinate $\tau$. The position of the event is given by the position of our origin of coordinates, plus Z times $\hat{Z)$.

While we could in principle use other simultaneity conventions, we follow MTW's guidance in using the simultaneity convetion of an instantaneously co-moving inertial frame which gives us the expression above.

As discussed in MTW, this accelerated coordinate system won't cover all of space-time, there is an inherent limit on the size of an accelerated frame.

With accleration in only one direction, X and Y coordinates are just x and y, we have simplified the analysis by leaving them out.