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

  39. import java.util.ArrayList;
  40. import java.util.Collections;
  41. import java.util.List;

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

  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<DSSTForceModel> forceModels;

  55.     /** Type of the orbit used for the propagation.*/
  56.     private PropagationType propagationType;

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

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

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

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

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

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

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

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

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

  197.         addSupportedParameters(model.getParametersDrivers());
  198.     }

  200.     /** Reset the orbit in the propagator builder.
  201.      * @param newOrbit newOrbit New orbit to set in the propagator builder
  202.      * @param orbitType orbit type (MEAN or OSCULATING)
  203.      */
  204.     public void resetOrbit(final Orbit newOrbit, final PropagationType orbitType) {
  205.         this.stateType = orbitType;
  206.         super.resetOrbit(newOrbit);
  207.     }

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

  212.         setParameters(normalizedParameters);
  213.         final EquinoctialOrbit orbit    = (EquinoctialOrbit) OrbitType.EQUINOCTIAL.convertType(createInitialOrbit());
  214.         final Attitude         attitude = getAttitudeProvider().getAttitude(orbit, orbit.getDate(), getFrame());
  215.         final SpacecraftState  state    = new SpacecraftState(orbit, attitude, getMass());

  217.         final DSSTPropagator propagator = new DSSTPropagator(
  218.                 builder.buildIntegrator(orbit, OrbitType.EQUINOCTIAL),
  219.                 propagationType,
  220.                 getAttitudeProvider());

  222.         // Configure force models
  223.         if (!hasNewtonianAttraction()) {
  224.             // There are no central attraction model yet, add it at the end of the list
  225.             addForceModel(new DSSTNewtonianAttraction(orbit.getMu()));
  226.         }
  227.         for (DSSTForceModel model : forceModels) {
  228.             propagator.addForceModel(model);
  229.         }

  231.         propagator.setInitialState(state, stateType);

  233.         // Add additional derivatives providers to the propagator
  234.         for (AdditionalDerivativesProvider provider: getAdditionalDerivativesProviders()) {
  235.             propagator.addAdditionalDerivativesProvider(provider);
  236.         }

  238.         return propagator;

  240.     }

  242.     /** {@inheritDoc} */
  243.     @Override
  244.     public DSSTBatchLSModel buildLeastSquaresModel(final PropagatorBuilder[] builders,
  245.                                                    final List<ObservedMeasurement<?>> measurements,
  246.                                                    final ParameterDriversList estimatedMeasurementsParameters,
  247.                                                    final ModelObserver observer) {
  248.         return new DSSTBatchLSModel(builders,
  249.                                     measurements,
  250.                                     estimatedMeasurementsParameters,
  251.                                     observer,
  252.                                     propagationType);
  253.     }

  255.     /** Check if Newtonian attraction force model is available.
  256.      * <p>
  257.      * Newtonian attraction is always the last force model in the list.
  258.      * </p>
  259.      * @return true if Newtonian attraction force model is available
  260.      */
  261.     private boolean hasNewtonianAttraction() {
  262.         final int last = forceModels.size() - 1;
  263.         return last >= 0 && forceModels.get(last) instanceof DSSTNewtonianAttraction;
  264.     }

  266. }
Created with JaCoCo 0.8.12.202403310830