NumericalPropagatorBuilder.java

  1. /* Copyright 2002-2020 CS GROUP
  2.  * Licensed to CS GROUP (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.ArrayList;
  20. import java.util.Collections;
  21. import java.util.List;

  23. import org.orekit.annotation.DefaultDataContext;
  24. import org.orekit.attitudes.Attitude;
  25. import org.orekit.attitudes.AttitudeProvider;
  26. import org.orekit.data.DataContext;
  27. import org.orekit.estimation.leastsquares.BatchLSModel;
  28. import org.orekit.estimation.leastsquares.ModelObserver;
  29. import org.orekit.estimation.measurements.ObservedMeasurement;
  30. import org.orekit.estimation.sequential.CovarianceMatrixProvider;
  31. import org.orekit.estimation.sequential.KalmanModel;
  32. import org.orekit.forces.ForceModel;
  33. import org.orekit.forces.gravity.NewtonianAttraction;
  34. import org.orekit.orbits.Orbit;
  35. import org.orekit.orbits.PositionAngle;
  36. import org.orekit.propagation.Propagator;
  37. import org.orekit.propagation.SpacecraftState;
  38. import org.orekit.propagation.integration.AdditionalEquations;
  39. import org.orekit.propagation.numerical.NumericalPropagator;
  40. import org.orekit.utils.ParameterDriver;
  41. import org.orekit.utils.ParameterDriversList;

  43. /** Builder for numerical propagator.
  44.  * @author Pascal Parraud
  45.  * @since 6.0
  46.  */
  47. public class NumericalPropagatorBuilder extends AbstractPropagatorBuilder implements IntegratedPropagatorBuilder {

  49.     /** First order integrator builder for propagation. */
  50.     private final ODEIntegratorBuilder builder;

  52.     /** Force models used during the extrapolation of the orbit. */
  53.     private final List<ForceModel> forceModels;

  55.     /** Current mass for initial state (kg). */
  56.     private double mass;

  58.     /** Build a new instance.
  59.      * <p>
  60.      * The reference orbit is used as a model to {@link
  61.      * #createInitialOrbit() create initial orbit}. It defines the
  62.      * inertial frame, the central attraction coefficient, and is also used together
  63.      * with the {@code positionScale} to convert from the {@link
  64.      * ParameterDriver#setNormalizedValue(double) normalized} parameters used by the
  65.      * callers of this builder to the real orbital parameters.
  66.      * </p>
  67.      *
  68.      * <p>This constructor uses the {@link DataContext#getDefault() default data context}.
  69.      *
  70.      * @param referenceOrbit reference orbit from which real orbits will be built
  71.      * @param builder first order integrator builder
  72.      * @param positionAngle position angle type to use
  73.      * @param positionScale scaling factor used for orbital parameters normalization
  74.      * (typically set to the expected standard deviation of the position)
  75.      * @since 8.0
  76.      * @see #NumericalPropagatorBuilder(Orbit, ODEIntegratorBuilder, PositionAngle,
  77.      * double, AttitudeProvider)
  78.      */
  79.     @DefaultDataContext
  80.     public NumericalPropagatorBuilder(final Orbit referenceOrbit,
  81.                                       final ODEIntegratorBuilder builder,
  82.                                       final PositionAngle positionAngle,
  83.                                       final double positionScale) {
  84.         this(referenceOrbit, builder, positionAngle, positionScale,
  85.                 Propagator.getDefaultLaw(DataContext.getDefault().getFrames()));
  86.     }

  88.     /** Build a new instance.
  89.      * <p>
  90.      * The reference orbit is used as a model to {@link
  91.      * #createInitialOrbit() create initial orbit}. It defines the
  92.      * inertial frame, the central attraction coefficient, and is also used together
  93.      * with the {@code positionScale} to convert from the {@link
  94.      * ParameterDriver#setNormalizedValue(double) normalized} parameters used by the
  95.      * callers of this builder to the real orbital parameters.
  96.      * </p>
  97.      * @param referenceOrbit reference orbit from which real orbits will be built
  98.      * @param builder first order integrator builder
  99.      * @param positionAngle position angle type to use
  100.      * @param positionScale scaling factor used for orbital parameters normalization
  101.      * (typically set to the expected standard deviation of the position)
  102.      * @param attitudeProvider attitude law.
  103.      * @since 10.1
  104.      */
  105.     public NumericalPropagatorBuilder(final Orbit referenceOrbit,
  106.                                       final ODEIntegratorBuilder builder,
  107.                                       final PositionAngle positionAngle,
  108.                                       final double positionScale,
  109.                                       final AttitudeProvider attitudeProvider) {
  110.         super(referenceOrbit, positionAngle, positionScale, true, attitudeProvider);
  111.         this.builder     = builder;
  112.         this.forceModels = new ArrayList<ForceModel>();
  113.         this.mass        = Propagator.DEFAULT_MASS;
  114.     }

  116.     /** Create a copy of a NumericalPropagatorBuilder object.
  117.      * @return Copied version of the NumericalPropagatorBuilder
  118.      */
  119.     public NumericalPropagatorBuilder copy() {
  120.         final NumericalPropagatorBuilder copyBuilder =
  121.                         new NumericalPropagatorBuilder(createInitialOrbit(),
  122.                                                        builder,
  123.                                                        getPositionAngle(),
  124.                                                        getPositionScale(),
  125.                                                        getAttitudeProvider());
  126.         copyBuilder.setMass(mass);
  127.         for (ForceModel model : forceModels) {
  128.             copyBuilder.addForceModel(model);
  129.         }
  130.         return copyBuilder;
  131.     }

  133.     /** Get the integrator builder.
  134.      * @return the integrator builder
  135.      * @since 9.2
  136.      */
  137.     public ODEIntegratorBuilder getIntegratorBuilder()
  138.     {
  139.         return builder;
  140.     }

  142.     /** Get the list of all force models.
  143.      * @return the list of all force models
  144.      * @since 9.2
  145.      */
  146.     public List<ForceModel> getAllForceModels()
  147.     {
  148.         return Collections.unmodifiableList(forceModels);
  149.     }

  151.     /** Add a force model to the global perturbation model.
  152.      * <p>If this method is not called at all, the integrated orbit will follow
  153.      * a Keplerian evolution only.</p>
  154.      * @param model perturbing {@link ForceModel} to add
  155.      */
  156.     public void addForceModel(final ForceModel model) {
  157.         if (model instanceof NewtonianAttraction) {
  158.             // we want to add the central attraction force model
  159.             if (hasNewtonianAttraction()) {
  160.                 // there is already a central attraction model, replace it
  161.                 forceModels.set(forceModels.size() - 1, model);
  162.             } else {
  163.                 // there are no central attraction model yet, add it at the end of the list
  164.                 forceModels.add(model);
  165.             }
  166.         } else {
  167.             // we want to add a perturbing force model
  168.             if (hasNewtonianAttraction()) {
  169.                 // insert the new force model before Newtonian attraction,
  170.                 // which should always be the last one in the list
  171.                 forceModels.add(forceModels.size() - 1, model);
  172.             } else {
  173.                 // we only have perturbing force models up to now, just append at the end of the list
  174.                 forceModels.add(model);
  175.             }
  176.         }

  178.         for (final ParameterDriver driver : model.getParametersDrivers()) {
  179.             addSupportedParameter(driver);
  180.         }
  181.     }

  183.     /** Get the mass.
  184.      * @return the mass
  185.      * @since 9.2
  186.      */
  187.     public double getMass()
  188.     {
  189.         return mass;
  190.     }

  192.     /** Set the initial mass.
  193.      * @param mass the mass (kg)
  194.      */
  195.     public void setMass(final double mass) {
  196.         this.mass = mass;
  197.     }

  199.     /** {@inheritDoc} */
  200.     public NumericalPropagator buildPropagator(final double[] normalizedParameters) {

  202.         setParameters(normalizedParameters);
  203.         final Orbit           orbit    = createInitialOrbit();
  204.         final Attitude        attitude =
  205.                 getAttitudeProvider().getAttitude(orbit, orbit.getDate(), getFrame());
  206.         final SpacecraftState state    = new SpacecraftState(orbit, attitude, mass);

  208.         final NumericalPropagator propagator = new NumericalPropagator(
  209.                 builder.buildIntegrator(orbit, getOrbitType()),
  210.                 getAttitudeProvider());
  211.         propagator.setOrbitType(getOrbitType());
  212.         propagator.setPositionAngleType(getPositionAngle());

  214.         // Configure force models
  215.         if (!hasNewtonianAttraction()) {
  216.             // There are no central attraction model yet, add it at the end of the list
  217.             addForceModel(new NewtonianAttraction(orbit.getMu()));
  218.         }
  219.         for (ForceModel model : forceModels) {
  220.             propagator.addForceModel(model);
  221.         }

  223.         propagator.resetInitialState(state);

  225.         // Add additional equations to the propagator
  226.         for (AdditionalEquations equation: getAdditionalEquations()) {
  227.             propagator.addAdditionalEquations(equation);
  228.         }

  230.         return propagator;
  231.     }

  233.     /** {@inheritDoc} */
  234.     public BatchLSModel buildLSModel(final IntegratedPropagatorBuilder[] builders,
  235.                             final List<ObservedMeasurement<?>> measurements,
  236.                             final ParameterDriversList estimatedMeasurementsParameters,
  237.                             final ModelObserver observer) {
  238.         return new BatchLSModel(builders, measurements, estimatedMeasurementsParameters, observer);
  239.     }

  241.     /** {@inheritDoc} */
  242.     @Deprecated
  243.     public KalmanModel buildKalmanModel(final List<IntegratedPropagatorBuilder> propagatorBuilders,
  244.                                   final List<CovarianceMatrixProvider> covarianceMatricesProviders,
  245.                                   final ParameterDriversList estimatedMeasurementsParameters) {
  246.         return new KalmanModel(propagatorBuilders, covarianceMatricesProviders,
  247.                                estimatedMeasurementsParameters);
  248.     }

  250.     /** {@inheritDoc} */
  251.     @Override
  252.     public KalmanModel buildKalmanModel(final List<IntegratedPropagatorBuilder> propagatorBuilders,
  253.                                   final List<CovarianceMatrixProvider> covarianceMatricesProviders,
  254.                                   final ParameterDriversList estimatedMeasurementsParameters,
  255.                                   final CovarianceMatrixProvider measurementProcessNoiseMatrix) {
  256.         return new KalmanModel(propagatorBuilders, covarianceMatricesProviders,
  257.                                estimatedMeasurementsParameters, measurementProcessNoiseMatrix);
  258.     }

  260.     /** Check if Newtonian attraction force model is available.
  261.      * <p>
  262.      * Newtonian attraction is always the last force model in the list.
  263.      * </p>
  264.      * @return true if Newtonian attraction force model is available
  265.      */
  266.     private boolean hasNewtonianAttraction() {
  267.         final int last = forceModels.size() - 1;
  268.         return last >= 0 && forceModels.get(last) instanceof NewtonianAttraction;
  269.     }

  271. }
Created with JaCoCo 0.8.6.202009150832