fr.cnes.sirius.patrius.attitudes.directions

Class LightAberrationTransformation

java.lang.Object

fr.cnes.sirius.patrius.attitudes.directions.LightAberrationTransformation

public final class LightAberrationTransformation
extends Object

This class implements the light aberration transformation. It allows to transform a light path direction (of observation or targeting) from a frame to another.

Note that this class only treats the transformation coming from the translational velocity between two frames since this is the only aspect that matters regarding the aberration.
For example, if a user wants to transform a light path direction from GCRF to a topocentric frame TOPO, they can proceed in two equivalent ways (depending on handling the rotation before of after the light aberration transformation):

• First use this class to transform the light path direction into an intermediate frame attached to TOPO but with axes having the same orientation as the GCRF and then transform the resulting direction in TOPO by applying the axes rotation.
• First apply the rotation of the light path direction in TOPO and then apply the light aberration transformation with the resulting vector and the velocity of TOPO in the GCRF (but projected on the axes of TOPO).

The light aberration simply comes from the difference of photons velocity direction, arriving (resp. leaving) an object, depending on the frame of observation. Thus, in the same manner as the velocity, the light path direction is necessarily attached to a frame.

Examples:

• The signal propagation from an object A to an object B is computed thanks to VacuumSignalPropagationModel in an inertial frame F (for example GCRF).
• The user wants to know in which direction the object B will see the signal (emitted by the object A) coming in its own frame (attached to B). Then this class should be used with: toTargetDirection=vectorBToA (light path direction from B to A), newFrameVelocity=velocityBInFrameF, signalDirection = ITargetDirection.SignalDirection.FROM_TARGET
• The user wants to know in which direction, in object B's frame, the object B should target a signal to reach object A. Then this class should be used with: toTargetDirection=vectorBToA (light path direction from B to A), newFrameVelocity=velocityBInFrameF, signalDirection = ITargetDirection.SignalDirection.TOWARD_TARGET
• A reception light path direction toTargetDirection expressed in an instrument frame F is provided as input. The user wants to know the equivalent reception light path direction seen from another frame F'. Then this class should be used with: newFrameVelocity=velocityF'InF, signalDirection = ITargetDirection.SignalDirection.FROM_TARGET

Since:

4.13

Author:

Alice Latourte, Hugo Veuillez

Constructor Summary

Constructors

Constructor and Description
LightAberrationTransformation(VacuumSignalPropagation signalPropagation, ITargetDirection.SignalDirection signalDirection) Constructor for the light aberration transformation to convert the propagation vector from frame F to F'.
LightAberrationTransformation(Vector3D toTargetDirection, Vector3D newFrameVelocity, ITargetDirection.SignalDirection signalDirection) Constructor for the light aberration transformation to transform the provided light path direction from frame F to F'.

Method Summary

Modifier and Type	Method and Description
static Vector3D	applyTo(Vector3D toTargetDirection, Vector3D newFrameVelocity, ITargetDirection.SignalDirection signalDirection) Transform the provided light path direction from frame F to F'.
static double	computeAberrationAngle(Vector3D toTargetDirection, Vector3D newFrameVelocity) Compute the light aberration angle between a light path direction seen from a frame F and a frame F'.
double	getAberrationAngle() Getter for the aberration angle [rad].
ITargetDirection.SignalDirection	getSignalDirection() Getter for the signal direction.
Vector3D	getTransformedToTargetDirection() Getter for the transformed light path direction towards the target in the new frame F'.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

LightAberrationTransformation

public LightAberrationTransformation(VacuumSignalPropagation signalPropagation,
                                     ITargetDirection.SignalDirection signalDirection)

Constructor for the light aberration transformation to convert the propagation vector from frame F to F'.

The light propagation vector is defined with respect to the frame F. The new frame F' is attached to the receiver or emitter according to the signalDirection, but keeps the same orientation as the frame F.

See computeAberrationAngle(fr.cnes.sirius.patrius.math.geometry.euclidean.threed.Vector3D, fr.cnes.sirius.patrius.math.geometry.euclidean.threed.Vector3D) for more details on the aberration formula.

