AbstractPropagatorBuilder.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.  */
  17. package org.orekit.propagation.conversion;

  19. import java.util.List;

  21. import org.hipparchus.exception.LocalizedCoreFormats;
  22. import org.hipparchus.util.FastMath;
  23. import org.orekit.errors.OrekitException;
  24. import org.orekit.errors.OrekitIllegalArgumentException;
  25. import org.orekit.forces.gravity.NewtonianAttraction;
  26. import org.orekit.frames.Frame;
  27. import org.orekit.orbits.Orbit;
  28. import org.orekit.orbits.OrbitType;
  29. import org.orekit.orbits.PositionAngle;
  30. import org.orekit.time.AbsoluteDate;
  31. import org.orekit.utils.ParameterDriver;
  32. import org.orekit.utils.ParameterDriversList;
  33. import org.orekit.utils.ParameterDriversList.DelegatingDriver;
  34. import org.orekit.utils.ParameterObserver;

  36. /** Base class for propagator builders.
  37.  * @author Pascal Parraud
  38.  * @since 7.1
  39.  */
  40. public abstract class AbstractPropagatorBuilder implements PropagatorBuilder {

  42.     /** Central attraction scaling factor.
  43.      * <p>
  44.      * We use a power of 2 to avoid numeric noise introduction
  45.      * in the multiplications/divisions sequences.
  46.      * </p>
  47.      */
  48.     private static final double MU_SCALE = FastMath.scalb(1.0, 32);

  50.     /** Date of the initial orbit. */
  51.     private AbsoluteDate initialOrbitDate;

  53.     /** Frame in which the orbit is propagated. */
  54.     private final Frame frame;

  56.     /** Central attraction coefficient (m³/s²). */
  57.     private double mu;

  59.     /** Drivers for orbital parameters. */
  60.     private final ParameterDriversList orbitalDrivers;

  62.     /** List of the supported parameters. */
  63.     private ParameterDriversList propagationDrivers;

  65.     /** Orbit type to use. */
  66.     private final OrbitType orbitType;

  68.     /** Position angle type to use. */
  69.     private final PositionAngle positionAngle;

  71.     /** Position scale to use for the orbital drivers. */
  72.     private final double positionScale;

  74.     /** Build a new instance.
  75.      * <p>
  76.      * The template orbit is used as a model to {@link
  77.      * #createInitialOrbit() create initial orbit}. It defines the
  78.      * inertial frame, the central attraction coefficient, the orbit type, and is also
  79.      * used together with the {@code positionScale} to convert from the {@link
  80.      * ParameterDriver#setNormalizedValue(double) normalized} parameters used by the
  81.      * callers of this builder to the real orbital parameters.
  82.      * </p>
  83.      * <p>
  84.      * By default, all the {@link #getOrbitalParametersDrivers() orbital parameters drivers}
  85.      * are selected, which means that if the builder is used for orbit determination or
  86.      * propagator conversion, all orbital parameters will be estimated. If only a subset
  87.      * of the orbital parameters must be estimated, caller must retrieve the orbital
  88.      * parameters by calling {@link #getOrbitalParametersDrivers()} and then call
  89.      * {@link ParameterDriver#setSelected(boolean) setSelected(false)}.
  90.      * </p>
  91.      * @param templateOrbit reference orbit from which real orbits will be built
  92.      * @param positionAngle position angle type to use
  93.      * @param positionScale scaling factor used for orbital parameters normalization
  94.      * (typically set to the expected standard deviation of the position)
  95.      * @param addDriverForCentralAttraction if true, a {@link ParameterDriver} should
  96.      * be set up for central attraction coefficient
  97.      * @exception OrekitException if parameters drivers cannot be scaled
  98.      * @since 8.0
  99.      */
  100.     protected AbstractPropagatorBuilder(final Orbit templateOrbit, final PositionAngle positionAngle,
  101.                                         final double positionScale, final boolean addDriverForCentralAttraction)
  102.         throws OrekitException {

  104.         this.initialOrbitDate    = templateOrbit.getDate();
  105.         this.frame               = templateOrbit.getFrame();
  106.         this.mu                  = templateOrbit.getMu();
  107.         this.propagationDrivers  = new ParameterDriversList();
  108.         this.orbitType           = templateOrbit.getType();
  109.         this.positionAngle       = positionAngle;
  110.         this.positionScale       = positionScale;
  111.         this.orbitalDrivers      = orbitType.getDrivers(positionScale, templateOrbit, positionAngle);
  112.         for (final DelegatingDriver driver : orbitalDrivers.getDrivers()) {
  113.             driver.setSelected(true);
  114.         }

  116.         if (addDriverForCentralAttraction) {
  117.             final ParameterDriver muDriver = new ParameterDriver(NewtonianAttraction.CENTRAL_ATTRACTION_COEFFICIENT,
  118.                                                                  mu, MU_SCALE, 0, Double.POSITIVE_INFINITY);
  119.             muDriver.addObserver(new ParameterObserver() {
  120.                 /** {@inheridDoc} */
  121.                 @Override
  122.                 public void valueChanged(final double previousValue, final ParameterDriver driver) {
  123.                     AbstractPropagatorBuilder.this.mu = driver.getValue();
  124.                 }
  125.             });
  126.             propagationDrivers.add(muDriver);
  127.         }

  129.     }

  131.     /** {@inheritDoc} */
  132.     public OrbitType getOrbitType() {
  133.         return orbitType;
  134.     }

  136.     /** {@inheritDoc} */
  137.     public PositionAngle getPositionAngle() {
  138.         return positionAngle;
  139.     }

  141.     /** {@inheritDoc} */
  142.     public AbsoluteDate getInitialOrbitDate() {
  143.         return initialOrbitDate;
  144.     }

  146.     /** {@inheritDoc} */
  147.     public Frame getFrame() {
  148.         return frame;
  149.     }

  151.     /** {@inheritDoc} */
  152.     public ParameterDriversList getOrbitalParametersDrivers() {
  153.         return orbitalDrivers;
  154.     }

  156.     /** {@inheritDoc} */
  157.     public ParameterDriversList getPropagationParametersDrivers() {
  158.         return propagationDrivers;
  159.     }

  161.     /** Get the position scale.
  162.      * @return the position scale used to scale the orbital drivers
  163.      */
  164.     public double getPositionScale() {
  165.         return positionScale;
  166.     }

  168.     /** Get the central attraction coefficient (µ - m³/s²) value.
  169.      * @return the central attraction coefficient (µ - m³/s²) value
  170.      * @since 9.2
  171.      */
  172.     public double getMu() {
  173.         return mu;
  174.     }

  176.     /** Get the number of selected parameters.
  177.      * @return number of selected parameters
  178.      */
  179.     private int getNbSelected() {

  181.         int count = 0;

  183.         // count orbital parameters
  184.         for (final ParameterDriver driver : orbitalDrivers.getDrivers()) {
  185.             if (driver.isSelected()) {
  186.                 ++count;
  187.             }
  188.         }

  190.         // count propagation parameters
  191.         for (final ParameterDriver driver : propagationDrivers.getDrivers()) {
  192.             if (driver.isSelected()) {
  193.                 ++count;
  194.             }
  195.         }

  197.         return count;

  199.     }

  201.     /** {@inheritDoc} */
  202.     public double[] getSelectedNormalizedParameters() {

  204.         // allocate array
  205.         final double[] selected = new double[getNbSelected()];

  207.         // fill data
  208.         int index = 0;
  209.         for (final ParameterDriver driver : orbitalDrivers.getDrivers()) {
  210.             if (driver.isSelected()) {
  211.                 selected[index++] = driver.getNormalizedValue();
  212.             }
  213.         }
  214.         for (final ParameterDriver driver : propagationDrivers.getDrivers()) {
  215.             if (driver.isSelected()) {
  216.                 selected[index++] = driver.getNormalizedValue();
  217.             }
  218.         }

  220.         return selected;

  222.     }

  224.     /** Build an initial orbit using the current selected parameters.
  225.      * <p>
  226.      * This method is a stripped down version of {@link #buildPropagator(double[])}
  227.      * that only builds the initial orbit and not the full propagator.
  228.      * </p>
  229.      * @return an initial orbit
  230.      * @since 8.0
  231.      */
  232.     protected Orbit createInitialOrbit() {
  233.         final double[] unNormalized = new double[orbitalDrivers.getNbParams()];
  234.         for (int i = 0; i < unNormalized.length; ++i) {
  235.             unNormalized[i] = orbitalDrivers.getDrivers().get(i).getValue();
  236.         }
  237.         return getOrbitType().mapArrayToOrbit(unNormalized, null, positionAngle, initialOrbitDate, mu, frame);
  238.     }

  240.     /** Set the selected parameters.
  241.      * @param normalizedParameters normalized values for the selected parameters
  242.      * @exception OrekitException if some parameter cannot be set to the specified value
  243.      * @exception OrekitIllegalArgumentException if the number of parameters is not the
  244.      * number of selected parameters (adding orbits and models parameters)
  245.      */
  246.     protected void setParameters(final double[] normalizedParameters)
  247.         throws OrekitException, OrekitIllegalArgumentException {


  250.         if (normalizedParameters.length != getNbSelected()) {
  251.             throw new OrekitIllegalArgumentException(LocalizedCoreFormats.DIMENSIONS_MISMATCH,
  252.                                                      normalizedParameters.length,
  253.                                                      getNbSelected());
  254.         }

  256.         int index = 0;

  258.         // manage orbital parameters
  259.         for (final ParameterDriver driver : orbitalDrivers.getDrivers()) {
  260.             if (driver.isSelected()) {
  261.                 driver.setNormalizedValue(normalizedParameters[index++]);
  262.             }
  263.         }

  265.         // manage propagation parameters
  266.         for (final ParameterDriver driver : propagationDrivers.getDrivers()) {
  267.             if (driver.isSelected()) {
  268.                 driver.setNormalizedValue(normalizedParameters[index++]);
  269.             }
  270.         }

  272.     }

  274.     /** Add a supported parameter.
  275.      * @param driver driver for the parameter
  276.      * @exception OrekitException if the name is already supported
  277.      */
  278.     protected void addSupportedParameter(final ParameterDriver driver)
  279.         throws OrekitException {
  280.         propagationDrivers.add(driver);
  281.         propagationDrivers.sort();
  282.     }

  284.     /** Reset the orbit in the propagator builder.
  285.      * @param newOrbit New orbit to set in the propagator builder
  286.      * @exception OrekitException if a parameter observer throws an exception during reset
  287.      */
  288.     public void resetOrbit(final Orbit newOrbit)
  289.         throws OrekitException {

  291.         // Map the new orbit in an array of double
  292.         final double[] orbitArray = new double[6];
  293.         orbitType.mapOrbitToArray(newOrbit, getPositionAngle(), orbitArray, null);

  295.         // Update all the orbital drivers, selected or unselected
  296.         final List<DelegatingDriver> orbitalDriversList = getOrbitalParametersDrivers().getDrivers();
  297.         for (int i = 0; i < 6; i++) {
  298.             orbitalDriversList.get(i).setValue(orbitArray[i]);
  299.         }

  301.         // Change the initial orbit date in the builder
  302.         this.initialOrbitDate = newOrbit.getDate();
  303.     }
  304. }
Created with JaCoCo 0.7.9.201702052155