CachedNormalizedSphericalHarmonicsProvider.java

  1. /* Copyright 2002-2013 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.List;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  123.     /** {@inheritDoc} */
  124.     @Override
  125.     @Deprecated
  126.     public double getNormalizedCnm(final double dateOffset, final int n, final int m)
  127.         throws OrekitException {
  128.         return onDate(getReferenceDate().shiftedBy(dateOffset)).getNormalizedCnm(n, m);
  129.     }

  131.     /** {@inheritDoc} */
  132.     @Override
  133.     @Deprecated
  134.     public double getNormalizedSnm(final double dateOffset, final int n, final int m)
  135.         throws OrekitException {
  136.         return onDate(getReferenceDate().shiftedBy(dateOffset)).getNormalizedSnm(n, m);
  137.     }

  139.     /** {@inheritDoc} */
  140.     @Override
  141.     public NormalizedSphericalHarmonics onDate(final AbsoluteDate date) throws
  142.             TimeStampedCacheException {
  143.         return TimeStampedSphericalHarmonics.interpolate(date, cache.getNeighbors(date));
  144.     }

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

  149.         /** Time step between generated sets. */
  150.         private final double step;

  152.         /** Simple constructor.
  153.          * @param step time step between generated sets
  154.          */
  155.         public Generator(final double step) {
  156.             this.step = step;
  157.         }

  159.         /** {@inheritDoc} */
  160.         @Override
  161.         public List<TimeStampedSphericalHarmonics> generate(final TimeStampedSphericalHarmonics existing,
  162.                                                             final AbsoluteDate date)
  163.             throws TimeStampedCacheException {
  164.             try {

  166.                 final List<TimeStampedSphericalHarmonics> generated =
  167.                         new ArrayList<TimeStampedSphericalHarmonics>();
  168.                 final double[] cnmsnm = new double[2 * size];

  170.                 if (existing == null) {

  172.                     // no prior existing transforms, just generate a first set
  173.                     for (int i = 0; i < cache.getNeighborsSize(); ++i) {
  174.                         final AbsoluteDate t = date.shiftedBy((i - cache.getNeighborsSize() / 2) * step);
  175.                         fillArray(rawProvider.onDate(t), cnmsnm);
  176.                         generated.add(new TimeStampedSphericalHarmonics(t, cnmsnm));
  177.                     }

  179.                 } else {

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

  184.                     AbsoluteDate t = existing.getDate();
  185.                     if (date.compareTo(t) > 0) {
  186.                         // forward generation
  187.                         do {
  188.                             t = t.shiftedBy(step);
  189.                             fillArray(rawProvider.onDate(t), cnmsnm);
  190.                             generated.add(new TimeStampedSphericalHarmonics(t, cnmsnm));
  191.                         } while (t.compareTo(date) <= 0);
  192.                     } else {
  193.                         // backward generation
  194.                         do {
  195.                             t = t.shiftedBy(-step);
  196.                             fillArray(rawProvider.onDate(t), cnmsnm);
  197.                             generated.add(new TimeStampedSphericalHarmonics(t, cnmsnm));
  198.                         } while (t.compareTo(date) >= 0);
  199.                     }

  201.                 }

  203.                 // return the generated sample
  204.                 return generated;

  206.             } catch (OrekitException oe) {
  207.                 throw new TimeStampedCacheException(oe);
  208.             }
  209.         }

  211.         /** Fill coefficients array for one entry.
  212.          * @param raw the un-interpolated spherical harmonics
  213.          * @param cnmsnm arrays to fill in
  214.          * @exception OrekitException if coefficients cannot be computed at specified date
  215.          */
  216.         private void fillArray(final NormalizedSphericalHarmonics raw,
  217.                                final double[] cnmsnm)
  218.             throws OrekitException {
  219.             int index = 0;
  220.             for (int n = 0; n <= rawProvider.getMaxDegree(); ++n) {
  221.                 for (int m = 0; m <= n; ++m) {
  222.                     cnmsnm[index++] = raw.getNormalizedCnm(n, m);
  223.                 }
  224.             }
  225.             for (int n = 0; n <= rawProvider.getMaxDegree(); ++n) {
  226.                 for (int m = 0; m <= n; ++m) {
  227.                     cnmsnm[index++] = raw.getNormalizedSnm(n, m);
  228.                 }
  229.             }
  230.         }

  232.     }

  234.     /**
  235.      * Internal class for time-stamped spherical harmonics. Instances are created using
  236.      * {@link #interpolate(AbsoluteDate, Collection)}
  237.      */
  238.     private static class TimeStampedSphericalHarmonics
  239.             implements TimeStamped, Serializable, NormalizedSphericalHarmonics {

  241.         /** Serializable UID. */
  242.         private static final long serialVersionUID = 20131029l;

  244.         /** Current date. */
  245.         private final AbsoluteDate date;

  247.         /** number of C or S coefficients. */
  248.         private final int size;

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

  253.         /** Simple constructor.
  254.          * @param date current date
  255.          * @param cnmsnm flattened array for C<sub>n,m</sub> and S<sub>n,m</sub>
  256.          *               coefficients. It is copied.
  257.          */
  258.         private TimeStampedSphericalHarmonics(final AbsoluteDate date,
  259.                                               final double[] cnmsnm) {
  260.             this.date   = date;
  261.             this.cnmsnm = cnmsnm.clone();
  262.             this.size   = cnmsnm.length / 2;
  263.         }

  265.         /** {@inheritDoc} */
  266.         @Override
  267.         public AbsoluteDate getDate() {
  268.             return date;
  269.         }

  271.         /** {@inheritDoc} */
  272.         @Override
  273.         public double getNormalizedCnm(final int n, final int m) throws OrekitException {
  274.             return cnmsnm[(n * (n + 1)) / 2 + m];
  275.         }

  277.         /** {@inheritDoc} */
  278.         @Override
  279.         public double getNormalizedSnm(final int n, final int m) throws OrekitException {
  280.             return cnmsnm[(n * (n + 1)) / 2 + m + size];
  281.         }

  283.         /** Interpolate spherical harmonics.
  284.          * <p>
  285.          * The interpolated instance is created by polynomial Hermite interpolation.
  286.          * </p>
  287.          * @param date interpolation date
  288.          * @param sample sample points on which interpolation should be done
  289.          * @return a new time-stamped spherical harmonics, interpolated at specified date
  290.          */
  291.         public static TimeStampedSphericalHarmonics interpolate(final AbsoluteDate date,
  292.                                                                 final Collection<TimeStampedSphericalHarmonics> sample) {

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

  297.             // add sample points
  298.             for (final TimeStampedSphericalHarmonics tssh : sample) {
  299.                 interpolator.addSamplePoint(tssh.date.durationFrom(date), tssh.cnmsnm);
  300.             }

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

  305.         }

  307.     }

  309. }
Created with JaCoCo 0.6.3.201306030806