AttitudeEntryKey.java

  1. /* Copyright 2002-2021 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.aem;

  18. import org.orekit.files.ccsds.definitions.Units;
  19. import org.orekit.files.ccsds.utils.ContextBinding;
  20. import org.orekit.files.ccsds.utils.lexical.ParseToken;
  21. import org.orekit.utils.units.Unit;


  22. /** Keys for {@link AttitudeEntry attitude entries} in XML messages.
  23.  * @author Luc Maisonobe
  24.  * @since 11.0
  25.  */
  26. public enum AttitudeEntryKey {

  27.     /** Quaternion state sub-section. */
  28.     quaternionState((token, context, container) -> true),

  29.     /** Quaternion/derivative sub-section. */
  30.     quaternionDerivative((token, context, container) -> true),

  31.     /** Quaternion/rate sub-section. */
  32.     quaternionEulerRate((token, context, container) -> true),

  33.     /** Euler angle sub-section. */
  34.     eulerAngle((token, context, container) -> true),

  35.     /** Euler angle/rate sub-section. */
  36.     eulerAngleRate((token, context, container) -> true),

  37.     /** Spin sub-section. */
  38.     spin((token, context, container) -> true),

  39.     /** Spin/nutation sub-section. */
  40.     spinNutation((token, context, container) -> true),

  41.     /** Quaternion sub-sub-section. */
  42.     quaternion((token, context, container) -> true),

  43.     /** Quaternion rate sub-sub-section. */
  44.     quaternionRate((token, context, container) -> true),

  45.     /** Rotation angles sub-sub-section. */
  46.     rotationAngles((token, context, container) -> true),

  47.     /** Rotation rates sub-sub-section. */
  48.     rotationRates((token, context, container) -> true),

  49.     /** Entry epoch. */
  50.     EPOCH((token, context, container) -> token.processAsDate(container::setEpoch, context)),

  51.     /** Quaternion first vectorial component. */
  52.     Q1((token, context, container) -> token.processAsIndexedDouble(container.getMetadata().isFirst() ? 1 : 0,
  53.                                                                    Unit.ONE, context.getParsedUnitsBehavior(),
  54.                                                                    container::setComponent)),

  55.     /** Quaternion second vectorial component. */
  56.     Q2((token, context, container) -> token.processAsIndexedDouble(container.getMetadata().isFirst() ? 2 : 1,
  57.                                                                    Unit.ONE, context.getParsedUnitsBehavior(),
  58.                                                                    container::setComponent)),

  59.     /** Quaternion third vectorial component. */
  60.     Q3((token, context, container) -> token.processAsIndexedDouble(container.getMetadata().isFirst() ? 3 : 2,
  61.                                                                    Unit.ONE, context.getParsedUnitsBehavior(),
  62.                                                                    container::setComponent)),

  63.     /** Quaternion scalar component. */
  64.     QC((token, context, container) -> token.processAsIndexedDouble(container.getMetadata().isFirst() ? 0 : 3,
  65.                                                                    Unit.ONE, context.getParsedUnitsBehavior(),
  66.                                                                    container::setComponent)),

  67.     /** Quaternion first vectorial component. */
  68.     Q1_DOT((token, context, container) -> token.processAsIndexedDouble(container.getMetadata().isFirst() ? 5 : 4,
  69.                                                                        Units.ONE_PER_S, context.getParsedUnitsBehavior(),
  70.                                                                        container::setComponent)),

  71.     /** Quaternion second vectorial component. */
  72.     Q2_DOT((token, context, container) -> token.processAsIndexedDouble(container.getMetadata().isFirst() ? 6 : 5,
  73.                                                                        Units.ONE_PER_S, context.getParsedUnitsBehavior(),
  74.                                                                        container::setComponent)),

  75.     /** Quaternion third vectorial component. */
  76.     Q3_DOT((token, context, container) -> token.processAsIndexedDouble(container.getMetadata().isFirst() ? 7 : 6,
  77.                                                                        Units.ONE_PER_S, context.getParsedUnitsBehavior(),
  78.                                                                        container::setComponent)),

  79.     /** Quaternion scalar component. */
  80.     QC_DOT((token, context, container) -> token.processAsIndexedDouble(container.getMetadata().isFirst() ? 4 : 7,
  81.                                                                        Units.ONE_PER_S, context.getParsedUnitsBehavior(),
  82.                                                                        container::setComponent)),

  83.     /** Rotation about X axis. */
  84.     X_ANGLE((token, context, container) -> token.processAsLabeledDouble('X', Unit.DEGREE, context.getParsedUnitsBehavior(),
  85.                                                                         container::setAngle)),

  86.     /** Rotation about Y axis. */
  87.     Y_ANGLE((token, context, container) -> token.processAsLabeledDouble('Y', Unit.DEGREE, context.getParsedUnitsBehavior(),
  88.                                                                         container::setAngle)),

  89.     /** Rotation about Z axis. */
  90.     Z_ANGLE((token, context, container) -> token.processAsLabeledDouble('Z', Unit.DEGREE, context.getParsedUnitsBehavior(),
  91.                                                                         container::setAngle)),

  92.     /** Rotation about X axis. */
  93.     X_RATE((token, context, container) -> token.processAsLabeledDouble('X',
  94.                                                                        Units.DEG_PER_S, context.getParsedUnitsBehavior(),
  95.                                                                        container::setRate)),

  96.     /** Rotation about Y axis. */
  97.     Y_RATE((token, context, container) -> token.processAsLabeledDouble('Y',
  98.                                                                        Units.DEG_PER_S, context.getParsedUnitsBehavior(),
  99.                                                                        container::setRate)),

  100.     /** Rotation about Z axis. */
  101.     Z_RATE((token, context, container) -> token.processAsLabeledDouble('Z',
  102.                                                                        Units.DEG_PER_S, context.getParsedUnitsBehavior(),
  103.                                                                        container::setRate)),

  104.     /** Right ascension of spin axis vector. */
  105.     SPIN_ALPHA((token, context, container) -> token.processAsIndexedDouble(0, Unit.DEGREE, context.getParsedUnitsBehavior(),
  106.                                                                            container::setComponent)),

  107.     /** Declination of spin axis vector. */
  108.     SPIN_DELTA((token, context, container) -> token.processAsIndexedDouble(1, Unit.DEGREE, context.getParsedUnitsBehavior(),
  109.                                                                            container::setComponent)),

  110.     /** Phase of satellite about spin axis. */
  111.     SPIN_ANGLE((token, context, container) -> token.processAsIndexedDouble(2, Unit.DEGREE, context.getParsedUnitsBehavior(),
  112.                                                                            container::setComponent)),

  113.     /** angular velocity of satellite around spin axis. */
  114.     SPIN_ANGLE_VEL((token, context, container) -> token.processAsIndexedDouble(3, Units.DEG_PER_S, context.getParsedUnitsBehavior(),
  115.                                                                                container::setComponent)),

  116.     /** Nutation angle entry. */
  117.     NUTATION((token, context, container) -> token.processAsIndexedDouble(4, Units.DEG_PER_S, context.getParsedUnitsBehavior(),
  118.                                                                          container::setComponent)),

  119.     /** Nutation period entry. */
  120.     NUTATION_PER((token, context, container) -> token.processAsIndexedDouble(5, Unit.SECOND, context.getParsedUnitsBehavior(),
  121.                                                                              container::setComponent)),

  122.     /** Nutation phase entry. */
  123.     NUTATION_PHASE((token, context, container) -> token.processAsIndexedDouble(6, Unit.DEGREE, context.getParsedUnitsBehavior(),
  124.                                                                                container::setComponent));

  125.     /** Processing method. */
  126.     private final TokenProcessor processor;

  127.     /** Simple constructor.
  128.      * @param processor processing method
  129.      */
  130.     AttitudeEntryKey(final TokenProcessor processor) {
  131.         this.processor = processor;
  132.     }

  133.     /** Process an token.
  134.      * @param token token to process
  135.      * @param context context binding
  136.      * @param container container to fill
  137.      * @return true of token was accepted
  138.      */
  139.     public boolean process(final ParseToken token, final ContextBinding context, final AttitudeEntry container) {
  140.         return processor.process(token, context, container);
  141.     }

  142.     /** Interface for processing one token. */
  143.     interface TokenProcessor {
  144.         /** Process one token.
  145.          * @param token token to process
  146.          * @param context context binding
  147.          * @param container container to fill
  148.          * @return true of token was accepted
  149.          */
  150.         boolean process(ParseToken token, ContextBinding context, AttitudeEntry container);
  151.     }

  152. }