FieldAttitude.java

  1. /* Copyright 2002-2018 CS Systèmes d'Information
  2.  * Licensed to CS Systèmes d'Information (CS) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * CS licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *   http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.orekit.attitudes;

  19. import java.util.List;
  20. import java.util.stream.Collectors;
  21. import java.util.stream.Stream;

  23. import org.hipparchus.Field;
  24. import org.hipparchus.RealFieldElement;
  25. import org.hipparchus.geometry.euclidean.threed.FieldRotation;
  26. import org.hipparchus.geometry.euclidean.threed.FieldVector3D;
  27. import org.hipparchus.geometry.euclidean.threed.Rotation;
  28. import org.hipparchus.geometry.euclidean.threed.RotationConvention;
  29. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  30. import org.orekit.errors.OrekitException;
  31. import org.orekit.frames.Frame;
  32. import org.orekit.frames.Transform;
  33. import org.orekit.time.FieldAbsoluteDate;
  34. import org.orekit.time.FieldTimeInterpolable;
  35. import org.orekit.time.FieldTimeShiftable;
  36. import org.orekit.time.FieldTimeStamped;
  37. import org.orekit.utils.AngularDerivativesFilter;
  38. import org.orekit.utils.FieldAngularCoordinates;
  39. import org.orekit.utils.TimeStampedFieldAngularCoordinates;


  42. /** This class handles attitude definition at a given date.

  44.  * <p>This class represents the rotation between a reference frame and
  45.  * the satellite frame, as well as the spin of the satellite (axis and
  46.  * rotation rate).</p>
  47.  * <p>
  48.  * The state can be slightly shifted to close dates. This shift is based on
  49.  * a linear extrapolation for attitude taking the spin rate into account.
  50.  * It is <em>not</em> intended as a replacement for proper attitude propagation
  51.  * but should be sufficient for either small time shifts or coarse accuracy.
  52.  * </p>
  53.  * <p>The instance <code>Attitude</code> is guaranteed to be immutable.</p>
  54.  * @see     org.orekit.orbits.Orbit
  55.  * @see AttitudeProvider
  56.  * @author V&eacute;ronique Pommier-Maurussane
  57.  */

  59. public class FieldAttitude<T extends RealFieldElement<T>>
  60.     implements FieldTimeStamped<T>, FieldTimeShiftable<FieldAttitude<T>, T>, FieldTimeInterpolable<FieldAttitude<T>, T> {


  63.     /** Reference frame. */
  64.     private final Frame referenceFrame;

  66.      /** Attitude and spin.  */
  67.     private final TimeStampedFieldAngularCoordinates<T> orientation;

  69.     /** Creates a new instance.
  70.      * @param referenceFrame reference frame from which attitude is defined
  71.      * @param orientation complete orientation between reference frame and satellite frame,
  72.      * including rotation rate
  73.      */
  74.     public FieldAttitude(final Frame referenceFrame, final TimeStampedFieldAngularCoordinates<T> orientation) {
  75.         this.referenceFrame = referenceFrame;
  76.         this.orientation    = orientation;
  77.     }

  79.     /** Creates a new instance.
  80.      * @param date date at which attitude is defined
  81.      * @param referenceFrame reference frame from which attitude is defined
  82.      * @param orientation complete orientation between reference frame and satellite frame,
  83.      * including rotation rate
  84.      */
  85.     public FieldAttitude(final FieldAbsoluteDate<T> date, final Frame referenceFrame,
  86.                          final FieldAngularCoordinates<T> orientation) {
  87.         this(referenceFrame,
  88.              new TimeStampedFieldAngularCoordinates<>(date,
  89.                                                       orientation.getRotation(),
  90.                                                       orientation.getRotationRate(),
  91.                                                       orientation.getRotationAcceleration()));
  92.     }

  94.     /** Creates a new instance.
  95.      * @param date date at which attitude is defined
  96.      * @param referenceFrame reference frame from which attitude is defined
  97.      * @param attitude rotation between reference frame and satellite frame
  98.      * @param spin satellite spin (axis and velocity, in <strong>satellite</strong> frame)
  99.      * @param acceleration satellite rotation acceleration (in <strong>satellite</strong> frame)
  100.      */
  101.     public FieldAttitude(final FieldAbsoluteDate<T> date, final Frame referenceFrame,
  102.                          final FieldRotation<T> attitude, final FieldVector3D<T> spin, final FieldVector3D<T> acceleration) {
  103.         this(referenceFrame, new TimeStampedFieldAngularCoordinates<>(date, attitude, spin, acceleration));
  104.     }

  106.     /** Creates a new instance.
  107.      * @param date date at which attitude is defined
  108.      * @param referenceFrame reference frame from which attitude is defined
  109.      * @param attitude rotation between reference frame and satellite frame
  110.      * @param spin satellite spin (axis and velocity, in <strong>satellite</strong> frame)
  111.      * @param acceleration satellite rotation acceleration (in <strong>satellite</strong> frame)
  112.      * @param field field used by default
  113.      */
  114.     public FieldAttitude(final FieldAbsoluteDate<T> date, final Frame referenceFrame,
  115.                          final Rotation attitude, final Vector3D spin, final Vector3D acceleration, final Field<T> field) {
  116.         this(referenceFrame, new TimeStampedFieldAngularCoordinates<>(date,
  117.                                                                       new FieldRotation<>(field, attitude),
  118.                                                                       new FieldVector3D<>(field, spin),
  119.                                                                       new FieldVector3D<>(field, acceleration)));
  120.     }

  122.     /** Builds an instance for a regular {@link Attitude}.
  123.      * @param field fields to which the elements belong
  124.      * @param attitude attitude to convert
  125.      */
  126.     public FieldAttitude(final Field<T> field, final Attitude attitude) {
  127.         this(attitude.getReferenceFrame(), new TimeStampedFieldAngularCoordinates<>(field, attitude.getOrientation()));
  128.     }

  130.     /** Get a time-shifted attitude.
  131.      * <p>
  132.      * The state can be slightly shifted to close dates. This shift is based on
  133.      * a linear extrapolation for attitude taking the spin rate into account.
  134.      * It is <em>not</em> intended as a replacement for proper attitude propagation
  135.      * but should be sufficient for either small time shifts or coarse accuracy.
  136.      * </p>
  137.      * @param dt time shift in seconds
  138.      * @return a new attitude, shifted with respect to the instance (which is immutable)
  139.      */
  140.     public FieldAttitude<T> shiftedBy(final double dt) {
  141.         return new FieldAttitude<>(referenceFrame, orientation.shiftedBy(dt));
  142.     }

  144.     /** Get a time-shifted attitude.
  145.      * <p>
  146.      * The state can be slightly shifted to close dates. This shift is based on
  147.      * a linear extrapolation for attitude taking the spin rate into account.
  148.      * It is <em>not</em> intended as a replacement for proper attitude propagation
  149.      * but should be sufficient for either small time shifts or coarse accuracy.
  150.      * </p>
  151.      * @param dt time shift in seconds
  152.      * @return a new attitude, shifted with respect to the instance (which is immutable)
  153.      */
  154.     public FieldAttitude<T> shiftedBy(final T dt) {
  155.         return new FieldAttitude<>(referenceFrame, orientation.shiftedBy(dt));
  156.     }

  158.     /** Get a similar attitude with a specific reference frame.
  159.      * <p>
  160.      * If the instance reference frame is already the specified one, the instance
  161.      * itself is returned without any object creation. Otherwise, a new instance
  162.      * will be created with the specified reference frame. In this case, the
  163.      * required intermediate rotation and spin between the specified and the
  164.      * original reference frame will be inserted.
  165.      * </p>
  166.      * @param newReferenceFrame desired reference frame for attitude
  167.      * @return an attitude that has the same orientation and motion as the instance,
  168.      * but guaranteed to have the specified reference frame
  169.      * @exception OrekitException if conversion between reference frames fails
  170.      */
  171.     public FieldAttitude<T> withReferenceFrame(final Frame newReferenceFrame)
  172.         throws OrekitException {

  174.         if (newReferenceFrame == referenceFrame) {
  175.             // simple case, the instance is already compliant
  176.             return this;
  177.         }

  179.         // we have to take an intermediate rotation into account
  180.         final Transform t = newReferenceFrame.getTransformTo(referenceFrame, orientation.getDate().toAbsoluteDate());
  181.         return new FieldAttitude<>(orientation.getDate(), newReferenceFrame,
  182.                                    orientation.getRotation().compose(t.getRotation(), RotationConvention.VECTOR_OPERATOR),
  183.                                    orientation.getRotationRate().add(orientation.getRotation().applyTo(t.getRotationRate())),
  184.                                    orientation.getRotationAcceleration().add(orientation.getRotation().applyTo(t.getRotationAcceleration())));

  186.     }

  188.     /** Get the date of attitude parameters.
  189.      * @return date of the attitude parameters
  190.      */
  191.     public FieldAbsoluteDate<T> getDate() {
  192.         return orientation.getDate();
  193.     }

  195.     /** Get the reference frame.
  196.      * @return referenceFrame reference frame from which attitude is defined.
  197.      */
  198.     public Frame getReferenceFrame() {
  199.         return referenceFrame;
  200.     }

  202.     /** Get the complete orientation including spin.
  203.      * @return complete orientation including spin
  204.      * @see #getRotation()
  205.      * @see #getSpin()
  206.      */
  207.     public TimeStampedFieldAngularCoordinates<T> getOrientation() {
  208.         return orientation;
  209.     }

  211.     /** Get the attitude rotation.
  212.      * @return attitude satellite rotation from reference frame.
  213.      * @see #getOrientation()
  214.      * @see #getSpin()
  215.      */
  216.     public FieldRotation<T> getRotation() {
  217.         return orientation.getRotation();
  218.     }

  220.     /** Get the satellite spin.
  221.      * <p>The spin vector is defined in <strong>satellite</strong> frame.</p>
  222.      * @return spin satellite spin (axis and velocity).
  223.      * @see #getOrientation()
  224.      * @see #getRotation()
  225.      */
  226.     public FieldVector3D<T> getSpin() {
  227.         return orientation.getRotationRate();
  228.     }

  230.     /** Get the satellite rotation acceleration.
  231.      * <p>The rotation acceleration. vector is defined in <strong>satellite</strong> frame.</p>
  232.      * @return rotation acceleration
  233.      * @see #getOrientation()
  234.      * @see #getRotation()
  235.      */
  236.     public FieldVector3D<T> getRotationAcceleration() {
  237.         return orientation.getRotationAcceleration();
  238.     }

  240.     /** Get an interpolated instance.
  241.      * <p>
  242.      * The interpolated instance is created by polynomial Hermite interpolation
  243.      * on Rodrigues vector ensuring rotation rate remains the exact derivative of rotation.
  244.      * </p>
  245.      * <p>
  246.      * As this implementation of interpolation is polynomial, it should be used only
  247.      * with small samples (about 10-20 points) in order to avoid <a
  248.      * href="http://en.wikipedia.org/wiki/Runge%27s_phenomenon">Runge's phenomenon</a>
  249.      * and numerical problems (including NaN appearing).
  250.      * </p>
  251.      * @param interpolationDate interpolation date
  252.      * @param sample sample points on which interpolation should be done
  253.      * @return a new instance, interpolated at specified date
  254.      * @exception OrekitException if the number of point is too small for interpolating
  255.      */
  256.     public FieldAttitude<T> interpolate(final FieldAbsoluteDate<T> interpolationDate,
  257.                                         final Stream<FieldAttitude<T>> sample)
  258.         throws OrekitException {
  259.         final List<TimeStampedFieldAngularCoordinates<T>> datedPV =
  260.                 sample.map(attitude -> attitude.orientation).collect(Collectors.toList());
  261.         final TimeStampedFieldAngularCoordinates<T> interpolated =
  262.                 TimeStampedFieldAngularCoordinates.interpolate(interpolationDate, AngularDerivativesFilter.USE_RR, datedPV);
  263.         return new FieldAttitude<>(referenceFrame, interpolated);
  264.     }
  265.     /**
  266.      * Converts to an Attitude instance.
  267.      * @return Attitude with same properties
  268.      */
  269.     public Attitude toAttitude() {
  270.         return new Attitude(orientation.getDate().toAbsoluteDate(), referenceFrame, orientation.toAngularCoordinates());
  271.     }

  273. }
Created with JaCoCo 0.7.9.201702052155