AttitudeType.java

  1. /* Copyright 2002-2022 CS GROUP
  2.  * Licensed to CS GROUP (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.files.ccsds.ndm.adm;

  19. import java.util.regex.Pattern;

  21. import org.hipparchus.analysis.differentiation.UnivariateDerivative1;
  22. import org.hipparchus.geometry.euclidean.threed.FieldRotation;
  23. import org.hipparchus.geometry.euclidean.threed.Rotation;
  24. import org.hipparchus.geometry.euclidean.threed.RotationConvention;
  25. import org.hipparchus.geometry.euclidean.threed.RotationOrder;
  26. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  27. import org.hipparchus.util.FastMath;
  28. import org.orekit.attitudes.Attitude;
  29. import org.orekit.errors.OrekitException;
  30. import org.orekit.errors.OrekitMessages;
  31. import org.orekit.files.ccsds.definitions.Units;
  32. import org.orekit.files.ccsds.utils.ContextBinding;
  33. import org.orekit.time.AbsoluteDate;
  34. import org.orekit.utils.AccurateFormatter;
  35. import org.orekit.utils.AngularDerivativesFilter;
  36. import org.orekit.utils.TimeStampedAngularCoordinates;
  37. import org.orekit.utils.units.Unit;

  39. /** Enumerate for ADM attitude type.
  40.  * @author Bryan Cazabonne
  41.  * @since 10.2
  42.  */
  43. public enum AttitudeType {

  45.     /** Quaternion. */
  46.     QUATERNION("QUATERNION", AngularDerivativesFilter.USE_R,
  47.                Unit.ONE, Unit.ONE, Unit.ONE, Unit.ONE) {

  49.         /** {@inheritDoc} */
  50.         @Override
  51.         public String[] createDataFields(final boolean isFirst, final boolean isExternal2SpacecraftBody,
  52.                                          final RotationOrder eulerRotSequence, final boolean isSpacecraftBodyRate,
  53.                                          final TimeStampedAngularCoordinates coordinates) {

  55.             // Initialize the array of attitude data
  56.             final double[] data = new double[4];

  58.             // Data index
  59.             final int[] quaternionIndex = isFirst ? new int[] {0, 1, 2, 3} : new int[] {3, 0, 1, 2};

  61.             // Fill the array
  62.             Rotation rotation  = coordinates.getRotation();
  63.             if (!isExternal2SpacecraftBody) {
  64.                 rotation = rotation.revert();
  65.             }
  66.             data[quaternionIndex[0]] = rotation.getQ0();
  67.             data[quaternionIndex[1]] = rotation.getQ1();
  68.             data[quaternionIndex[2]] = rotation.getQ2();
  69.             data[quaternionIndex[3]] = rotation.getQ3();

  71.             // Convert units and format
  72.             return QUATERNION.formatData(data);

  74.         }

  76.         /** {@inheritDoc} */
  77.         @Override
  78.         public TimeStampedAngularCoordinates build(final boolean isFirst,
  79.                                                    final boolean isExternal2SpacecraftBody,
  80.                                                    final RotationOrder eulerRotSequence,
  81.                                                    final boolean isSpacecraftBodyRate,
  82.                                                    final AbsoluteDate date,
  83.                                                    final double... components) {

  85.             Rotation rotation = isFirst ?
  86.                                 new Rotation(components[0], components[1], components[2], components[3], true) :
  87.                                 new Rotation(components[3], components[0], components[1], components[2], true);
  88.             if (!isExternal2SpacecraftBody) {
  89.                 rotation = rotation.revert();
  90.             }

  92.             // Return
  93.             return new TimeStampedAngularCoordinates(date, rotation, Vector3D.ZERO, Vector3D.ZERO);

  95.         }

  97.     },

  99.     /** Quaternion and derivatives. */
  100.     QUATERNION_DERIVATIVE("QUATERNION/DERIVATIVE", AngularDerivativesFilter.USE_RR,
  101.                           Unit.ONE, Unit.ONE, Unit.ONE, Unit.ONE,
  102.                           Units.ONE_PER_S, Units.ONE_PER_S, Units.ONE_PER_S, Units.ONE_PER_S) {

  104.         /** {@inheritDoc} */
  105.         @Override
  106.         public String[] createDataFields(final boolean isFirst, final boolean isExternal2SpacecraftBody,
  107.                                          final RotationOrder eulerRotSequence, final boolean isSpacecraftBodyRate,
  108.                                          final TimeStampedAngularCoordinates coordinates) {

  110.             // Initialize the array of attitude data
  111.             final double[] data = new double[8];

  113.             FieldRotation<UnivariateDerivative1> rotation = coordinates.toUnivariateDerivative1Rotation();
  114.             if (!isExternal2SpacecraftBody) {
  115.                 rotation = rotation.revert();
  116.             }

  118.             // Data index
  119.             final int[] quaternionIndex = isFirst ?
  120.                                           new int[] {0, 1, 2, 3, 4, 5, 6, 7} :
  121.                                           new int[] {3, 0, 1, 2, 7, 4, 5, 6};

  123.             // Fill the array
  124.             data[quaternionIndex[0]] = rotation.getQ0().getValue();
  125.             data[quaternionIndex[1]] = rotation.getQ1().getValue();
  126.             data[quaternionIndex[2]] = rotation.getQ2().getValue();
  127.             data[quaternionIndex[3]] = rotation.getQ3().getValue();
  128.             data[quaternionIndex[4]] = rotation.getQ0().getFirstDerivative();
  129.             data[quaternionIndex[5]] = rotation.getQ1().getFirstDerivative();
  130.             data[quaternionIndex[6]] = rotation.getQ2().getFirstDerivative();
  131.             data[quaternionIndex[7]] = rotation.getQ3().getFirstDerivative();

  133.             // Convert units and format
  134.             return QUATERNION_DERIVATIVE.formatData(data);

  136.         }

  138.         /** {@inheritDoc} */
  139.         @Override
  140.         public TimeStampedAngularCoordinates build(final boolean isFirst,
  141.                                                    final boolean isExternal2SpacecraftBody,
  142.                                                    final RotationOrder eulerRotSequence,
  143.                                                    final boolean isSpacecraftBodyRate,
  144.                                                    final AbsoluteDate date,
  145.                                                    final double... components) {
  146.             FieldRotation<UnivariateDerivative1> rotation =
  147.                             isFirst ?
  148.                             new FieldRotation<>(new UnivariateDerivative1(components[0], components[4]),
  149.                                                 new UnivariateDerivative1(components[1], components[5]),
  150.                                                 new UnivariateDerivative1(components[2], components[6]),
  151.                                                 new UnivariateDerivative1(components[3], components[7]),
  152.                                                 true) :
  153.                             new FieldRotation<>(new UnivariateDerivative1(components[3], components[7]),
  154.                                                 new UnivariateDerivative1(components[0], components[4]),
  155.                                                 new UnivariateDerivative1(components[1], components[5]),
  156.                                                 new UnivariateDerivative1(components[2], components[6]),
  157.                                                 true);
  158.             if (!isExternal2SpacecraftBody) {
  159.                 rotation = rotation.revert();
  160.             }

  162.             return new TimeStampedAngularCoordinates(date, rotation);

  164.         }

  166.     },

  168.     /** Quaternion and rotation rate. */
  169.     QUATERNION_RATE("QUATERNION/RATE", AngularDerivativesFilter.USE_RR,
  170.                     Unit.ONE, Unit.ONE, Unit.ONE, Unit.ONE,
  171.                     Units.DEG_PER_S, Units.DEG_PER_S, Units.DEG_PER_S) {

  173.         /** {@inheritDoc} */
  174.         @Override
  175.         public String[] createDataFields(final boolean isFirst, final boolean isExternal2SpacecraftBody,
  176.                                          final RotationOrder eulerRotSequence, final boolean isSpacecraftBodyRate,
  177.                                          final TimeStampedAngularCoordinates coordinates) {

  179.             // Initialize the array of attitude data
  180.             final double[] data = new double[7];

  182.             // Data index
  183.             final int[] quaternionIndex = isFirst ? new int[] {0, 1, 2, 3} : new int[] {3, 0, 1, 2};

  185.             // Attitude
  186.             final TimeStampedAngularCoordinates c = isExternal2SpacecraftBody ? coordinates : coordinates.revert();
  187.             final Vector3D rotationRate = QUATERNION_RATE.metadataRate(isSpacecraftBodyRate, c.getRotationRate(), c.getRotation());

  189.             // Fill the array
  190.             data[quaternionIndex[0]] = c.getRotation().getQ0();
  191.             data[quaternionIndex[1]] = c.getRotation().getQ1();
  192.             data[quaternionIndex[2]] = c.getRotation().getQ2();
  193.             data[quaternionIndex[3]] = c.getRotation().getQ3();
  194.             data[4] = rotationRate.getX();
  195.             data[5] = rotationRate.getY();
  196.             data[6] = rotationRate.getZ();

  198.             // Convert units and format
  199.             return QUATERNION_RATE.formatData(data);

  201.         }

  203.         /** {@inheritDoc} */
  204.         @Override
  205.         public TimeStampedAngularCoordinates build(final boolean isFirst,
  206.                                                    final boolean isExternal2SpacecraftBody,
  207.                                                    final RotationOrder eulerRotSequence,
  208.                                                    final boolean isSpacecraftBodyRate,
  209.                                                    final AbsoluteDate date,
  210.                                                    final double... components) {
  211.             // Build the needed objects
  212.             final Rotation rotation = isFirst ?
  213.                                       new Rotation(components[0], components[1], components[2], components[3], true) :
  214.                                       new Rotation(components[3], components[0], components[1], components[2], true);
  215.             final Vector3D rotationRate = QUATERNION_RATE.orekitRate(isSpacecraftBodyRate,
  216.                                                                      new Vector3D(components[4],
  217.                                                                                   components[5],
  218.                                                                                   components[6]),
  219.                                                                      rotation);

  221.             // Return
  222.             final TimeStampedAngularCoordinates ac =
  223.                             new TimeStampedAngularCoordinates(date, rotation, rotationRate, Vector3D.ZERO);
  224.             return isExternal2SpacecraftBody ? ac : ac.revert();

  226.         }

  228.     },

  230.     /** Euler angles. */
  231.     EULER_ANGLE("EULER ANGLE", AngularDerivativesFilter.USE_R,
  232.                 Unit.DEGREE, Unit.DEGREE, Unit.DEGREE) {

  234.         /** {@inheritDoc} */
  235.         @Override
  236.         public String[] createDataFields(final boolean isFirst, final boolean isExternal2SpacecraftBody,
  237.                                          final RotationOrder eulerRotSequence, final boolean isSpacecraftBodyRate,
  238.                                          final TimeStampedAngularCoordinates coordinates) {

  240.             // Attitude
  241.             Rotation rotation = coordinates.getRotation();
  242.             if (!isExternal2SpacecraftBody) {
  243.                 rotation = rotation.revert();
  244.             }

  246.             final double[] data = rotation.getAngles(eulerRotSequence, RotationConvention.FRAME_TRANSFORM);

  248.             // Convert units and format
  249.             return EULER_ANGLE.formatData(data);

  251.         }

  253.         /** {@inheritDoc} */
  254.         @Override
  255.         public TimeStampedAngularCoordinates build(final boolean isFirst,
  256.                                                    final boolean isExternal2SpacecraftBody,
  257.                                                    final RotationOrder eulerRotSequence,
  258.                                                    final boolean isSpacecraftBodyRate,
  259.                                                    final AbsoluteDate date,
  260.                                                    final double... components) {

  262.             // Build the needed objects
  263.             Rotation rotation = new Rotation(eulerRotSequence, RotationConvention.FRAME_TRANSFORM,
  264.                                              components[0], components[1], components[2]);
  265.             if (!isExternal2SpacecraftBody) {
  266.                 rotation = rotation.revert();
  267.             }

  269.             // Return
  270.             return new TimeStampedAngularCoordinates(date, rotation, Vector3D.ZERO, Vector3D.ZERO);
  271.         }

  273.     },

  275.     /** Euler angles and rotation rate. */
  276.     EULER_ANGLE_RATE("EULER ANGLE/RATE", AngularDerivativesFilter.USE_RR,
  277.                      Unit.DEGREE, Unit.DEGREE, Unit.DEGREE,
  278.                      Units.DEG_PER_S, Units.DEG_PER_S, Units.DEG_PER_S) {

  280.         /** {@inheritDoc} */
  281.         @Override
  282.         public String[] createDataFields(final boolean isFirst, final boolean isExternal2SpacecraftBody,
  283.                                          final RotationOrder eulerRotSequence, final boolean isSpacecraftBodyRate,
  284.                                          final TimeStampedAngularCoordinates coordinates) {

  286.             // Initialize the array of attitude data
  287.             final double[] data = new double[6];

  289.             // Attitude
  290.             final TimeStampedAngularCoordinates c = isExternal2SpacecraftBody ? coordinates : coordinates.revert();
  291.             final Vector3D rotationRate = EULER_ANGLE_RATE.metadataRate(isSpacecraftBodyRate, c.getRotationRate(), c.getRotation());
  292.             final double[] angles       = c.getRotation().getAngles(eulerRotSequence, RotationConvention.FRAME_TRANSFORM);

  294.             // Fill the array
  295.             data[0] = angles[0];
  296.             data[1] = angles[1];
  297.             data[2] = angles[2];
  298.             data[3] = Vector3D.dotProduct(rotationRate, eulerRotSequence.getA1());
  299.             data[4] = Vector3D.dotProduct(rotationRate, eulerRotSequence.getA2());
  300.             data[5] = Vector3D.dotProduct(rotationRate, eulerRotSequence.getA3());

  302.             // Convert units and format
  303.             return EULER_ANGLE_RATE.formatData(data);

  305.         }

  307.         /** {@inheritDoc} */
  308.         @Override
  309.         public TimeStampedAngularCoordinates build(final boolean isFirst,
  310.                                                    final boolean isExternal2SpacecraftBody,
  311.                                                    final RotationOrder eulerRotSequence,
  312.                                                    final boolean isSpacecraftBodyRate,
  313.                                                    final AbsoluteDate date,
  314.                                                    final double... components) {

  316.             // Build the needed objects
  317.             final Rotation rotation = new Rotation(eulerRotSequence,
  318.                                                    RotationConvention.FRAME_TRANSFORM,
  319.                                                    components[0],
  320.                                                    components[1],
  321.                                                    components[2]);
  322.             final Vector3D rotationRate = EULER_ANGLE_RATE.orekitRate(isSpacecraftBodyRate,
  323.                                                                       new Vector3D(components[3], eulerRotSequence.getA1(),
  324.                                                                                    components[4], eulerRotSequence.getA2(),
  325.                                                                                    components[5], eulerRotSequence.getA3()),
  326.                                                                       rotation);
  327.             // Return
  328.             final TimeStampedAngularCoordinates ac =
  329.                             new TimeStampedAngularCoordinates(date, rotation, rotationRate, Vector3D.ZERO);
  330.             return isExternal2SpacecraftBody ? ac : ac.revert();

  332.         }

  334.     },

  336.     /** Spin.
  337.      * <p>
  338.      * CCSDS enforces that spin axis is +Z, so if {@link #createDataFields(boolean, boolean, RotationOrder, boolean,
  339.      * TimeStampedAngularCoordinates) createDataFields} is called with {@code coordinates} with {@link
  340.      * TimeStampedAngularCoordinates#getRotationRate() rotation rate} that is not along the Z axis, result is
  341.      * undefined.
  342.      * </p>
  343.      */
  344.     SPIN("SPIN", AngularDerivativesFilter.USE_RR,
  345.          Unit.DEGREE, Unit.DEGREE, Unit.DEGREE, Units.DEG_PER_S) {

  347.         /** {@inheritDoc} */
  348.         @Override
  349.         public String[] createDataFields(final boolean isFirst, final boolean isExternal2SpacecraftBody,
  350.                                          final RotationOrder eulerRotSequence, final boolean isSpacecraftBodyRate,
  351.                                          final TimeStampedAngularCoordinates coordinates) {

  353.             // Initialize the array of attitude data
  354.             final double[] data = new double[4];

  356.             // Attitude
  357.             final double[] angles = coordinates.getRotation().getAngles(RotationOrder.ZYZ, RotationConvention.FRAME_TRANSFORM);

  359.             // Fill the array
  360.             data[0] = angles[0];
  361.             data[1] = 0.5 * FastMath.PI - angles[1];
  362.             data[2] = angles[2];
  363.             data[3] = coordinates.getRotationRate().getZ();

  365.             // Convert units and format
  366.             return SPIN.formatData(data);

  368.         }

  370.         /** {@inheritDoc} */
  371.         @Override
  372.         public TimeStampedAngularCoordinates build(final boolean isFirst,
  373.                                                    final boolean isExternal2SpacecraftBody,
  374.                                                    final RotationOrder eulerRotSequence,
  375.                                                    final boolean isSpacecraftBodyRate,
  376.                                                    final AbsoluteDate date,
  377.                                                    final double... components) {

  379.             // Build the needed objects
  380.             final Rotation rotation = new Rotation(RotationOrder.ZYZ,
  381.                                                    RotationConvention.FRAME_TRANSFORM,
  382.                                                    components[0],
  383.                                                    0.5 * FastMath.PI - components[1],
  384.                                                    components[2]);
  385.             final Vector3D rotationRate = new Vector3D(0, 0, components[3]);

  387.             // Return
  388.             return new TimeStampedAngularCoordinates(date, rotation, rotationRate, Vector3D.ZERO);

  390.         }

  392.     },

  394.     /** Spin and nutation. */
  395.     SPIN_NUTATION("SPIN/NUTATION", AngularDerivativesFilter.USE_RR,
  396.                   Unit.DEGREE, Unit.DEGREE, Unit.DEGREE, Units.DEG_PER_S,
  397.                   Unit.DEGREE, Unit.SECOND, Unit.DEGREE) {

  399.         /** {@inheritDoc} */
  400.         @Override
  401.         public String[] createDataFields(final boolean isFirst, final boolean isExternal2SpacecraftBody,
  402.                                          final RotationOrder eulerRotSequence, final boolean isSpacecraftBodyRate,
  403.                                          final TimeStampedAngularCoordinates coordinates) {
  404.             // Attitude parameters in the Specified Reference Frame for a Spin Stabilized Satellite
  405.             // are optional in CCSDS AEM format. Support for this attitude type is not implemented
  406.             // yet in Orekit.
  407.             throw new OrekitException(OrekitMessages.CCSDS_AEM_ATTITUDE_TYPE_NOT_IMPLEMENTED, name());
  408.         }

  410.         /** {@inheritDoc} */
  411.         @Override
  412.         public TimeStampedAngularCoordinates build(final boolean isFirst,
  413.                                                    final boolean isExternal2SpacecraftBody,
  414.                                                    final RotationOrder eulerRotSequence,
  415.                                                    final boolean isSpacecraftBodyRate,
  416.                                                    final AbsoluteDate date,
  417.                                                    final double... components) {
  418.             // Attitude parameters in the Specified Reference Frame for a Spin Stabilized Satellite
  419.             // are optional in CCSDS AEM format. Support for this attitude type is not implemented
  420.             // yet in Orekit.
  421.             throw new OrekitException(OrekitMessages.CCSDS_AEM_ATTITUDE_TYPE_NOT_IMPLEMENTED, name());
  422.         }

  424.     };

  426.     /** Pattern for normalizing attitude types. */
  427.     private static final Pattern TYPE_SEPARATORS = Pattern.compile("[ _/]+");

  429.     /** CCSDS name of the attitude type. */
  430.     private final String ccsdsName;

  432.     /** Derivatives filter. */
  433.     private final AngularDerivativesFilter filter;

  435.     /** Components units (used only for parsing). */
  436.     private final Unit[] units;

  438.     /** Private constructor.
  439.      * @param ccsdsName CCSDS name of the attitude type
  440.      * @param filter derivative filter
  441.      * @param units components units (used only for parsing)
  442.      */
  443.     AttitudeType(final String ccsdsName, final AngularDerivativesFilter filter, final Unit... units) {
  444.         this.ccsdsName = ccsdsName;
  445.         this.filter    = filter;
  446.         this.units     = units.clone();
  447.     }

  449.     /** {@inheritDoc} */
  450.     @Override
  451.     public String toString() {
  452.         return ccsdsName;
  453.     }

  455.     /** Parse an attitude type.
  456.      * @param type unnormalized type name
  457.      * @return parsed type
  458.      */
  459.     public static AttitudeType parseType(final String type) {
  460.         return AttitudeType.valueOf(TYPE_SEPARATORS.matcher(type).replaceAll("_"));
  461.     }

  463.     /**
  464.      * Get the attitude data fields corresponding to the attitude type.
  465.      * <p>
  466.      * This method returns the components in CCSDS units (i.e. degrees, degrees per seconds…).
  467.      * </p>
  468.      * @param isFirst if true the first quaternion component is the scalar component
  469.      * @param isExternal2SpacecraftBody true attitude is from external frame to spacecraft body frame
  470.      * @param eulerRotSequence sequance of Euler angles
  471.      * @param isSpacecraftBodyRate if true Euler rates are specified in spacecraft body frame
  472.      * @param attitude angular coordinates, using {@link Attitude Attitude} convention
  473.      * (i.e. from inertial frame to spacecraft frame)
  474.      * @return the attitude data in CCSDS units
  475.      */
  476.     public abstract String[] createDataFields(boolean isFirst, boolean isExternal2SpacecraftBody,
  477.                                               RotationOrder eulerRotSequence, boolean isSpacecraftBodyRate,
  478.                                               TimeStampedAngularCoordinates attitude);

  480.     /**
  481.      * Get the angular coordinates corresponding to the attitude data.
  482.      * <p>
  483.      * This method assumes the text fields are in CCSDS units and will convert to SI units.
  484.      * </p>
  485.      * @param isFirst if true the first quaternion component is the scalar component
  486.      * @param isExternal2SpacecraftBody true attitude is from external frame to spacecraft body frame
  487.      * @param eulerRotSequence sequance of Euler angles
  488.      * @param isSpacecraftBodyRate if true Euler rates are specified in spacecraft body frame
  489.      * @param context context binding
  490.      * @param fields raw data fields
  491.      * @return the angular coordinates, using {@link Attitude Attitude} convention
  492.      * (i.e. from inertial frame to spacecraft frame)
  493.      */
  494.     public TimeStampedAngularCoordinates parse(final boolean isFirst, final boolean isExternal2SpacecraftBody,
  495.                                                final RotationOrder eulerRotSequence, final boolean isSpacecraftBodyRate,
  496.                                                final ContextBinding context, final String[] fields) {

  498.         // parse the text fields
  499.         final AbsoluteDate date = context.getTimeSystem().getConverter(context).parse(fields[0]);
  500.         final double[] components = new double[fields.length - 1];
  501.         for (int i = 0; i < components.length; ++i) {
  502.             components[i] = units[i].toSI(Double.parseDouble(fields[i + 1]));
  503.         }

  505.         // build the coordinates
  506.         return build(isFirst, isExternal2SpacecraftBody, eulerRotSequence, isSpacecraftBodyRate,
  507.                      date, components);

  509.     }

  511.     /** Get the angular coordinates corresponding to the attitude data.
  512.      * @param isFirst if true the first quaternion component is the scalar component
  513.      * @param isExternal2SpacecraftBody true attitude is from external frame to spacecraft body frame
  514.      * @param eulerRotSequence sequance of Euler angles
  515.      * @param isSpacecraftBodyRate if true Euler rates are specified in spacecraft body frame
  516.      * @param date entry date
  517.      * @param components entry components with CCSDS units (i.e. angles
  518.      * <em>must</em> still be in degrees here), semantic depends on attitude type
  519.      * @return the angular coordinates, using {@link Attitude Attitude} convention
  520.      * (i.e. from inertial frame to spacecraft frame)
  521.      */
  522.     public abstract TimeStampedAngularCoordinates build(boolean isFirst, boolean isExternal2SpacecraftBody,
  523.                                                         RotationOrder eulerRotSequence, boolean isSpacecraftBodyRate,
  524.                                                         AbsoluteDate date, double... components);

  526.     /**
  527.      * Get the angular derivative filter corresponding to the attitude data.
  528.      * @return the angular derivative filter corresponding to the attitude data
  529.      */
  530.     public AngularDerivativesFilter getAngularDerivativesFilter() {
  531.         return filter;
  532.     }

  534.     private String[] formatData(final double[] data) {
  535.         final String[] fields = new String[data.length];
  536.         for (int i = 0; i < data.length; ++i) {
  537.             fields[i] = AccurateFormatter.format(units[i].fromSI(data[i]));
  538.         }
  539.         return fields;
  540.     }

  542.     /** Convert a rotation rate for Orekit convention to metadata convention.
  543.      * @param isSpacecraftBodyRate if true Euler rates are specified in spacecraft body frame
  544.      * @param rate rotation rate from Orekit attitude
  545.      * @param rotation corresponding rotation
  546.      * @return rotation rate in metadata convention
  547.      */
  548.     private Vector3D metadataRate(final boolean isSpacecraftBodyRate, final Vector3D rate, final Rotation rotation) {
  549.         return isSpacecraftBodyRate ? rate : rotation.applyInverseTo(rate);
  550.     }

  552.     /** Convert a rotation rate for metadata convention to Orekit convention.
  553.      * @param isSpacecraftBodyRate if true Euler rates are specified in spacecraft body frame
  554.      * @param rate rotation rate read from the data line
  555.      * @param rotation corresponding rotation
  556.      * @return rotation rate in Orekit convention (i.e. in spacecraft body local frame)
  557.      */
  558.     private Vector3D orekitRate(final boolean isSpacecraftBodyRate, final Vector3D rate, final Rotation rotation) {
  559.         return isSpacecraftBodyRate ? rate : rotation.applyTo(rate);
  560.     }

  562. }
Created with JaCoCo 0.8.8.202204050719