Parameters:

signalPropagation - The signal propagation from emitter to receiver

signalDirection - Indicate whether the frame F' is attached to the receiver ITargetDirection.SignalDirection.FROM_TARGET or the emitter ITargetDirection.SignalDirection.TOWARD_TARGET

LightAberrationTransformation

public LightAberrationTransformation(Vector3D toTargetDirection,
                                     Vector3D newFrameVelocity,
                                     ITargetDirection.SignalDirection signalDirection)

Constructor for the light aberration transformation to transform the provided light path direction from frame F to F'.

See computeAberrationAngle(fr.cnes.sirius.patrius.math.geometry.euclidean.threed.Vector3D, fr.cnes.sirius.patrius.math.geometry.euclidean.threed.Vector3D) for more details on the aberration formula.

Parameters:

toTargetDirection - Direction towards the target, defined in a frame F

newFrameVelocity - Velocity of the new frame F' with respect to F. Note that F' keeps the same orientation as F.

signalDirection - Indicates whether the signal is coming from or towards the target

Method Detail

getAberrationAngle

public double getAberrationAngle()

Getter for the aberration angle [rad].

Returns:

the aberration angle

getTransformedToTargetDirection

public Vector3D getTransformedToTargetDirection()

Getter for the transformed light path direction towards the target in the new frame F'.

Note: The returned vector can be projected in any other frame thanks to Transform.transformVector(fr.cnes.sirius.patrius.math.geometry.euclidean.threed.Vector3D).
But beware that it is only a projection and the light path direction remains defined with respect to F' (in terms of aberration).

Returns:

the direction towards the target defined with respect to the frame F'

getSignalDirection

public ITargetDirection.SignalDirection getSignalDirection()

Getter for the signal direction.

Returns:

the signal direction

computeAberrationAngle

public static double computeAberrationAngle(Vector3D toTargetDirection,
                                            Vector3D newFrameVelocity)

Compute the light aberration angle between a light path direction seen from a frame F and a frame F'.

Let's assume that toTargetDirection is a light path direction defined in the frame F.
To convert this direction in a new frame F', the velocity of F' with respect to F (newFrameVelocity) needs to be taken into consideration. Note that F' keeps the same orientation as F.

          target (in F)    target (in F')
                 T          T'
                ^          ^
               /         .
              /        .  dir (in F')
             /__ Δθ  .
 dir (in F) /   \  .
           /     .
          /    .
         /   .__
        /__.    \ θ'
       / .  \   |
      /.  θ |   |
      -----------> _
    O              V
                velocity of F' in F
 
              sin(θ)
   tan(θ') = ------------- sqrt(1 - (V/c)²)
             cos(θ) + V/c
 

Parameters:

toTargetDirection - Direction towards the target, defined in the frame F

newFrameVelocity - Velocity of the new frame F' w.r.t the frame F

Returns:

the aberration angle so that angleInNewFrame = angleInPreviousFrame + aberrationAngle

applyTo

public static Vector3D applyTo(Vector3D toTargetDirection,
                               Vector3D newFrameVelocity,
                               ITargetDirection.SignalDirection signalDirection)

Transform the provided light path direction from frame F to F'.

Let's assume that toTargetDirection is a light path direction defined in the frame F.
To convert this direction in a new frame F', the newFrameVelocity should be the velocity of F' with respect to F.
Note that F' keeps the same orientation as F.

See computeAberrationAngle(fr.cnes.sirius.patrius.math.geometry.euclidean.threed.Vector3D, fr.cnes.sirius.patrius.math.geometry.euclidean.threed.Vector3D) for more details on the aberration formula.

Parameters:

toTargetDirection - Direction towards the target defined in the frame F

newFrameVelocity - Velocity of the frame F' w.r.t the frame F

signalDirection - Indicates whether the signal is coming from or towards the target

Returns:

the transformed light path direction, expressed in the frame F'