ShiftingTransformProvider.java

  1. /* Copyright 2002-2018 CS Systèmes d'Information
  2.  * Licensed to CS Systèmes d'Information (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.RealFieldElement;
  26. import org.hipparchus.util.FastMath;
  27. import org.orekit.errors.OrekitException;
  28. import org.orekit.errors.OrekitExceptionWrapper;
  29. import org.orekit.time.AbsoluteDate;
  30. import org.orekit.time.FieldAbsoluteDate;
  31. import org.orekit.utils.AngularDerivativesFilter;
  32. import org.orekit.utils.CartesianDerivativesFilter;
  33. import org.orekit.utils.GenericTimeStampedCache;

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

  46.     /** Serializable UID. */
  47.     private static final long serialVersionUID = 20150601L;

  49.     /** First level cache. */
  50.     private final InterpolatingTransformProvider interpolatingProvider;

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

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

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

  85.     /** Simple constructor.
  86.      * @param rawProvider provider for raw (non-interpolated) transforms
  87.      * @param cFilter filter for derivatives from the sample to use in interpolation
  88.      * @param aFilter filter for derivatives from the sample to use in interpolation
  89.      * @param earliest earliest supported date
  90.      * @param latest latest supported date
  91.      * @param gridPoints number of interpolation grid points
  92.      * @param step grid points time step
  93.      * @param maxSlots maximum number of independent cached time slots
  94.      * in the {@link GenericTimeStampedCache time-stamped cache}
  95.      * @param maxSpan maximum duration span in seconds of one slot
  96.      * in the {@link GenericTimeStampedCache time-stamped cache}
  97.      * @param newSlotInterval time interval above which a new slot is created
  98.      * in the {@link GenericTimeStampedCache time-stamped cache}
  99.      * @deprecated as of 9.1, replaced by {@link #ShiftingTransformProvider(TransformProvider,
  100.      * CartesianDerivativesFilter, AngularDerivativesFilter, int, double, int, double, double)}
  101.      */
  102.     @Deprecated
  103.     public ShiftingTransformProvider(final TransformProvider rawProvider,
  104.                                      final CartesianDerivativesFilter cFilter,
  105.                                      final AngularDerivativesFilter aFilter,
  106.                                      final AbsoluteDate earliest, final AbsoluteDate latest,
  107.                                      final int gridPoints, final double step,
  108.                                      final int maxSlots, final double maxSpan, final double newSlotInterval) {
  109.         this(new InterpolatingTransformProvider(rawProvider, cFilter, aFilter,
  110.                                                 earliest, latest, gridPoints, step,
  111.                                                 maxSlots, maxSpan, newSlotInterval),
  112.              maxSlots, maxSpan, newSlotInterval);
  113.     }

  115.     /** Simple constructor.
  116.      * @param interpolatingProvider first level cache provider
  117.      * @param maxSlots maximum number of independent cached time slots
  118.      * in the {@link GenericTimeStampedCache time-stamped cache}
  119.      * @param maxSpan maximum duration span in seconds of one slot
  120.      * in the {@link GenericTimeStampedCache time-stamped cache}
  121.      * @param newSlotInterval time interval above which a new slot is created
  122.      * in the {@link GenericTimeStampedCache time-stamped cache}
  123.      */
  124.     private ShiftingTransformProvider(final InterpolatingTransformProvider interpolatingProvider,
  125.                                      final int maxSlots, final double maxSpan, final double newSlotInterval) {
  126.         this.interpolatingProvider = interpolatingProvider;
  127.         this.cache = new GenericTimeStampedCache<Transform>(2, maxSlots, maxSpan, newSlotInterval,
  128.                                                             new TransformGenerator(2,
  129.                                                                                    interpolatingProvider,
  130.                                                                                    interpolatingProvider.getStep()));
  131.         this.fieldCaches = new HashMap<>();
  132.     }

  134.     /** Get the underlying provider for raw (non-interpolated) transforms.
  135.      * @return provider for raw (non-interpolated) transforms
  136.      */
  137.     public TransformProvider getRawProvider() {
  138.         return interpolatingProvider.getRawProvider();
  139.     }

  141.     /** Get the number of interpolation grid points.
  142.      * @return number of interpolation grid points
  143.      */
  144.     public int getGridPoints() {
  145.         return interpolatingProvider.getGridPoints();
  146.     }

  148.     /** Get the grid points time step.
  149.      * @return grid points time step
  150.      */
  151.     public double getStep() {
  152.         return interpolatingProvider.getStep();
  153.     }

  155.     /** {@inheritDoc} */
  156.     public Transform getTransform(final AbsoluteDate date) throws OrekitException {
  157.         try {

  159.             // retrieve a sample from the thread-safe cache
  160.             final Transform closest = cache.getNeighbors(date).reduce((t0, t1) ->
  161.                 FastMath.abs(date.durationFrom(t0.getDate())) < FastMath.abs(date.durationFrom(t1.getDate())) ? t0 : t1
  162.             ).get();
  163.             return closest.shiftedBy(date.durationFrom(closest.getDate()));

  165.         } catch (OrekitExceptionWrapper oew) {
  166.             // something went wrong while generating the sample,
  167.             // we just forward the exception up
  168.             throw oew.getException();
  169.         }
  170.     }

  172.     /** {@inheritDoc} */
  173.     public <T extends RealFieldElement<T>> FieldTransform<T> getTransform(final FieldAbsoluteDate<T> date)
  174.         throws OrekitException {
  175.         try {

  177.             @SuppressWarnings("unchecked")
  178.             GenericTimeStampedCache<FieldTransform<T>> fieldCache =
  179.                 (GenericTimeStampedCache<FieldTransform<T>>) fieldCaches.get(date.getField());
  180.             if (fieldCache == null) {
  181.                 fieldCache =
  182.                     new GenericTimeStampedCache<FieldTransform<T>>(cache.getNeighborsSize(),
  183.                                                                    cache.getMaxSlots(),
  184.                                                                    cache.getMaxSpan(),
  185.                                                                    cache.getNewSlotQuantumGap(),
  186.                                                                    new FieldTransformGenerator<>(date.getField(),
  187.                                                                                                  cache.getNeighborsSize(),
  188.                                                                                                  interpolatingProvider,
  189.                                                                                                  interpolatingProvider.getStep()));
  190.                 fieldCaches.put(date.getField(), fieldCache);
  191.             }

  193.             // retrieve a sample from the thread-safe cache
  194.             final FieldTransform<T> closest = fieldCache.getNeighbors(date.toAbsoluteDate()).reduce((t0, t1) ->
  195.                 date.durationFrom(t0.getDate()).abs().getReal() < date.durationFrom(t1.getDate()).abs().getReal() ?
  196.                 t0 : t1
  197.             ).get();
  198.             return closest.shiftedBy(date.durationFrom(closest.getDate()));

  200.         } catch (OrekitExceptionWrapper oew) {
  201.             // something went wrong while generating the sample,
  202.             // we just forward the exception up
  203.             throw oew.getException();
  204.         }
  205.     }

  207.     /** Replace the instance with a data transfer object for serialization.
  208.      * <p>
  209.      * This intermediate class serializes only the data needed for generation,
  210.      * but does <em>not</em> serializes the cache itself (in fact the cache is
  211.      * not serializable).
  212.      * </p>
  213.      * @return data transfer object that will be serialized
  214.      */
  215.     private Object writeReplace() {
  216.         return new DTO(interpolatingProvider,
  217.                        cache.getMaxSlots(), cache.getMaxSpan(), cache.getNewSlotQuantumGap());
  218.     }

  220.     /** Internal class used only for serialization. */
  221.     private static class DTO implements Serializable {

  223.         /** Serializable UID. */
  224.         private static final long serialVersionUID = 20150601L;

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

  229.         /** Maximum number of independent cached time slots. */
  230.         private final int maxSlots;

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

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

  238.         /** Simple constructor.
  239.          * @param interpolatingProvider first level cache provider
  240.          * @param maxSlots maximum number of independent cached time slots
  241.          * in the {@link GenericTimeStampedCache time-stamped cache}
  242.          * @param maxSpan maximum duration span in seconds of one slot
  243.          * in the {@link GenericTimeStampedCache time-stamped cache}
  244.          * @param newSlotInterval time interval above which a new slot is created
  245.          * in the {@link GenericTimeStampedCache time-stamped cache}
  246.          */
  247.         private DTO(final InterpolatingTransformProvider interpolatingProvider,
  248.                     final int maxSlots, final double maxSpan, final double newSlotInterval) {
  249.             this.interpolatingProvider = interpolatingProvider;
  250.             this.maxSlots              = maxSlots;
  251.             this.maxSpan               = maxSpan;
  252.             this.newSlotInterval       = newSlotInterval;
  253.         }

  255.         /** Replace the deserialized data transfer object with a {@link ShiftingTransformProvider}.
  256.          * @return replacement {@link ShiftingTransformProvider}
  257.          */
  258.         private Object readResolve() {
  259.             // build a new provider, with an empty cache
  260.             return new ShiftingTransformProvider(interpolatingProvider,
  261.                                                  maxSlots, maxSpan, newSlotInterval);
  262.         }

  264.     }

  266. }
Created with JaCoCo 0.7.9.201702052155