FieldAbstractGaussianContributionContext.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.propagation.semianalytical.dsst.forces;

  19. import org.hipparchus.CalculusFieldElement;
  20. import org.hipparchus.util.FastMath;
  21. import org.orekit.propagation.semianalytical.dsst.utilities.FieldAuxiliaryElements;

  23. /**
  24.  * This class is a container for the common "field" parameters used in {@link AbstractGaussianContribution}.
  25.  * <p>
  26.  * It performs parameters initialization at each integration step for the Gaussian contributions
  27.  * </p>
  28.  * @author Bryan Cazabonne
  29.  * @since 10.0
  30.  */
  31. public class FieldAbstractGaussianContributionContext<T extends CalculusFieldElement<T>> extends FieldForceModelContext<T> {

  33.     // CHECKSTYLE: stop VisibilityModifier check

  35.     /** 2 / (n² * a) . */
  36.     protected T ton2a;

  38.     /** 1 / A . */
  39.     protected T ooA;

  41.     /** 1 / (A * B) . */
  42.     protected T ooAB;

  44.     /** C / (2 * A * B) . */
  45.     protected T co2AB;

  47.     /** 1 / (1 + B) . */
  48.     protected T ooBpo;

  50.     /** 1 / μ . */
  51.     protected T ooMu;

  53.     /** A = sqrt(μ * a). */
  54.     private final T A;

  56.     /** Keplerian mean motion. */
  57.     private final T n;

  59.     /** Central attraction coefficient. */
  60.     private T mu;

  62.     // CHECKSTYLE: resume VisibilityModifier check

  64.     /**
  65.      * Simple constructor.
  66.      *
  67.      * @param auxiliaryElements auxiliary elements related to the current orbit
  68.      * @param parameters        parameters values of the force model parameters
  69.      */
  70.     FieldAbstractGaussianContributionContext(final FieldAuxiliaryElements<T> auxiliaryElements, final T[] parameters) {

  72.         super(auxiliaryElements);

  74.         // mu driver corresponds to the last term of parameters driver array
  75.         mu = parameters[parameters.length - 1];

  77.         // Keplerian mean motion
  78.         final T absA = FastMath.abs(auxiliaryElements.getSma());
  79.         n = FastMath.sqrt(mu.divide(absA)).divide(absA);
  80.         // sqrt(μ * a)
  81.         A = FastMath.sqrt(mu.multiply(auxiliaryElements.getSma()));
  82.         // 1 / A
  83.         ooA = A.reciprocal();
  84.         // 1 / AB
  85.         ooAB = ooA.divide(auxiliaryElements.getB());
  86.         // C / 2AB
  87.         co2AB = auxiliaryElements.getC().multiply(ooAB).divide(2.);
  88.         // 1 / (1 + B)
  89.         ooBpo = auxiliaryElements.getB().add(1.).reciprocal();
  90.         // 2 / (n² * a)
  91.         ton2a = (n.multiply(n).multiply(auxiliaryElements.getSma())).divide(2.).reciprocal();
  92.         // 1 / mu
  93.         ooMu = mu.reciprocal();

  95.     }

  97.     /** Get central attraction coefficient.
  98.      * @return mu
  99.      */
  100.     public T getMu() {
  101.         return mu;
  102.     }

  104.     /** Get A = sqrt(μ * a).
  105.      * @return A
  106.      */
  107.     public T getA() {
  108.         return A;
  109.     }

  111.     /** Get ooA = 1 / A.
  112.      * @return ooA
  113.      */
  114.     public T getOOA() {
  115.         return ooA;
  116.     }

  118.     /** Get ooAB = 1 / (A * B).
  119.      * @return ooAB
  120.      */
  121.     public T getOOAB() {
  122.         return ooAB;
  123.     }

  125.     /** Get co2AB = C / 2AB.
  126.      * @return co2AB
  127.      */
  128.     public T getCo2AB() {
  129.         return co2AB;
  130.     }

  132.     /** Get ooBpo = 1 / (B + 1).
  133.      * @return ooBpo
  134.      */
  135.     public T getOoBpo() {
  136.         return ooBpo;
  137.     }

  139.     /** Get ton2a = 2 / (n² * a).
  140.      * @return ton2a
  141.      */
  142.     public T getTon2a() {
  143.         return ton2a;
  144.     }

  146.     /** Get ooMu = 1 / mu.
  147.      * @return ooMu
  148.      */
  149.     public T getOoMU() {
  150.         return ooMu;
  151.     }

  153.     /** Get the Keplerian mean motion.
  154.      * <p>The Keplerian mean motion is computed directly from semi major axis
  155.      * and central acceleration constant.</p>
  156.      * @return Keplerian mean motion in radians per second
  157.      */
  158.     public T getMeanMotion() {
  159.         return n;
  160.     }

  162. }
Created with JaCoCo 0.8.8.202204050719