DSSTPropagatorBuilder.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;
  22. import org.orekit.attitudes.Attitude;
  23. import org.orekit.attitudes.AttitudeProvider;
  24. import org.orekit.attitudes.FrameAlignedProvider;
  25. import org.orekit.estimation.leastsquares.DSSTBatchLSModel;
  26. import org.orekit.estimation.leastsquares.ModelObserver;
  27. import org.orekit.estimation.measurements.ObservedMeasurement;
  28. import org.orekit.orbits.EquinoctialOrbit;
  29. import org.orekit.orbits.Orbit;
  30. import org.orekit.orbits.OrbitType;
  31. import org.orekit.orbits.PositionAngleType;
  32. import org.orekit.propagation.PropagationType;
  33. import org.orekit.propagation.Propagator;
  34. import org.orekit.propagation.SpacecraftState;
  35. import org.orekit.propagation.integration.AdditionalDerivativesProvider;
  36. import org.orekit.propagation.semianalytical.dsst.DSSTPropagator;
  37. import org.orekit.propagation.semianalytical.dsst.forces.DSSTForceModel;
  38. import org.orekit.propagation.semianalytical.dsst.forces.DSSTNewtonianAttraction;
  39. import org.orekit.utils.ParameterDriver;
  40. import org.orekit.utils.ParameterDriversList;

  42. /** Builder for DSST propagator.
  43.  * @author Bryan Cazabonne
  44.  * @since 10.0
  45.  */
  46. public class DSSTPropagatorBuilder extends AbstractPropagatorBuilder {

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

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

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

  57.     /** Type of the orbit used for the propagation.*/
  58.     private PropagationType propagationType;

  60.     /** Type of the elements used to define the orbital state.*/
  61.     private PropagationType stateType;

  63.     /** Build a new instance.
  64.      * <p>
  65.      * The reference orbit is used as a model to {@link
  66.      * #createInitialOrbit() create initial orbit}. It defines the
  67.      * inertial frame, the central attraction coefficient, and is also used together
  68.      * with the {@code positionScale} to convert from the {@link
  69.      * ParameterDriver#setNormalizedValue(double) normalized} parameters used by the
  70.      * callers of this builder to the real orbital parameters.
  71.      * The default attitude provider is aligned with the orbit's inertial frame.
  72.      * </p>
  73.      *
  74.      * @param referenceOrbit reference orbit from which real orbits will be built
  75.      * @param builder first order integrator builder
  76.      * @param positionScale scaling factor used for orbital parameters normalization
  77.      * (typically set to the expected standard deviation of the position)
  78.      * @param propagationType type of the orbit used for the propagation (mean or osculating)
  79.      * @param stateType type of the elements used to define the orbital state (mean or osculating)
  80.      * @see #DSSTPropagatorBuilder(Orbit, ODEIntegratorBuilder, double, PropagationType,
  81.      * PropagationType, AttitudeProvider)
  82.      */
  83.     public DSSTPropagatorBuilder(final Orbit referenceOrbit,
  84.                                  final ODEIntegratorBuilder builder,
  85.                                  final double positionScale,
  86.                                  final PropagationType propagationType,
  87.                                  final PropagationType stateType) {
  88.         this(referenceOrbit, builder, positionScale, propagationType, stateType,
  89.              FrameAlignedProvider.of(referenceOrbit.getFrame()));
  90.     }

  92.     /** Build a new instance.
  93.      * <p>
  94.      * The reference orbit is used as a model to {@link
  95.      * #createInitialOrbit() create initial orbit}. It defines the
  96.      * inertial frame, the central attraction coefficient, and is also used together
  97.      * with the {@code positionScale} to convert from the {@link
  98.      * ParameterDriver#setNormalizedValue(double) normalized} parameters used by the
  99.      * callers of this builder to the real orbital parameters.
  100.      * </p>
  101.      * @param referenceOrbit reference orbit from which real orbits will be built
  102.      * @param builder first order integrator builder
  103.      * @param positionScale scaling factor used for orbital parameters normalization
  104.      * (typically set to the expected standard deviation of the position)
  105.      * @param propagationType type of the orbit used for the propagation (mean or osculating)
  106.      * @param stateType type of the elements used to define the orbital state (mean or osculating)
  107.      * @param attitudeProvider attitude law.
  108.      * @since 10.1
  109.      */
  110.     public DSSTPropagatorBuilder(final Orbit referenceOrbit,
  111.                                  final ODEIntegratorBuilder builder,
  112.                                  final double positionScale,
  113.                                  final PropagationType propagationType,
  114.                                  final PropagationType stateType,
  115.                                  final AttitudeProvider attitudeProvider) {
  116.         super(referenceOrbit, PositionAngleType.MEAN, positionScale, true, attitudeProvider);
  117.         this.builder           = builder;
  118.         this.forceModels       = new ArrayList<DSSTForceModel>();
  119.         this.mass              = Propagator.DEFAULT_MASS;
  120.         this.propagationType   = propagationType;
  121.         this.stateType         = stateType;
  122.     }

  124.     /** Get the type of the orbit used for the propagation (mean or osculating).
  125.      * @return the type of the orbit used for the propagation
  126.      */
  127.     public PropagationType getPropagationType() {
  128.         return propagationType;
  129.     }

  131.     /** Get the type of the elements used to define the orbital state (mean or osculating).
  132.      * @return the type of the elements used to define the orbital state
  133.      */
  134.     public PropagationType getStateType() {
  135.         return stateType;
  136.     }

  138.     /** Create a copy of a DSSTPropagatorBuilder object.
  139.      * @return Copied version of the DSSTPropagatorBuilder
  140.      */
  141.     public DSSTPropagatorBuilder copy() {
  142.         final DSSTPropagatorBuilder copyBuilder =
  143.                         new DSSTPropagatorBuilder(createInitialOrbit(),
  144.                                                   builder,
  145.                                                   getPositionScale(),
  146.                                                   propagationType,
  147.                                                   stateType,
  148.                                                   getAttitudeProvider());
  149.         copyBuilder.setMass(mass);
  150.         for (DSSTForceModel model : forceModels) {
  151.             copyBuilder.addForceModel(model);
  152.         }
  153.         return copyBuilder;
  154.     }

  156.     /** Get the integrator builder.
  157.      * @return the integrator builder
  158.      */
  159.     public ODEIntegratorBuilder getIntegratorBuilder()
  160.     {
  161.         return builder;
  162.     }

  164.     /** Get the list of all force models.
  165.      * @return the list of all force models
  166.      */
  167.     public List<DSSTForceModel> getAllForceModels()
  168.     {
  169.         return Collections.unmodifiableList(forceModels);
  170.     }

  172.     /** Get the mass.
  173.      * @return the mass
  174.      */
  175.     public double getMass()
  176.     {
  177.         return mass;
  178.     }

  180.     /** Set the initial mass.
  181.      * @param mass the mass (kg)
  182.      */
  183.     public void setMass(final double mass) {
  184.         this.mass = mass;
  185.     }

  187.     /** Add a force model to the global perturbation model.
  188.      * <p>If this method is not called at all, the integrated orbit will follow
  189.      * a Keplerian evolution only.</p>
  190.      * @param model perturbing {@link DSSTForceModel} to add
  191.      */
  192.     public void addForceModel(final DSSTForceModel model) {
  193.         if (model instanceof DSSTNewtonianAttraction) {
  194.             // we want to add the central attraction force model
  195.             if (hasNewtonianAttraction()) {
  196.                 // there is already a central attraction model, replace it
  197.                 forceModels.set(forceModels.size() - 1, model);
  198.             } else {
  199.                 // there are no central attraction model yet, add it at the end of the list
  200.                 forceModels.add(model);
  201.             }
  202.         } else {
  203.             // we want to add a perturbing force model
  204.             if (hasNewtonianAttraction()) {
  205.                 // insert the new force model before Newtonian attraction,
  206.                 // which should always be the last one in the list
  207.                 forceModels.add(forceModels.size() - 1, model);
  208.             } else {
  209.                 // we only have perturbing force models up to now, just append at the end of the list
  210.                 forceModels.add(model);
  211.             }
  212.         }

  214.         addSupportedParameters(model.getParametersDrivers());
  215.     }

  217.     /** Reset the orbit in the propagator builder.
  218.      * @param newOrbit newOrbit New orbit to set in the propagator builder
  219.      * @param orbitType orbit type (MEAN or OSCULATING)
  220.      */
  221.     public void resetOrbit(final Orbit newOrbit, final PropagationType orbitType) {
  222.         this.stateType = orbitType;
  223.         super.resetOrbit(newOrbit);
  224.     }

  226.     /** {@inheritDoc} */
  227.     public DSSTPropagator buildPropagator(final double[] normalizedParameters) {

  229.         setParameters(normalizedParameters);
  230.         final EquinoctialOrbit orbit    = (EquinoctialOrbit) OrbitType.EQUINOCTIAL.convertType(createInitialOrbit());
  231.         final Attitude         attitude = getAttitudeProvider().getAttitude(orbit, orbit.getDate(), getFrame());
  232.         final SpacecraftState  state    = new SpacecraftState(orbit, attitude, mass);

  234.         final DSSTPropagator propagator = new DSSTPropagator(
  235.                 builder.buildIntegrator(orbit, OrbitType.EQUINOCTIAL),
  236.                 propagationType,
  237.                 getAttitudeProvider());

  239.         // Configure force models
  240.         if (!hasNewtonianAttraction()) {
  241.             // There are no central attraction model yet, add it at the end of the list
  242.             addForceModel(new DSSTNewtonianAttraction(orbit.getMu()));
  243.         }
  244.         for (DSSTForceModel model : forceModels) {
  245.             propagator.addForceModel(model);
  246.         }

  248.         propagator.setInitialState(state, stateType);

  250.         // Add additional derivatives providers to the propagator
  251.         for (AdditionalDerivativesProvider provider: getAdditionalDerivativesProviders()) {
  252.             propagator.addAdditionalDerivativesProvider(provider);
  253.         }

  255.         return propagator;

  257.     }

  259.     /** {@inheritDoc} */
  260.     @Override
  261.     public DSSTBatchLSModel buildLeastSquaresModel(final PropagatorBuilder[] builders,
  262.                                                    final List<ObservedMeasurement<?>> measurements,
  263.                                                    final ParameterDriversList estimatedMeasurementsParameters,
  264.                                                    final ModelObserver observer) {
  265.         return new DSSTBatchLSModel(builders,
  266.                                     measurements,
  267.                                     estimatedMeasurementsParameters,
  268.                                     observer,
  269.                                     propagationType);
  270.     }

  272.     /** Check if Newtonian attraction force model is available.
  273.      * <p>
  274.      * Newtonian attraction is always the last force model in the list.
  275.      * </p>
  276.      * @return true if Newtonian attraction force model is available
  277.      */
  278.     private boolean hasNewtonianAttraction() {
  279.         final int last = forceModels.size() - 1;
  280.         return last >= 0 && forceModels.get(last) instanceof DSSTNewtonianAttraction;
  281.     }

  283. }
Created with JaCoCo 0.8.11.202310140853