CachedNormalizedSphericalHarmonicsProvider.java

  1. /* Copyright 2002-2015 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.  */
  17. package org.orekit.forces.gravity.potential;

  19. import java.io.Serializable;
  20. import java.util.ArrayList;
  21. import java.util.Collection;
  22. import java.util.Collections;
  23. import java.util.List;

  25. import org.apache.commons.math3.analysis.interpolation.HermiteInterpolator;
  26. import org.orekit.errors.OrekitException;
  27. import org.orekit.errors.TimeStampedCacheException;
  28. import org.orekit.time.AbsoluteDate;
  29. import org.orekit.time.TimeStamped;
  30. import org.orekit.utils.GenericTimeStampedCache;
  31. import org.orekit.utils.TimeStampedCache;
  32. import org.orekit.utils.TimeStampedGenerator;

  34. /** Caching wrapper for {@link NormalizedSphericalHarmonicsProvider}.
  35.  * <p>
  36.  * This wrapper improves efficiency of {@link NormalizedSphericalHarmonicsProvider}
  37.  * by sampling the values at a user defined rate and using interpolation
  38.  * between samples. This is important with providers that have sub-daily
  39.  * frequencies and are computing intensive, such as tides fields.
  40.  * </p>
  41.  * @see NormalizedSphericalHarmonicsProvider
  42.  * @see org.orekit.forces.gravity.SolidTides
  43.  * @see TimeStampedCache
  44.  * @author Luc Maisonobe
  45.  * @since 6.1
  46.  */
  47. public class CachedNormalizedSphericalHarmonicsProvider implements NormalizedSphericalHarmonicsProvider {

  49.     /** Underlying raw provider. */
  50.     private final NormalizedSphericalHarmonicsProvider rawProvider;

  52.     /** Number of coefficients in C<sub>n, m</sub> and S<sub>n, m</sub> arrays (counted separately). */
  53.     private final int size;

  55.     /** Cache. */
  56.     private final TimeStampedCache<TimeStampedSphericalHarmonics> cache;

  58.     /** Simple constructor.
  59.      * @param rawProvider underlying raw provider
  60.      * @param step time step between sample points for interpolation
  61.      * @param nbPoints number of points to use for interpolation, must be at least 2
  62.      * @param maxSlots maximum number of independent cached time slots
  63.      * @param maxSpan maximum duration span in seconds of one slot
  64.      * (can be set to {@code Double.POSITIVE_INFINITY} if desired)
  65.      * @param newSlotInterval time interval above which a new slot is created
  66.      * instead of extending an existing one
  67.      */
  68.     public CachedNormalizedSphericalHarmonicsProvider(final NormalizedSphericalHarmonicsProvider rawProvider,
  69.                                                       final double step, final int nbPoints,
  70.                                                       final int maxSlots, final double maxSpan,
  71.                                                       final double newSlotInterval) {

  73.         this.rawProvider  = rawProvider;
  74.         final int k       = rawProvider.getMaxDegree() + 1;
  75.         this.size         = (k * (k + 1)) / 2;

  77.         cache = new GenericTimeStampedCache<TimeStampedSphericalHarmonics>(nbPoints, maxSlots, maxSpan,
  78.                                                                            newSlotInterval, new Generator(step),
  79.                                                                            TimeStampedSphericalHarmonics.class);
  80.     }

  82.     /** {@inheritDoc} */
  83.     @Override
  84.     public int getMaxDegree() {
  85.         return rawProvider.getMaxDegree();
  86.     }

  88.     /** {@inheritDoc} */
  89.     @Override
  90.     public int getMaxOrder() {
  91.         return rawProvider.getMaxOrder();
  92.     }

  94.     /** {@inheritDoc} */
  95.     @Override
  96.     public double getMu() {
  97.         return rawProvider.getMu();
  98.     }

  100.     /** {@inheritDoc} */
  101.     @Override
  102.     public double getAe() {
  103.         return rawProvider.getAe();
  104.     }

  106.     /** {@inheritDoc} */
  107.     @Override
  108.     public AbsoluteDate getReferenceDate() {
  109.         return rawProvider.getReferenceDate();
  110.     }

  112.     /** {@inheritDoc} */
  113.     @Override
  114.     public double getOffset(final AbsoluteDate date) {
  115.         return rawProvider.getOffset(date);
  116.     }

  118.     /** {@inheritDoc} */
  119.     @Override
  120.     public TideSystem getTideSystem() {
  121.         return rawProvider.getTideSystem();
  122.     }

  124.     /** {@inheritDoc} */
  125.     @Override
  126.     public NormalizedSphericalHarmonics onDate(final AbsoluteDate date) throws
  127.             TimeStampedCacheException {
  128.         return TimeStampedSphericalHarmonics.interpolate(date, cache.getNeighbors(date));
  129.     }

  131.     /** Generator for time-stamped spherical harmonics. */
  132.     private class Generator implements TimeStampedGenerator<TimeStampedSphericalHarmonics> {

  134.         /** Time step between generated sets. */
  135.         private final double step;

  137.         /** Simple constructor.
  138.          * @param step time step between generated sets
  139.          */
  140.         public Generator(final double step) {
  141.             this.step = step;
  142.         }

  144.         /** {@inheritDoc} */
  145.         @Override
  146.         public List<TimeStampedSphericalHarmonics> generate(final TimeStampedSphericalHarmonics existing,
  147.                                                             final AbsoluteDate date)
  148.             throws TimeStampedCacheException {
  149.             try {

  151.                 final List<TimeStampedSphericalHarmonics> generated =
  152.                         new ArrayList<TimeStampedSphericalHarmonics>();
  153.                 final double[] cnmsnm = new double[2 * size];

  155.                 if (existing == null) {

  157.                     // no prior existing transforms, just generate a first set
  158.                     for (int i = 0; i < cache.getNeighborsSize(); ++i) {
  159.                         final AbsoluteDate t = date.shiftedBy((i - cache.getNeighborsSize() / 2) * step);
  160.                         fillArray(rawProvider.onDate(t), cnmsnm);
  161.                         generated.add(new TimeStampedSphericalHarmonics(t, cnmsnm));
  162.                     }

  164.                 } else {

  166.                     // some coefficients have already been generated
  167.                     // add the missing ones up to specified date

  169.                     AbsoluteDate t = existing.getDate();
  170.                     if (date.compareTo(t) > 0) {
  171.                         // forward generation
  172.                         do {
  173.                             t = t.shiftedBy(step);
  174.                             fillArray(rawProvider.onDate(t), cnmsnm);
  175.                             generated.add(new TimeStampedSphericalHarmonics(t, cnmsnm));
  176.                         } while (t.compareTo(date) <= 0);
  177.                     } else {
  178.                         // backward generation
  179.                         do {
  180.                             t = t.shiftedBy(-step);
  181.                             fillArray(rawProvider.onDate(t), cnmsnm);
  182.                             generated.add(new TimeStampedSphericalHarmonics(t, cnmsnm));
  183.                         } while (t.compareTo(date) >= 0);
  184.                         // ensure forward chronological order
  185.                         Collections.reverse(generated);
  186.                     }

  188.                 }

  190.                 // return the generated sample
  191.                 return generated;

  193.             } catch (OrekitException oe) {
  194.                 throw new TimeStampedCacheException(oe);
  195.             }
  196.         }

  198.         /** Fill coefficients array for one entry.
  199.          * @param raw the un-interpolated spherical harmonics
  200.          * @param cnmsnm arrays to fill in
  201.          * @exception OrekitException if coefficients cannot be computed at specified date
  202.          */
  203.         private void fillArray(final NormalizedSphericalHarmonics raw,
  204.                                final double[] cnmsnm)
  205.             throws OrekitException {
  206.             int index = 0;
  207.             for (int n = 0; n <= rawProvider.getMaxDegree(); ++n) {
  208.                 for (int m = 0; m <= n; ++m) {
  209.                     cnmsnm[index++] = raw.getNormalizedCnm(n, m);
  210.                 }
  211.             }
  212.             for (int n = 0; n <= rawProvider.getMaxDegree(); ++n) {
  213.                 for (int m = 0; m <= n; ++m) {
  214.                     cnmsnm[index++] = raw.getNormalizedSnm(n, m);
  215.                 }
  216.             }
  217.         }

  219.     }

  221.     /**
  222.      * Internal class for time-stamped spherical harmonics. Instances are created using
  223.      * {@link #interpolate(AbsoluteDate, Collection)}
  224.      */
  225.     private static class TimeStampedSphericalHarmonics
  226.             implements TimeStamped, Serializable, NormalizedSphericalHarmonics {

  228.         /** Serializable UID. */
  229.         private static final long serialVersionUID = 20131029l;

  231.         /** Current date. */
  232.         private final AbsoluteDate date;

  234.         /** number of C or S coefficients. */
  235.         private final int size;

  237.         /** Flattened array for C<sub>n,m</sub> and S<sub>n,m</sub> coefficients. */
  238.         private final double[] cnmsnm;

  240.         /** Simple constructor.
  241.          * @param date current date
  242.          * @param cnmsnm flattened array for C<sub>n,m</sub> and S<sub>n,m</sub>
  243.          *               coefficients. It is copied.
  244.          */
  245.         private TimeStampedSphericalHarmonics(final AbsoluteDate date,
  246.                                               final double[] cnmsnm) {
  247.             this.date   = date;
  248.             this.cnmsnm = cnmsnm.clone();
  249.             this.size   = cnmsnm.length / 2;
  250.         }

  252.         /** {@inheritDoc} */
  253.         @Override
  254.         public AbsoluteDate getDate() {
  255.             return date;
  256.         }

  258.         /** {@inheritDoc} */
  259.         @Override
  260.         public double getNormalizedCnm(final int n, final int m) throws OrekitException {
  261.             return cnmsnm[(n * (n + 1)) / 2 + m];
  262.         }

  264.         /** {@inheritDoc} */
  265.         @Override
  266.         public double getNormalizedSnm(final int n, final int m) throws OrekitException {
  267.             return cnmsnm[(n * (n + 1)) / 2 + m + size];
  268.         }

  270.         /** Interpolate spherical harmonics.
  271.          * <p>
  272.          * The interpolated instance is created by polynomial Hermite interpolation.
  273.          * </p>
  274.          * @param date interpolation date
  275.          * @param sample sample points on which interpolation should be done
  276.          * @return a new time-stamped spherical harmonics, interpolated at specified date
  277.          */
  278.         public static TimeStampedSphericalHarmonics interpolate(final AbsoluteDate date,
  279.                                                                 final Collection<TimeStampedSphericalHarmonics> sample) {

  281.             // set up an interpolator taking derivatives into account
  282.             final HermiteInterpolator interpolator = new HermiteInterpolator();

  284.             // add sample points
  285.             for (final TimeStampedSphericalHarmonics tssh : sample) {
  286.                 interpolator.addSamplePoint(tssh.date.durationFrom(date), tssh.cnmsnm);
  287.             }

  289.             // build a new interpolated instance
  290.             return new TimeStampedSphericalHarmonics(date, interpolator.value(0.0));

  292.         }

  294.     }

  296. }
Created with JaCoCo 0.7.2.201409121644