HarmonicParametricAcceleration.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.hipparchus.util.MathUtils;
  23. import org.orekit.attitudes.AttitudeProvider;
  24. import org.orekit.errors.OrekitException;
  25. import org.orekit.errors.OrekitInternalError;
  26. import org.orekit.forces.empirical.HarmonicAccelerationModel;
  27. import org.orekit.propagation.FieldSpacecraftState;
  28. import org.orekit.propagation.SpacecraftState;
  29. import org.orekit.time.AbsoluteDate;
  30. import org.orekit.utils.ParameterDriver;

  32. /** This class implements a {@link AbstractParametricAcceleration parametric acceleration}
  33.  * with harmonic signed amplitude.
  34.  * @since 9.0
  35.  * @author Luc Maisonobe
  36.  * @deprecated as of 10.3, replaced by {@link HarmonicAccelerationModel}
  37.  */
  38. @Deprecated
  39. public class HarmonicParametricAcceleration extends AbstractParametricAcceleration {

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

  52.     /** Phase scaling factor.
  53.      * <p>
  54.      * 2⁻²³ is the order of magnitude of an angle corresponding to one meter along
  55.      * track for a Low Earth Orbiting satellite.
  56.      * </p>
  57.      * <p>
  58.      * We use a power of 2 to avoid numeric noise introduction
  59.      * in the multiplications/divisions sequences.
  60.      * </p>
  61.      */
  62.     private static final double PHASE_SCALE = FastMath.scalb(1.0, -23);

  64.     /** Drivers for the parameters. */
  65.     private final ParameterDriver[] drivers;

  67.     /** Reference date for computing phase. */
  68.     private AbsoluteDate referenceDate;

  70.     /** Angular frequency ω = 2kπ/T. */
  71.     private final double omega;

  73.     /** Simple constructor.
  74.      * <p>
  75.      * The signed amplitude of the acceleration is γ sin[2kπ(t-t₀)/T + φ], where
  76.      * γ is parameter {@code 0} and represents the full amplitude, t is current
  77.      * date, t₀ is reference date, {@code T} is fundamental period, {@code k} is
  78.      * harmonic multiplier, and φ is parameter {@code 1} and represents phase at t₀.
  79.      * The value t-t₀ is in seconds.
  80.      * </p>
  81.      * <p>
  82.      * The fundamental period {@code T} is often set to the Keplerian period of the
  83.      * orbit and the harmonic multiplier {@code k} is often set to 1 or 2. The model
  84.      * has two parameters, one for the full amplitude and one for the phase at reference
  85.      * date.
  86.      * </p>
  87.      * <p>
  88.      * The two parameters for this model are the full amplitude (parameter 0) and the
  89.      * phase at reference date (parameter 1). Their reference values (used also as the
  90.      * initial values) are both set to 0. User can change them before starting the
  91.      * propagation (or orbit determination) by calling {@link #getParametersDrivers()}
  92.      * and {@link ParameterDriver#setValue(double)}.
  93.      * </p>
  94.      * @param direction acceleration direction in defining frame
  95.      * @param isInertial if true, direction is defined in the same inertial
  96.      * frame used for propagation (i.e. {@link SpacecraftState#getFrame()}),
  97.      * otherwise direction is defined in spacecraft frame (i.e. using the
  98.      * propagation {@link
  99.      * org.orekit.propagation.Propagator#setAttitudeProvider(AttitudeProvider)
  100.      * attitude law})
  101.      * @param prefix prefix to use for parameter drivers
  102.      * @param referenceDate reference date for computing phase, if null
  103.      * the reference date will be automatically set at propagation start
  104.      * @param fundamentalPeriod fundamental period (typically set to initial orbit
  105.      * {@link org.orekit.orbits.Orbit#getKeplerianPeriod() Keplerian period})
  106.      * @param harmonicMultiplier multiplier to compute harmonic period from
  107.      * fundamental period)
  108.      */
  109.     public HarmonicParametricAcceleration(final Vector3D direction, final boolean isInertial,
  110.                                           final String prefix, final AbsoluteDate referenceDate,
  111.                                           final double fundamentalPeriod, final int harmonicMultiplier) {
  112.         this(direction, isInertial, null, prefix, referenceDate,
  113.              fundamentalPeriod, harmonicMultiplier);
  114.     }

  116.     /** Simple constructor.
  117.      * <p>
  118.      * The signed amplitude of the acceleration is γ sin[2kπ(t-t₀)/T + φ], where
  119.      * γ is parameter {@code 0} and represents the full amplitude, t is current
  120.      * date, t₀ is reference date, {@code T} is fundamental period, {@code k} is
  121.      * harmonic multiplier, and φ is parameter {@code 1} and represents phase at t₀.
  122.      * The value t-t₀ is in seconds.
  123.      * </p>
  124.      * <p>
  125.      * The fundamental period {@code T} is often set to the Keplerian period of the
  126.      * orbit and the harmonic multiplier {@code k} is often set to 1 or 2. The model
  127.      * has two parameters, one for the full amplitude and one for the phase at reference
  128.      * date.
  129.      * </p>
  130.      * <p>
  131.      * The two parameters for this model are the full amplitude (parameter 0) and the
  132.      * phase at reference date (parameter 1). Their reference values (used also as the
  133.      * initial values) are both set to 0. User can change them before starting the
  134.      * propagation (or orbit determination) by calling {@link #getParametersDrivers()}
  135.      * and {@link ParameterDriver#setValue(double)}.
  136.      * </p>
  137.      * @param direction acceleration direction in overridden spacecraft frame
  138.      * @param attitudeOverride provider for attitude used to compute acceleration
  139.      * direction
  140.      * @param prefix prefix to use for parameter drivers
  141.      * @param referenceDate reference date for computing phase, if null
  142.      * the reference date will be automatically set at propagation start
  143.      * @param fundamentalPeriod fundamental period (typically set to initial orbit
  144.      * {@link org.orekit.orbits.Orbit#getKeplerianPeriod() Keplerian period})
  145.      * @param harmonicMultiplier multiplier to compute harmonic period from
  146.      * fundamental period)
  147.      */
  148.     public HarmonicParametricAcceleration(final Vector3D direction, final AttitudeProvider attitudeOverride,
  149.                                           final String prefix, final AbsoluteDate referenceDate,
  150.                                           final double fundamentalPeriod, final int harmonicMultiplier) {
  151.         this(direction, false, attitudeOverride, prefix, referenceDate,
  152.              fundamentalPeriod, harmonicMultiplier);
  153.     }

  155.     /** Simple constructor.
  156.      * @param direction acceleration direction in overridden spacecraft frame
  157.      * @param isInertial if true, direction is defined in the same inertial
  158.      * frame used for propagation (i.e. {@link SpacecraftState#getFrame()}),
  159.      * otherwise direction is defined in spacecraft frame (i.e. using the
  160.      * propagation {@link
  161.      * org.orekit.propagation.Propagator#setAttitudeProvider(AttitudeProvider)
  162.      * attitude law})
  163.      * @param attitudeOverride provider for attitude used to compute acceleration
  164.      * direction
  165.      * @param prefix prefix to use for parameter drivers
  166.      * @param referenceDate reference date for computing polynomials, if null
  167.      * the reference date will be automatically set at propagation start
  168.      * @param fundamentalPeriod fundamental period (typically set to initial orbit
  169.      * {@link org.orekit.orbits.Orbit#getKeplerianPeriod() Keplerian period})
  170.      * @param harmonicMultiplier multiplier to compute harmonic period from
  171.      * fundamental period)
  172.      */
  173.     private HarmonicParametricAcceleration(final Vector3D direction, final boolean isInertial,
  174.                                            final AttitudeProvider attitudeOverride,
  175.                                            final String prefix, final AbsoluteDate referenceDate,
  176.                                            final double fundamentalPeriod, final int harmonicMultiplier) {
  177.         super(direction, isInertial, attitudeOverride);
  178.         this.referenceDate = referenceDate;
  179.         this.omega         = harmonicMultiplier * MathUtils.TWO_PI / fundamentalPeriod;
  180.         try {
  181.             drivers = new ParameterDriver[] {
  182.                 new ParameterDriver(prefix + " γ",
  183.                                     0.0, AMPLITUDE_SCALE, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY),
  184.                 new ParameterDriver(prefix + " φ",
  185.                                     0.0, PHASE_SCALE, -MathUtils.TWO_PI, MathUtils.TWO_PI),
  186.             };
  187.         } catch (OrekitException oe) {
  188.             // this should never happen as scales are hard-coded
  189.             throw new OrekitInternalError(oe);
  190.         }
  191.     }

  193.     /** {@inheritDoc} */
  194.     @Override
  195.     public boolean dependsOnPositionOnly() {
  196.         return isInertial();
  197.     }

  199.     /** {@inheritDoc} */
  200.     @Override
  201.     public void init(final SpacecraftState initialState, final AbsoluteDate target) {
  202.         if (referenceDate == null) {
  203.             referenceDate = initialState.getDate();
  204.         }
  205.     }

  207.     /** {@inheritDoc}.
  208.      * The signed amplitude of the acceleration is γ sin[2kπ(t-t₀)/T + φ], where
  209.      * γ is parameter {@code 0} and represents the full amplitude, t is current
  210.      * date, t₀ is reference date, {@code T} is fundamental period, {@code k} is
  211.      * harmonic multiplier, and φ is parameter {@code 1} and represents phase at t₀.
  212.      * The value t-t₀ is in seconds.
  213.      */
  214.     @Override
  215.     protected double signedAmplitude(final SpacecraftState state, final double[] parameters) {
  216.         final double dt = state.getDate().durationFrom(referenceDate);
  217.         return parameters[0] * FastMath.sin(dt * omega + parameters[1]);
  218.     }

  220.     /** {@inheritDoc}
  221.      * The signed amplitude of the acceleration is γ sin[2kπ(t-t₀)/T + φ], where
  222.      * γ is parameter {@code 0} and represents the full amplitude, t is current
  223.      * date, t₀ is reference date, {@code T} is fundamental period, {@code k} is
  224.      * harmonic multiplier, and φ is parameter {@code 1} and represents phase at t₀.
  225.      * The value t-t₀ is in seconds.
  226.      */
  227.     @Override
  228.     protected <T extends RealFieldElement<T>> T signedAmplitude(final FieldSpacecraftState<T> state, final T[] parameters) {
  229.         final T dt = state.getDate().durationFrom(referenceDate);
  230.         return parameters[0].multiply(dt.multiply(omega).add(parameters[1]).sin());
  231.     }

  233.     /** {@inheritDoc} */
  234.     @Override
  235.     public ParameterDriver[] getParametersDrivers() {
  236.         return drivers.clone();
  237.     }

  239. }
Created with JaCoCo 0.8.6.202009150832