ThreeEighthesFieldStateInterpolator.java

  1. /*
  2.  * Licensed to the Apache Software Foundation (ASF) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * The ASF 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.  *      https://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.  */

  18. /*
  19.  * This is not the original file distributed by the Apache Software Foundation
  20.  * It has been modified by the Hipparchus project
  21.  */

  23. package org.hipparchus.ode.nonstiff.interpolators;

  25. import org.hipparchus.CalculusFieldElement;
  26. import org.hipparchus.Field;
  27. import org.hipparchus.ode.FieldEquationsMapper;
  28. import org.hipparchus.ode.FieldODEStateAndDerivative;
  29. import org.hipparchus.ode.nonstiff.ThreeEighthesFieldIntegrator;

  31. /**
  32.  * This class implements a step interpolator for the 3/8 fourth
  33.  * order Runge-Kutta integrator.
  34.  *
  35.  * <p>This interpolator allows to compute dense output inside the last
  36.  * step computed. The interpolation equation is consistent with the
  37.  * integration scheme :</p>
  38.  * <ul>
  39.  *   <li>Using reference point at step start:<br>
  40.  *     y(t<sub>n</sub> + &theta; h) = y (t<sub>n</sub>)
  41.  *                      + &theta; (h/8) [ (8 - 15 &theta; +  8 &theta;<sup>2</sup>) y'<sub>1</sub>
  42.  *                                     +  3 * (15 &theta; - 12 &theta;<sup>2</sup>) y'<sub>2</sub>
  43.  *                                     +        3 &theta;                           y'<sub>3</sub>
  44.  *                                     +      (-3 &theta; +  4 &theta;<sup>2</sup>) y'<sub>4</sub>
  45.  *                                    ]
  46.  *   </li>
  47.  *   <li>Using reference point at step end:<br>
  48.  *     y(t<sub>n</sub> + &theta; h) = y (t<sub>n</sub> + h)
  49.  *                      - (1 - &theta;) (h/8) [(1 - 7 &theta; + 8 &theta;<sup>2</sup>) y'<sub>1</sub>
  50.  *                                         + 3 (1 +   &theta; - 4 &theta;<sup>2</sup>) y'<sub>2</sub>
  51.  *                                         + 3 (1 +   &theta;)                         y'<sub>3</sub>
  52.  *                                         +   (1 +   &theta; + 4 &theta;<sup>2</sup>) y'<sub>4</sub>
  53.  *                                          ]
  54.  *   </li>
  55.  * </ul>
  56.  *
  57.  * <p>where &theta; belongs to [0 ; 1] and where y'<sub>1</sub> to y'<sub>4</sub> are the four
  58.  * evaluations of the derivatives already computed during the
  59.  * step.</p>
  60.  *
  61.  * @see ThreeEighthesFieldIntegrator
  62.  * @param <T> the type of the field elements
  63.  */

  65. public class ThreeEighthesFieldStateInterpolator<T extends CalculusFieldElement<T>>
  66.       extends RungeKuttaFieldStateInterpolator<T> {

  68.     /** Simple constructor.
  69.      * @param field field to which the time and state vector elements belong
  70.      * @param forward integration direction indicator
  71.      * @param yDotK slopes at the intermediate points
  72.      * @param globalPreviousState start of the global step
  73.      * @param globalCurrentState end of the global step
  74.      * @param softPreviousState start of the restricted step
  75.      * @param softCurrentState end of the restricted step
  76.      * @param mapper equations mapper for the all equations
  77.      */
  78.     public ThreeEighthesFieldStateInterpolator(final Field<T> field, final boolean forward,
  79.                                                final T[][] yDotK,
  80.                                                final FieldODEStateAndDerivative<T> globalPreviousState,
  81.                                                final FieldODEStateAndDerivative<T> globalCurrentState,
  82.                                                final FieldODEStateAndDerivative<T> softPreviousState,
  83.                                                final FieldODEStateAndDerivative<T> softCurrentState,
  84.                                                final FieldEquationsMapper<T> mapper) {
  85.         super(field, forward, yDotK, globalPreviousState, globalCurrentState, softPreviousState, softCurrentState,
  86.                 mapper);
  87.     }

  89.     /** {@inheritDoc} */
  90.     @Override
  91.     protected ThreeEighthesFieldStateInterpolator<T> create(final Field<T> newField, final boolean newForward, final T[][] newYDotK,
  92.                                                             final FieldODEStateAndDerivative<T> newGlobalPreviousState,
  93.                                                             final FieldODEStateAndDerivative<T> newGlobalCurrentState,
  94.                                                             final FieldODEStateAndDerivative<T> newSoftPreviousState,
  95.                                                             final FieldODEStateAndDerivative<T> newSoftCurrentState,
  96.                                                             final FieldEquationsMapper<T> newMapper) {
  97.         return new ThreeEighthesFieldStateInterpolator<>(newField, newForward, newYDotK,
  98.                                                           newGlobalPreviousState, newGlobalCurrentState,
  99.                                                           newSoftPreviousState, newSoftCurrentState,
  100.                                                           newMapper);
  101.     }

  103.     /** {@inheritDoc} */
  104.     @SuppressWarnings("unchecked")
  105.     @Override
  106.     protected FieldODEStateAndDerivative<T> computeInterpolatedStateAndDerivatives(final FieldEquationsMapper<T> mapper,
  107.                                                                                    final T time, final T theta,
  108.                                                                                    final T thetaH, final T oneMinusThetaH) {

  110.         final T coeffDot3  = theta.multiply(0.75);
  111.         final T coeffDot1  = coeffDot3.multiply(theta.multiply(4).subtract(5)).add(1);
  112.         final T coeffDot2  = coeffDot3.multiply(theta.multiply(-6).add(5));
  113.         final T coeffDot4  = coeffDot3.multiply(theta.multiply(2).subtract(1));
  114.         final T[] interpolatedState;
  115.         final T[] interpolatedDerivatives;

  117.         if (getGlobalPreviousState() != null && theta.getReal() <= 0.5) {
  118.             final T s          = thetaH.divide(8);
  119.             final T fourTheta2 = theta.multiply(theta).multiply(4);
  120.             final T coeff1     = s.multiply(fourTheta2.multiply(2).subtract(theta.multiply(15)).add(8));
  121.             final T coeff2     = s.multiply(theta.multiply(5).subtract(fourTheta2)).multiply(3);
  122.             final T coeff3     = s.multiply(theta).multiply(3);
  123.             final T coeff4     = s.multiply(fourTheta2.subtract(theta.multiply(3)));
  124.             interpolatedState       = previousStateLinearCombination(coeff1, coeff2, coeff3, coeff4);
  125.             interpolatedDerivatives = derivativeLinearCombination(coeffDot1, coeffDot2, coeffDot3, coeffDot4);
  126.         } else {
  127.             final T s          = oneMinusThetaH.divide(-8);
  128.             final T fourTheta2 = theta.multiply(theta).multiply(4);
  129.             final T thetaPlus1 = theta.add(1);
  130.             final T coeff1     = s.multiply(fourTheta2.multiply(2).subtract(theta.multiply(7)).add(1));
  131.             final T coeff2     = s.multiply(thetaPlus1.subtract(fourTheta2)).multiply(3);
  132.             final T coeff3     = s.multiply(thetaPlus1).multiply(3);
  133.             final T coeff4     = s.multiply(thetaPlus1.add(fourTheta2));
  134.             interpolatedState       = currentStateLinearCombination(coeff1, coeff2, coeff3, coeff4);
  135.             interpolatedDerivatives = derivativeLinearCombination(coeffDot1, coeffDot2, coeffDot3, coeffDot4);
  136.         }

  138.         return mapper.mapStateAndDerivative(time, interpolatedState, interpolatedDerivatives);

  140.     }

  142. }
Created with JaCoCo 0.8.12.202403310830