NumericalPropagatorBuilder.java

  1. /* Copyright 2002-2024 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.attitudes.Attitude;
  24. import org.orekit.attitudes.AttitudeProvider;
  25. import org.orekit.attitudes.FrameAlignedProvider;
  26. import org.orekit.estimation.leastsquares.BatchLSModel;
  27. import org.orekit.estimation.leastsquares.ModelObserver;
  28. import org.orekit.estimation.measurements.ObservedMeasurement;
  29. import org.orekit.forces.ForceModel;
  30. import org.orekit.forces.gravity.NewtonianAttraction;
  31. import org.orekit.forces.maneuvers.ImpulseManeuver;
  32. import org.orekit.orbits.Orbit;
  33. import org.orekit.orbits.PositionAngleType;
  34. import org.orekit.propagation.Propagator;
  35. import org.orekit.propagation.SpacecraftState;
  36. import org.orekit.propagation.integration.AdditionalDerivativesProvider;
  37. import org.orekit.propagation.numerical.NumericalPropagator;
  38. import org.orekit.utils.ParameterDriver;
  39. import org.orekit.utils.ParameterDriversList;

  41. /** Builder for numerical propagator.
  42.  * @author Pascal Parraud
  43.  * @since 6.0
  44.  */
  45. public class NumericalPropagatorBuilder extends AbstractPropagatorBuilder {

  47.     /** First order integrator builder for propagation. */
  48.     private final ODEIntegratorBuilder builder;

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

  53.     /** Impulse maneuvers. */
  54.     private final List<ImpulseManeuver> impulseManeuvers;

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

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

  112.     /**
  113.      * Add impulse maneuver.
  114.      * @param impulseManeuver impulse maneuver
  115.      * @since 12.2
  116.      */
  117.     public void addImpulseManeuver(final ImpulseManeuver impulseManeuver) {
  118.         impulseManeuvers.add(impulseManeuver);
  119.     }

  121.     /**
  122.      * Remove all impulse maneuvers.
  123.      * @since 12.2
  124.      */
  125.     public void clearImpulseManeuvers() {
  126.         impulseManeuvers.clear();
  127.     }

  129.     /** Create a copy of a NumericalPropagatorBuilder object.
  130.      * @return Copied version of the NumericalPropagatorBuilder
  131.      */
  132.     @Deprecated
  133.     public NumericalPropagatorBuilder copy() {
  134.         final NumericalPropagatorBuilder copyBuilder =
  135.                         new NumericalPropagatorBuilder(createInitialOrbit(),
  136.                                                        builder,
  137.                                                        getPositionAngleType(),
  138.                                                        getPositionScale(),
  139.                                                        getAttitudeProvider());
  140.         copyBuilder.setMass(getMass());
  141.         for (ForceModel model : forceModels) {
  142.             copyBuilder.addForceModel(model);
  143.         }
  144.         impulseManeuvers.forEach(copyBuilder::addImpulseManeuver);
  145.         return copyBuilder;
  146.     }

  148.     /** Get the integrator builder.
  149.      * @return the integrator builder
  150.      * @since 9.2
  151.      */
  152.     public ODEIntegratorBuilder getIntegratorBuilder()
  153.     {
  154.         return builder;
  155.     }

  157.     /** Get the list of all force models.
  158.      * @return the list of all force models
  159.      * @since 9.2
  160.      */
  161.     public List<ForceModel> getAllForceModels()
  162.     {
  163.         return Collections.unmodifiableList(forceModels);
  164.     }

  166.     /** Add a force model to the global perturbation model.
  167.      * <p>If this method is not called at all, the integrated orbit will follow
  168.      * a Keplerian evolution only.</p>
  169.      * @param model perturbing {@link ForceModel} to add
  170.      */
  171.     public void addForceModel(final ForceModel model) {
  172.         if (model instanceof NewtonianAttraction) {
  173.             // we want to add the central attraction force model
  174.             if (hasNewtonianAttraction()) {
  175.                 // there is already a central attraction model, replace it
  176.                 forceModels.set(forceModels.size() - 1, model);
  177.             } else {
  178.                 // there are no central attraction model yet, add it at the end of the list
  179.                 forceModels.add(model);
  180.             }
  181.         } else {
  182.             // we want to add a perturbing force model
  183.             if (hasNewtonianAttraction()) {
  184.                 // insert the new force model before Newtonian attraction,
  185.                 // which should always be the last one in the list
  186.                 forceModels.add(forceModels.size() - 1, model);
  187.             } else {
  188.                 // we only have perturbing force models up to now, just append at the end of the list
  189.                 forceModels.add(model);
  190.             }
  191.         }

  193.         addSupportedParameters(model.getParametersDrivers());
  194.     }

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

  199.         setParameters(normalizedParameters);
  200.         final Orbit           orbit    = createInitialOrbit();
  201.         final Attitude        attitude =
  202.                 getAttitudeProvider().getAttitude(orbit, orbit.getDate(), getFrame());
  203.         final SpacecraftState state    = new SpacecraftState(orbit, attitude, getMass());

  205.         final NumericalPropagator propagator = new NumericalPropagator(
  206.                 builder.buildIntegrator(orbit, getOrbitType()),
  207.                 getAttitudeProvider());
  208.         propagator.setOrbitType(getOrbitType());
  209.         propagator.setPositionAngleType(getPositionAngleType());

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

  221.         propagator.resetInitialState(state);

  223.         // Add additional derivatives providers to the propagator
  224.         for (AdditionalDerivativesProvider provider: getAdditionalDerivativesProviders()) {
  225.             propagator.addAdditionalDerivativesProvider(provider);
  226.         }

  228.         return propagator;

  230.     }

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

  241.     /** Check if Newtonian attraction force model is available.
  242.      * <p>
  243.      * Newtonian attraction is always the last force model in the list.
  244.      * </p>
  245.      * @return true if Newtonian attraction force model is available
  246.      */
  247.     private boolean hasNewtonianAttraction() {
  248.         final int last = forceModels.size() - 1;
  249.         return last >= 0 && forceModels.get(last) instanceof NewtonianAttraction;
  250.     }

  252. }
Created with JaCoCo 0.8.12.202403310830