ShiftingTransformProvider.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.  */

  18. package org.orekit.frames;

  20. import java.io.Serializable;
  21. import java.util.HashMap;
  22. import java.util.Map;

  24. import org.hipparchus.Field;
  25. import org.hipparchus.CalculusFieldElement;
  26. import org.hipparchus.util.FastMath;
  27. import org.orekit.time.AbsoluteDate;
  28. import org.orekit.time.FieldAbsoluteDate;
  29. import org.orekit.utils.AngularDerivativesFilter;
  30. import org.orekit.utils.CartesianDerivativesFilter;
  31. import org.orekit.utils.GenericTimeStampedCache;

  33. /** Transform provider using thread-safe shifts on transforms sample.
  34.  * <p>
  35.  * The shifts take derivatives into account, up to user specified order.
  36.  * </p>
  37.  * @see GenericTimeStampedCache
  38.  * @see InterpolatingTransformProvider
  39.  * @since 7.1
  40.  * @author Luc Maisonobe
  41.  */
  42. public class ShiftingTransformProvider implements TransformProvider {

  44.     /** Serializable UID. */
  45.     private static final long serialVersionUID = 20150601L;

  47.     /** First level cache. */
  48.     private final InterpolatingTransformProvider interpolatingProvider;

  50.     /** Cache for sample points. */
  51.     private final transient GenericTimeStampedCache<Transform> cache;

  53.     /** Field caches for sample points. */
  54.     // we use Object as the value of fieldCaches because despite numerous attempts,
  55.     // we could not find a way to use GenericTimeStampedCache<FieldTransform<? extends CalculusFieldElement<?>>
  56.     // without the compiler complaining
  57.     private final transient Map<Field<? extends CalculusFieldElement<?>>, Object> fieldCaches;

  59.     /** Simple constructor.
  60.      * @param rawProvider provider for raw (non-interpolated) transforms
  61.      * @param cFilter filter for derivatives from the sample to use in interpolation
  62.      * @param aFilter filter for derivatives from the sample to use in interpolation
  63.      * @param gridPoints number of interpolation grid points
  64.      * @param step grid points time step
  65.      * @param maxSlots maximum number of independent cached time slots
  66.      * in the {@link GenericTimeStampedCache time-stamped cache}
  67.      * @param maxSpan maximum duration span in seconds of one slot
  68.      * in the {@link GenericTimeStampedCache time-stamped cache}
  69.      * @param newSlotInterval time interval above which a new slot is created
  70.      * in the {@link GenericTimeStampedCache time-stamped cache}
  71.      * @since 9.1
  72.      */
  73.     public ShiftingTransformProvider(final TransformProvider rawProvider,
  74.                                      final CartesianDerivativesFilter cFilter,
  75.                                      final AngularDerivativesFilter aFilter,
  76.                                      final int gridPoints, final double step,
  77.                                      final int maxSlots, final double maxSpan, final double newSlotInterval) {
  78.         this(new InterpolatingTransformProvider(rawProvider, cFilter, aFilter,
  79.                                                 gridPoints, step, maxSlots, maxSpan, newSlotInterval),
  80.              maxSlots, maxSpan, newSlotInterval);
  81.     }

  83.     /** Simple constructor.
  84.      * @param interpolatingProvider first level cache provider
  85.      * @param maxSlots maximum number of independent cached time slots
  86.      * in the {@link GenericTimeStampedCache time-stamped cache}
  87.      * @param maxSpan maximum duration span in seconds of one slot
  88.      * in the {@link GenericTimeStampedCache time-stamped cache}
  89.      * @param newSlotInterval time interval above which a new slot is created
  90.      * in the {@link GenericTimeStampedCache time-stamped cache}
  91.      */
  92.     private ShiftingTransformProvider(final InterpolatingTransformProvider interpolatingProvider,
  93.                                      final int maxSlots, final double maxSpan, final double newSlotInterval) {
  94.         this.interpolatingProvider = interpolatingProvider;
  95.         this.cache = new GenericTimeStampedCache<Transform>(2, maxSlots, maxSpan, newSlotInterval,
  96.                                                             new TransformGenerator(2,
  97.                                                                                    interpolatingProvider,
  98.                                                                                    interpolatingProvider.getStep()));
  99.         this.fieldCaches = new HashMap<>();
  100.     }

  102.     /** Get the underlying provider for raw (non-interpolated) transforms.
  103.      * @return provider for raw (non-interpolated) transforms
  104.      */
  105.     public TransformProvider getRawProvider() {
  106.         return interpolatingProvider.getRawProvider();
  107.     }

  109.     /** Get the number of interpolation grid points.
  110.      * @return number of interpolation grid points
  111.      */
  112.     public int getGridPoints() {
  113.         return interpolatingProvider.getGridPoints();
  114.     }

  116.     /** Get the grid points time step.
  117.      * @return grid points time step
  118.      */
  119.     public double getStep() {
  120.         return interpolatingProvider.getStep();
  121.     }

  123.     /** {@inheritDoc} */
  124.     public Transform getTransform(final AbsoluteDate date) {
  125.         // retrieve a sample from the thread-safe cache
  126.         final Transform closest = cache.getNeighbors(date).reduce((t0, t1) ->
  127.             FastMath.abs(date.durationFrom(t0.getDate())) < FastMath.abs(date.durationFrom(t1.getDate())) ? t0 : t1
  128.         ).get();
  129.         return closest.shiftedBy(date.durationFrom(closest.getDate()));
  130.     }

  132.     /** {@inheritDoc} */
  133.     @Override
  134.     public StaticTransform getStaticTransform(final AbsoluteDate date) {
  135.         // retrieve a sample from the thread-safe cache
  136.         final Transform closest = cache.getNeighbors(date).reduce((t0, t1) ->
  137.                 FastMath.abs(date.durationFrom(t0.getDate())) < FastMath.abs(date.durationFrom(t1.getDate())) ? t0 : t1
  138.         ).get();
  139.         return closest.staticShiftedBy(date.durationFrom(closest.getDate()));
  140.     }

  142.     /** {@inheritDoc} */
  143.     public <T extends CalculusFieldElement<T>> FieldTransform<T> getTransform(final FieldAbsoluteDate<T> date) {
  144.         @SuppressWarnings("unchecked")
  145.         GenericTimeStampedCache<FieldTransform<T>> fieldCache =
  146.             (GenericTimeStampedCache<FieldTransform<T>>) fieldCaches.get(date.getField());
  147.         if (fieldCache == null) {
  148.             fieldCache =
  149.                 new GenericTimeStampedCache<FieldTransform<T>>(cache.getMaxNeighborsSize(),
  150.                                                                cache.getMaxSlots(),
  151.                                                                cache.getMaxSpan(),
  152.                                                                cache.getNewSlotQuantumGap(),
  153.                                                                new FieldTransformGenerator<>(date.getField(),
  154.                                                                                              cache.getMaxNeighborsSize(),
  155.                                                                                              interpolatingProvider,
  156.                                                                                              interpolatingProvider.getStep()));
  157.             fieldCaches.put(date.getField(), fieldCache);
  158.         }

  160.         // retrieve a sample from the thread-safe cache
  161.         final FieldTransform<T> closest = fieldCache.getNeighbors(date.toAbsoluteDate()).reduce((t0, t1) ->
  162.             date.durationFrom(t0.getDate()).abs().getReal() < date.durationFrom(t1.getDate()).abs().getReal() ?
  163.             t0 : t1
  164.         ).get();
  165.         return closest.shiftedBy(date.durationFrom(closest.getDate()));
  166.     }

  168.     /** {@inheritDoc} */
  169.     @Override
  170.     public <T extends CalculusFieldElement<T>> FieldStaticTransform<T> getStaticTransform(final FieldAbsoluteDate<T> date) {
  171.         @SuppressWarnings("unchecked")
  172.         GenericTimeStampedCache<FieldTransform<T>> fieldCache =
  173.             (GenericTimeStampedCache<FieldTransform<T>>) fieldCaches.get(date.getField());
  174.         if (fieldCache == null) {
  175.             fieldCache =
  176.                 new GenericTimeStampedCache<FieldTransform<T>>(cache.getMaxNeighborsSize(),
  177.                                                                cache.getMaxSlots(),
  178.                                                                cache.getMaxSpan(),
  179.                                                                cache.getNewSlotQuantumGap(),
  180.                                                                new FieldTransformGenerator<>(date.getField(),
  181.                                                                                              cache.getMaxNeighborsSize(),
  182.                                                                                              interpolatingProvider,
  183.                                                                                              interpolatingProvider.getStep()));
  184.             fieldCaches.put(date.getField(), fieldCache);
  185.         }

  187.         // retrieve a sample from the thread-safe cache
  188.         final FieldTransform<T> closest = fieldCache.getNeighbors(date.toAbsoluteDate()).reduce((t0, t1) ->
  189.             date.durationFrom(t0.getDate()).abs().getReal() < date.durationFrom(t1.getDate()).abs().getReal() ?
  190.             t0 : t1
  191.         ).get();
  192.         return closest.staticShiftedBy(date.durationFrom(closest.getDate()));
  193.     }

  195.     /** Replace the instance with a data transfer object for serialization.
  196.      * <p>
  197.      * This intermediate class serializes only the data needed for generation,
  198.      * but does <em>not</em> serializes the cache itself (in fact the cache is
  199.      * not serializable).
  200.      * </p>
  201.      * @return data transfer object that will be serialized
  202.      */
  203.     private Object writeReplace() {
  204.         return new DTO(interpolatingProvider,
  205.                        cache.getMaxSlots(), cache.getMaxSpan(), cache.getNewSlotQuantumGap());
  206.     }

  208.     /** Internal class used only for serialization. */
  209.     private static class DTO implements Serializable {

  211.         /** Serializable UID. */
  212.         private static final long serialVersionUID = 20150601L;

  214.         /** Provider for raw (non-interpolated) transforms. */
  215.         private final InterpolatingTransformProvider interpolatingProvider;

  217.         /** Maximum number of independent cached time slots. */
  218.         private final int maxSlots;

  220.         /** Maximum duration span in seconds of one slot. */
  221.         private final double maxSpan;

  223.         /** Time interval above which a new slot is created. */
  224.         private final double newSlotInterval;

  226.         /** Simple constructor.
  227.          * @param interpolatingProvider first level cache provider
  228.          * @param maxSlots maximum number of independent cached time slots
  229.          * in the {@link GenericTimeStampedCache time-stamped cache}
  230.          * @param maxSpan maximum duration span in seconds of one slot
  231.          * in the {@link GenericTimeStampedCache time-stamped cache}
  232.          * @param newSlotInterval time interval above which a new slot is created
  233.          * in the {@link GenericTimeStampedCache time-stamped cache}
  234.          */
  235.         private DTO(final InterpolatingTransformProvider interpolatingProvider,
  236.                     final int maxSlots, final double maxSpan, final double newSlotInterval) {
  237.             this.interpolatingProvider = interpolatingProvider;
  238.             this.maxSlots              = maxSlots;
  239.             this.maxSpan               = maxSpan;
  240.             this.newSlotInterval       = newSlotInterval;
  241.         }

  243.         /** Replace the deserialized data transfer object with a {@link ShiftingTransformProvider}.
  244.          * @return replacement {@link ShiftingTransformProvider}
  245.          */
  246.         private Object readResolve() {
  247.             // build a new provider, with an empty cache
  248.             return new ShiftingTransformProvider(interpolatingProvider,
  249.                                                  maxSlots, maxSpan, newSlotInterval);
  250.         }

  252.     }

  254. }
Created with JaCoCo 0.8.11.202310140853