AbstractFieldTimeInterpolator.java

  1. /* Copyright 2002-2023 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.time;

  19. import org.hipparchus.CalculusFieldElement;
  20. import org.hipparchus.Field;
  21. import org.hipparchus.util.FastMath;
  22. import org.orekit.errors.OrekitIllegalArgumentException;
  23. import org.orekit.errors.OrekitMessages;
  24. import org.orekit.utils.ImmutableFieldTimeStampedCache;

  26. import java.util.Collection;
  27. import java.util.Collections;
  28. import java.util.List;
  29. import java.util.stream.Collectors;
  30. import java.util.stream.Stream;

  32. /**
  33.  * Abstract class for time interpolator.
  34.  *
  35.  * @param <T> interpolated time stamped type
  36.  * @param <KK> type of the field element
  37.  *
  38.  * @author Vincent Cucchietti
  39.  */
  40. public abstract class AbstractFieldTimeInterpolator<T extends FieldTimeStamped<KK>, KK extends CalculusFieldElement<KK>>
  41.         implements FieldTimeInterpolator<T, KK> {

  43.     /** Default extrapolation time threshold: 1ms. */
  44.     public static final double DEFAULT_EXTRAPOLATION_THRESHOLD_SEC = 1e-3;

  46.     /** Default number of interpolation points. */
  47.     public static final int DEFAULT_INTERPOLATION_POINTS = 2;

  49.     /** The extrapolation threshold beyond which the propagation will fail. */
  50.     private final double extrapolationThreshold;

  52.     /** Neighbor size. */
  53.     private final int interpolationPoints;

  55.     /**
  56.      * Constructor.
  57.      *
  58.      * @param interpolationPoints number of interpolation points
  59.      * @param extrapolationThreshold extrapolation threshold beyond which the propagation will fail
  60.      */
  61.     public AbstractFieldTimeInterpolator(final int interpolationPoints, final double extrapolationThreshold) {
  62.         this.interpolationPoints    = interpolationPoints;
  63.         this.extrapolationThreshold = extrapolationThreshold;
  64.     }

  66.     /**
  67.      * Method checking if given interpolator is compatible with given sample size.
  68.      *
  69.      * @param interpolator interpolator
  70.      * @param sampleSize sample size
  71.      * @param <T> type of the field elements
  72.      */
  73.     public static <T extends CalculusFieldElement<T>> void checkInterpolatorCompatibilityWithSampleSize(
  74.             final FieldTimeInterpolator<? extends FieldTimeStamped<T>, T> interpolator,
  75.             final int sampleSize) {

  77.         // Retrieve all sub-interpolators (or a singleton list with given interpolator if there are no sub-interpolators)
  78.         final List<FieldTimeInterpolator<? extends FieldTimeStamped<T>, T>> subInterpolators =
  79.                 interpolator.getSubInterpolators();
  80.         for (final FieldTimeInterpolator<? extends FieldTimeStamped<T>, T> subInterpolator : subInterpolators) {
  81.             if (sampleSize < subInterpolator.getNbInterpolationPoints()) {
  82.                 throw new OrekitIllegalArgumentException(OrekitMessages.NOT_ENOUGH_DATA, sampleSize);
  83.             }
  84.         }
  85.     }

  87.     /** {@inheritDoc} */
  88.     @Override
  89.     public T interpolate(final FieldAbsoluteDate<KK> interpolationDate, final Stream<T> sample) {
  90.         return interpolate(interpolationDate, sample.collect(Collectors.toList()));
  91.     }

  93.     /** {@inheritDoc}. */
  94.     @Override
  95.     public T interpolate(final FieldAbsoluteDate<KK> interpolationDate, final Collection<T> sample) {
  96.         final InterpolationData interpolationData = new InterpolationData(interpolationDate, sample);
  97.         return interpolate(interpolationData);
  98.     }

  100.     /** {@inheritDoc} */
  101.     public List<FieldTimeInterpolator<? extends FieldTimeStamped<KK>, KK>> getSubInterpolators() {
  102.         return Collections.singletonList(this);
  103.     }

  105.     /** {@inheritDoc} */
  106.     public int getNbInterpolationPoints() {
  107.         return interpolationPoints;
  108.     }

  110.     /** {@inheritDoc} */
  111.     public double getExtrapolationThreshold() {
  112.         return extrapolationThreshold;
  113.     }

  115.     /**
  116.      * Add all lowest level sub interpolators to the sub interpolator list.
  117.      *
  118.      * @param subInterpolator optional sub interpolator to add
  119.      * @param subInterpolators list of sub interpolators
  120.      * @param <S> type of the field element
  121.      */
  122.     protected <S extends CalculusFieldElement<S>> void addOptionalSubInterpolatorIfDefined(
  123.             final FieldTimeInterpolator<? extends FieldTimeStamped<S>, S> subInterpolator,
  124.             final List<FieldTimeInterpolator<? extends FieldTimeStamped<S>, S>> subInterpolators) {
  125.         // Add all lowest level sub interpolators
  126.         if (subInterpolator != null) {
  127.             subInterpolators.addAll(subInterpolator.getSubInterpolators());
  128.         }
  129.     }

  131.     /**
  132.      * Interpolate instance from given interpolation data.
  133.      *
  134.      * @param interpolationData interpolation data
  135.      *
  136.      * @return interpolated instance from given interpolation data.
  137.      */
  138.     protected abstract T interpolate(InterpolationData interpolationData);

  140.     /**
  141.      * Get the time parameter which lies between [0:1] by normalizing the difference between interpolating time and previous
  142.      * date by the Δt between tabulated values.
  143.      *
  144.      * @param interpolatingTime time at which we want to interpolate a value (between previous and next tabulated dates)
  145.      * @param previousDate previous tabulated value date
  146.      * @param nextDate next tabulated value date
  147.      *
  148.      * @return time parameter which lies between [0:1]
  149.      */
  150.     protected KK getTimeParameter(final FieldAbsoluteDate<KK> interpolatingTime,
  151.                                   final FieldAbsoluteDate<KK> previousDate,
  152.                                   final FieldAbsoluteDate<KK> nextDate) {

  154.         return interpolatingTime.durationFrom(previousDate).divide(nextDate.getDate().durationFrom(previousDate));
  155.     }

  157.     /**
  158.      * Nested class used to store interpolation data.
  159.      * <p>
  160.      * It makes the interpolator thread safe.
  161.      */
  162.     public class InterpolationData {

  164.         /** Interpolation date. */
  165.         private final FieldAbsoluteDate<KK> interpolationDate;

  167.         /** Immutable time stamped cached samples. */
  168.         private final ImmutableFieldTimeStampedCache<T, KK> cachedSamples;

  170.         /** Unmodifiable list of neighbors. */
  171.         private final List<T> neighborList;

  173.         /** Field of the element. */
  174.         private final Field<KK> field;

  176.         /** Fielded zero. */
  177.         private final KK zero;

  179.         /** Fielded one. */
  180.         private final KK one;

  182.         /**
  183.          * Constructor.
  184.          *
  185.          * @param interpolationDate interpolation date
  186.          * @param sample time stamped sample
  187.          */
  188.         protected InterpolationData(final FieldAbsoluteDate<KK> interpolationDate, final Collection<T> sample) {
  189.             try {
  190.                 // Handle specific case that is not handled by the immutable time stamped cache constructor
  191.                 if (sample.size() < 2) {
  192.                     throw new OrekitIllegalArgumentException(OrekitMessages.NOT_ENOUGH_DATA,
  193.                                                              sample.size());
  194.                 }

  196.                 // Create immutable time stamped cache
  197.                 cachedSamples = new ImmutableFieldTimeStampedCache<>(interpolationPoints, sample);

  199.                 // Find neighbors
  200.                 final FieldAbsoluteDate<KK> central         = getCentralDate(interpolationDate);
  201.                 final Stream<T>             neighborsStream = cachedSamples.getNeighbors(central);

  203.                 // Extract field and useful terms
  204.                 this.field = interpolationDate.getField();
  205.                 this.zero  = field.getZero();
  206.                 this.one   = field.getOne();

  208.                 // Convert to unmodifiable list
  209.                 neighborList = Collections.unmodifiableList(neighborsStream.collect(Collectors.toList()));

  211.                 // Store interpolation date
  212.                 this.interpolationDate = interpolationDate;
  213.             }
  214.             catch (OrekitIllegalArgumentException exception) {
  215.                 throw new OrekitIllegalArgumentException(OrekitMessages.NOT_ENOUGH_DATA, sample.size());
  216.             }
  217.         }

  219.         /**
  220.          * Get the central date to use to find neighbors while taking into account extrapolation threshold.
  221.          *
  222.          * @param date interpolation date
  223.          *
  224.          * @return central date to use to find neighbors
  225.          */
  226.         protected FieldAbsoluteDate<KK> getCentralDate(final FieldAbsoluteDate<KK> date) {
  227.             final FieldAbsoluteDate<KK> central;
  228.             final FieldAbsoluteDate<KK> minDate = cachedSamples.getEarliest().getDate();
  229.             final FieldAbsoluteDate<KK> maxDate = cachedSamples.getLatest().getDate();

  231.             if (date.compareTo(minDate) < 0 &&
  232.                     FastMath.abs(date.durationFrom(minDate)).getReal() <= extrapolationThreshold) {
  233.                 // avoid TimeStampedCacheException as we are still within the tolerance before minDate
  234.                 central = minDate;
  235.             } else if (date.compareTo(maxDate) > 0 &&
  236.                     FastMath.abs(date.durationFrom(maxDate)).getReal() <= extrapolationThreshold) {
  237.                 // avoid TimeStampedCacheException as we are still within the tolerance after maxDate
  238.                 central = maxDate;
  239.             } else {
  240.                 central = date;
  241.             }

  243.             return central;
  244.         }

  246.         /** Get interpolation date.
  247.          * @return interpolation date
  248.          */
  249.         public FieldAbsoluteDate<KK> getInterpolationDate() {
  250.             return interpolationDate;
  251.         }

  253.         /** Get cached samples.
  254.          * @return cached samples
  255.          */
  256.         public ImmutableFieldTimeStampedCache<T, KK> getCachedSamples() {
  257.             return cachedSamples;
  258.         }

  260.         /** Get neighbor list.
  261.          * @return neighbor list
  262.          */
  263.         public List<T> getNeighborList() {
  264.             return neighborList;
  265.         }

  267.         /** Get field.
  268.          * @return field
  269.          */
  270.         public Field<KK> getField() {
  271.             return field;
  272.         }

  274.         /** Get zero.
  275.          * @return zero
  276.          */
  277.         public KK getZero() {
  278.             return zero;
  279.         }

  281.         /** Get one.
  282.          * @return one
  283.          */
  284.         public KK getOne() {
  285.             return one;
  286.         }
  287.     }
  288. }
Created with JaCoCo 0.8.11.202310140853