OceanTides.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;

  19. import java.util.List;

  21. import org.apache.commons.math3.analysis.differentiation.DerivativeStructure;
  22. import org.apache.commons.math3.geometry.euclidean.threed.FieldRotation;
  23. import org.apache.commons.math3.geometry.euclidean.threed.FieldVector3D;
  24. import org.apache.commons.math3.ode.AbstractParameterizable;
  25. import org.apache.commons.math3.ode.UnknownParameterException;
  26. import org.orekit.errors.OrekitException;
  27. import org.orekit.forces.ForceModel;
  28. import org.orekit.forces.gravity.potential.CachedNormalizedSphericalHarmonicsProvider;
  29. import org.orekit.forces.gravity.potential.GravityFieldFactory;
  30. import org.orekit.forces.gravity.potential.NormalizedSphericalHarmonicsProvider;
  31. import org.orekit.forces.gravity.potential.OceanTidesWave;
  32. import org.orekit.frames.Frame;
  33. import org.orekit.propagation.SpacecraftState;
  34. import org.orekit.propagation.events.EventDetector;
  35. import org.orekit.propagation.numerical.TimeDerivativesEquations;
  36. import org.orekit.time.AbsoluteDate;
  37. import org.orekit.time.UT1Scale;
  38. import org.orekit.utils.Constants;
  39. import org.orekit.utils.IERSConventions;
  40. import org.orekit.utils.OrekitConfiguration;

  42. /** Ocean tides force model.
  43.  * @since 6.1
  44.  * @author Luc Maisonobe
  45.  */
  46. public class OceanTides extends AbstractParameterizable implements ForceModel {

  48.     /** Default step for tides field sampling (seconds). */
  49.     public static final double DEFAULT_STEP = 600.0;

  51.     /** Default number of points tides field sampling. */
  52.     public static final int DEFAULT_POINTS = 12;

  54.     /** Underlying attraction model. */
  55.     private final ForceModel attractionModel;

  57.     /** Simple constructor.
  58.      * <p>
  59.      * This constructor uses pole tides, the default {@link #DEFAULT_STEP step} and default
  60.      * {@link #DEFAULT_POINTS number of points} for the tides field interpolation.
  61.      * </p>
  62.      * @param centralBodyFrame rotating body frame
  63.      * @param ae central body reference radius
  64.      * @param mu central body attraction coefficient
  65.      * @param degree degree of the tide model to load
  66.      * @param order order of the tide model to load
  67.      * @param conventions IERS conventions used for loading ocean pole tide
  68.      * @param ut1 UT1 time scale
  69.      * @exception OrekitException if the ocean tides model cannot be read or the
  70.      * model does not support requested degree or order
  71.      * @see #DEFAULT_STEP
  72.      * @see #DEFAULT_POINTS
  73.      * @see #OceanTides(Frame, double, double, boolean, double, int, int, int, IERSConventions, UT1Scale)
  74.      * @see GravityFieldFactory#getOceanTidesWaves(int, int)
  75.      */
  76.     public OceanTides(final Frame centralBodyFrame, final double ae, final double mu,
  77.                       final int degree, final int order,
  78.                       final IERSConventions conventions, final UT1Scale ut1)
  79.         throws OrekitException {
  80.         this(centralBodyFrame, ae, mu, true,
  81.              DEFAULT_STEP, DEFAULT_POINTS, degree, order,
  82.              conventions, ut1);
  83.     }

  85.     /** Simple constructor.
  86.      * @param centralBodyFrame rotating body frame
  87.      * @param ae central body reference radius
  88.      * @param mu central body attraction coefficient
  89.      * @param poleTide if true, pole tide is computed
  90.      * @param step time step between sample points for interpolation
  91.      * @param nbPoints number of points to use for interpolation, if less than 2
  92.      * then no interpolation is performed (thus greatly increasing computation cost)
  93.      * @param degree degree of the tide model to load
  94.      * @param order order of the tide model to load
  95.      * @param conventions IERS conventions used for loading ocean pole tide
  96.      * @param ut1 UT1 time scale
  97.      * @exception OrekitException if the ocean tides model cannot be read or the
  98.      * model does not support requested degree or order
  99.      * @see GravityFieldFactory#getOceanTidesWaves(int, int)
  100.      */
  101.     public OceanTides(final Frame centralBodyFrame, final double ae, final double mu,
  102.                       final boolean poleTide, final double step, final int nbPoints,
  103.                       final int degree, final int order,
  104.                       final IERSConventions conventions, final UT1Scale ut1)
  105.         throws OrekitException {

  107.         // load the ocean tides model
  108.         final List<OceanTidesWave> waves = GravityFieldFactory.getOceanTidesWaves(degree, order);

  110.         final OceanTidesField raw =
  111.                 new OceanTidesField(ae, mu, waves,
  112.                                     conventions.getNutationArguments(ut1),
  113.                                     poleTide ? conventions.getOceanPoleTide(ut1.getEOPHistory()) : null);

  115.         final NormalizedSphericalHarmonicsProvider provider;
  116.         if (nbPoints < 2) {
  117.             provider = raw;
  118.         } else {
  119.             provider =
  120.                 new CachedNormalizedSphericalHarmonicsProvider(raw, step, nbPoints,
  121.                                                                OrekitConfiguration.getCacheSlotsNumber(),
  122.                                                                7 * Constants.JULIAN_DAY,
  123.                                                                0.5 * Constants.JULIAN_DAY);
  124.         }

  126.         attractionModel = new HolmesFeatherstoneAttractionModel(centralBodyFrame, provider);

  128.     }

  130.     /** {@inheritDoc} */
  131.     @Override
  132.     public double getParameter(final String name)
  133.         throws UnknownParameterException {
  134.         // there are no tunable parameters at all in this force model
  135.         throw new UnknownParameterException(name);
  136.     }

  138.     /** {@inheritDoc} */
  139.     @Override
  140.     public void setParameter(final String name, final double value)
  141.         throws UnknownParameterException {
  142.         // there are no tunable parameters at all in this force model
  143.         throw new UnknownParameterException(name);
  144.     }

  146.     /** {@inheritDoc} */
  147.     @Override
  148.     public void addContribution(final SpacecraftState s,
  149.                                 final TimeDerivativesEquations adder)
  150.         throws OrekitException {
  151.         // delegate to underlying attraction model
  152.         attractionModel.addContribution(s, adder);
  153.     }

  155.     /** {@inheritDoc} */
  156.     @Override
  157.     public FieldVector3D<DerivativeStructure> accelerationDerivatives(final AbsoluteDate date,
  158.                                                                       final Frame frame,
  159.                                                                       final FieldVector3D<DerivativeStructure> position,
  160.                                                                       final FieldVector3D<DerivativeStructure> velocity,
  161.                                                                       final FieldRotation<DerivativeStructure> rotation,
  162.                                                                       final DerivativeStructure mass)
  163.         throws OrekitException {
  164.         // delegate to underlying attraction model
  165.         return attractionModel.accelerationDerivatives(date, frame, position, velocity, rotation, mass);
  166.     }

  168.     /** {@inheritDoc} */
  169.     @Override
  170.     public FieldVector3D<DerivativeStructure> accelerationDerivatives(final SpacecraftState s,
  171.                                                                       final String paramName)
  172.         throws OrekitException {
  173.         // this should never be called as there are no tunable parameters
  174.         return attractionModel.accelerationDerivatives(s, paramName);
  175.     }

  177.     /** {@inheritDoc} */
  178.     @Override
  179.     public EventDetector[] getEventsDetectors() {
  180.         // delegate to underlying attraction model
  181.         return attractionModel.getEventsDetectors();
  182.     }

  184. }
Created with JaCoCo 0.6.3.201306030806