PolynomialParametricAcceleration.java

  1. /* Copyright 2002-2020 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.forces;

  19. import org.hipparchus.RealFieldElement;
  20. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  21. import org.hipparchus.util.FastMath;
  22. import org.orekit.attitudes.AttitudeProvider;
  23. import org.orekit.forces.empirical.PolynomialAccelerationModel;
  24. import org.orekit.propagation.FieldSpacecraftState;
  25. import org.orekit.propagation.SpacecraftState;
  26. import org.orekit.time.AbsoluteDate;
  27. import org.orekit.utils.ParameterDriver;

  29. /** This class implements a {@link AbstractParametricAcceleration parametric acceleration}
  30.  * with polynomial signed amplitude.
  31.  * @since 9.0
  32.  * @author Luc Maisonobe
  33.  * @deprecated as of 10.3, replaced by {@link PolynomialAccelerationModel}
  34.  */
  35. @Deprecated
  36. public class PolynomialParametricAcceleration extends AbstractParametricAcceleration {

  38.     /** Acceleration scaling factor.
  39.      * <p>
  40.      * 2⁻²⁰ is the order of magnitude of third body perturbing acceleration.
  41.      * </p>
  42.      * <p>
  43.      * We use a power of 2 to avoid numeric noise introduction
  44.      * in the multiplications/divisions sequences.
  45.      * </p>
  46.      */
  47.     private static final double ACCELERATION_SCALE = FastMath.scalb(1.0, -20);

  49.     /** Drivers for the polynomial coefficients. */
  50.     private final ParameterDriver[] drivers;

  52.     /** Reference date for computing polynomials. */
  53.     private AbsoluteDate referenceDate;

  55.     /** Simple constructor.
  56.      * <p>
  57.      * The signed amplitude of the acceleration is ∑pₙ(t-t₀)ⁿ, where
  58.      * pₙ is parameter {@code n}, t is current date and t₀ is reference date.
  59.      * The value t-t₀ is in seconds.
  60.      * </p>
  61.      * <p>
  62.      * The {@code degree + 1} parameters for this model are the polynomial
  63.      * coefficients in increasing degree order. Their reference values (used
  64.      * also as the initial values) are all set to 0. User can change them before
  65.      * starting the propagation (or orbit determination) by calling {@link
  66.      * #getParametersDrivers()} and {@link ParameterDriver#setValue(double)}.
  67.      * </p>
  68.      * @param direction acceleration direction in defining frame
  69.      * @param isInertial if true, direction is defined in the same inertial
  70.      * frame used for propagation (i.e. {@link SpacecraftState#getFrame()}),
  71.      * otherwise direction is defined in spacecraft frame (i.e. using the
  72.      * propagation {@link
  73.      * org.orekit.propagation.Propagator#setAttitudeProvider(AttitudeProvider)
  74.      * attitude law})
  75.      * @param prefix prefix to use for parameter drivers
  76.      * @param referenceDate reference date for computing polynomials, if null
  77.      * the reference date will be automatically set at propagation start
  78.      * @param degree polynomial degree (i.e. a value of 0 corresponds to a constant acceleration)
  79.      */
  80.     public PolynomialParametricAcceleration(final Vector3D direction, final boolean isInertial,
  81.                                             final String prefix, final AbsoluteDate referenceDate,
  82.                                             final int degree) {
  83.         this(direction, isInertial, null, prefix, referenceDate, degree);
  84.     }

  86.     /** Simple constructor.
  87.      * <p>
  88.      * The signed amplitude of the acceleration is ∑pₙ(t-t₀)ⁿ, where
  89.      * pₙ is parameter {@code n}, t is current date and t₀ is reference date.
  90.      * The value t-t₀ is in seconds.
  91.      * </p>
  92.      * <p>
  93.      * The {@code degree + 1} parameters for this model are the polynomial
  94.      * coefficients in increasing degree order. Their reference values (used
  95.      * also as the initial values) are all set to 0. User can change them before
  96.      * starting the propagation (or orbit determination) by calling {@link
  97.      * #getParametersDrivers()} and {@link ParameterDriver#setValue(double)}.
  98.      * </p>
  99.      * @param direction acceleration direction in overridden spacecraft frame
  100.      * @param attitudeOverride provider for attitude used to compute acceleration
  101.      * direction
  102.      * @param prefix prefix to use for parameter drivers
  103.      * @param referenceDate reference date for computing polynomials, if null
  104.      * the reference date will be automatically set at propagation start
  105.      * @param degree polynomial degree (i.e. a value of 0 corresponds to a constant acceleration)
  106.      */
  107.     public PolynomialParametricAcceleration(final Vector3D direction, final AttitudeProvider attitudeOverride,
  108.                                             final String prefix, final AbsoluteDate referenceDate,
  109.                                             final int degree) {
  110.         this(direction, false, attitudeOverride, prefix, referenceDate, degree);
  111.     }

  113.     /** Simple constructor.
  114.      * @param direction acceleration direction in overridden spacecraft frame
  115.      * @param isInertial if true, direction is defined in the same inertial
  116.      * frame used for propagation (i.e. {@link SpacecraftState#getFrame()}),
  117.      * otherwise direction is defined in spacecraft frame (i.e. using the
  118.      * propagation {@link
  119.      * org.orekit.propagation.Propagator#setAttitudeProvider(AttitudeProvider)
  120.      * attitude law})
  121.      * @param attitudeOverride provider for attitude used to compute acceleration
  122.      * direction
  123.      * @param prefix prefix to use for parameter drivers
  124.      * @param referenceDate reference date for computing polynomials, if null
  125.      * the reference date will be automatically set at propagation start
  126.      * @param degree polynomial degree (i.e. a value of 0 corresponds to a constant acceleration)
  127.      */
  128.     private PolynomialParametricAcceleration(final Vector3D direction, final boolean isInertial,
  129.                                              final AttitudeProvider attitudeOverride,
  130.                                              final String prefix, final AbsoluteDate referenceDate,
  131.                                              final int degree) {
  132.         super(direction, isInertial, attitudeOverride);
  133.         this.referenceDate = referenceDate;
  134.         this.drivers       = new ParameterDriver[degree + 1];
  135.         for (int i = 0; i < drivers.length; ++i) {
  136.             drivers[i] = new ParameterDriver(prefix + "[" + i + "]", 0.0, ACCELERATION_SCALE,
  137.                                              Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY);
  138.         }
  139.     }

  141.     /** {@inheritDoc} */
  142.     @Override
  143.     public boolean dependsOnPositionOnly() {
  144.         return isInertial();
  145.     }

  147.     /** {@inheritDoc} */
  148.     @Override
  149.     public void init(final SpacecraftState initialState, final AbsoluteDate target) {
  150.         if (referenceDate == null) {
  151.             referenceDate = initialState.getDate();
  152.         }
  153.     }

  155.     /** {@inheritDoc} */
  156.     @Override
  157.     protected double signedAmplitude(final SpacecraftState state, final double[] parameters) {
  158.         final double dt = state.getDate().durationFrom(referenceDate);
  159.         double amplitude = 0;
  160.         for (int i = parameters.length - 1; i >= 0; --i) {
  161.             amplitude += amplitude * dt + parameters[i];
  162.         }
  163.         return amplitude;
  164.     }

  166.     /** {@inheritDoc} */
  167.     @Override
  168.     protected <T extends RealFieldElement<T>> T signedAmplitude(final FieldSpacecraftState<T> state, final T[] parameters) {
  169.         final T dt = state.getDate().durationFrom(referenceDate);
  170.         T amplitude = dt.getField().getZero();
  171.         for (int i = parameters.length - 1; i >= 0; --i) {
  172.             amplitude = amplitude.add(amplitude.multiply(dt).add(parameters[i]));
  173.         }
  174.         return amplitude;
  175.     }

  177.     /** {@inheritDoc} */
  178.     @Override
  179.     public ParameterDriver[] getParametersDrivers() {
  180.         return drivers.clone();
  181.     }

  183. }
Created with JaCoCo 0.8.6.202009150832