diff --git a/src/main/java/org/orekit/propagation/semianalytical/dsst/DSSTPropagator.java b/src/main/java/org/orekit/propagation/semianalytical/dsst/DSSTPropagator.java
index 83189c8e28a5ca9ea4cb990ea394b848570194d4..b0e753c27702a5eddb3ce44280f99fe45ff1d78f 100644
--- a/src/main/java/org/orekit/propagation/semianalytical/dsst/DSSTPropagator.java
+++ b/src/main/java/org/orekit/propagation/semianalytical/dsst/DSSTPropagator.java
@@ -136,6 +136,12 @@ public class DSSTPropagator extends AbstractIntegratedPropagator {
      */
     private static final int I = 1;
 
+    /** Default value for epsilon. */
+    private static final double EPSILON_DEFAULT = 1.0e-13;
+
+    /** Default value for maxIterations. */
+    private static final int MAX_ITERATIONS_DEFAULT = 200;
+
     /** Number of grid points per integration step to be used in interpolation of short periodics coefficients.*/
     private static final int INTERPOLATION_POINTS_PER_STEP = 3;
 
@@ -477,7 +483,36 @@ public class DSSTPropagator extends AbstractIntegratedPropagator {
     public static SpacecraftState computeMeanState(final SpacecraftState osculating,
                                                    final AttitudeProvider attitudeProvider,
                                                    final Collection<DSSTForceModel> forceModels) {
-        final Orbit meanOrbit = computeMeanOrbit(osculating, attitudeProvider, forceModels);
+        return computeMeanState(osculating, attitudeProvider, forceModels, EPSILON_DEFAULT, MAX_ITERATIONS_DEFAULT);
+    }
+
+    /** Conversion from osculating to mean orbit.
+     * <p>
+     * Compute mean state <b>in a DSST sense</b>, corresponding to the
+     * osculating SpacecraftState in input, and according to the Force models
+     * taken into account.
+     * </p><p>
+     * Since the osculating state is obtained with the computation of
+     * short-periodic variation of each force model, the resulting output will
+     * depend on the force models parameterized in input.
+     * </p><p>
+     * The computation is done through a fixed-point iteration process.
+     * </p>
+     * @param osculating Osculating state to convert
+     * @param attitudeProvider attitude provider (may be null if there are no Gaussian force models
+     * like atmospheric drag, radiation pressure or specific user-defined models)
+     * @param forceModels Forces to take into account
+     * @param epsilon convergence threshold for mean parameters conversion
+     * @param maxIterations maximum iterations for mean parameters conversion
+     * @return mean state in a DSST sense
+     * @since 10.1
+     */
+    public static SpacecraftState computeMeanState(final SpacecraftState osculating,
+                                                   final AttitudeProvider attitudeProvider,
+                                                   final Collection<DSSTForceModel> forceModels,
+                                                   final double epsilon,
+                                                   final int maxIterations) {
+        final Orbit meanOrbit = computeMeanOrbit(osculating, attitudeProvider, forceModels, epsilon, maxIterations);
         return new SpacecraftState(meanOrbit, osculating.getAttitude(), osculating.getMass(), osculating.getAdditionalStates());
     }
 
@@ -587,17 +622,18 @@ public class DSSTPropagator extends AbstractIntegratedPropagator {
      * @param attitudeProvider attitude provider (may be null if there are no Gaussian force models
      * like atmospheric drag, radiation pressure or specific user-defined models)
      * @param forceModels force models
+     * @param epsilon convergence threshold for mean parameters conversion
+     * @param maxIterations maximum iterations for mean parameters conversion
      * @return mean state
      */
     private static Orbit computeMeanOrbit(final SpacecraftState osculating,
                                           final AttitudeProvider attitudeProvider,
-                                          final Collection<DSSTForceModel> forceModels) {
+                                          final Collection<DSSTForceModel> forceModels, final double epsilon, final int maxIterations) {
 
         // rough initialization of the mean parameters
         EquinoctialOrbit meanOrbit = (EquinoctialOrbit) OrbitType.EQUINOCTIAL.convertType(osculating.getOrbit());
 
         // threshold for each parameter
-        final double epsilon    = 1.0e-13;
         final double thresholdA = epsilon * (1 + FastMath.abs(meanOrbit.getA()));
         final double thresholdE = epsilon * (1 + meanOrbit.getE());
         final double thresholdI = epsilon * (1 + meanOrbit.getI());
@@ -609,7 +645,7 @@ public class DSSTPropagator extends AbstractIntegratedPropagator {
         }
 
         int i = 0;
-        while (i++ < 200) {
+        while (i++ < maxIterations) {
 
             final SpacecraftState meanState = new SpacecraftState(meanOrbit, osculating.getAttitude(), osculating.getMass());
 
diff --git a/src/main/java/org/orekit/propagation/semianalytical/dsst/FieldDSSTPropagator.java b/src/main/java/org/orekit/propagation/semianalytical/dsst/FieldDSSTPropagator.java
index 8afe98435432a541ca9f2e3eb770fb8e0099f990..1bac56462c4d272172cc24892679889f2a9bdb2d 100644
--- a/src/main/java/org/orekit/propagation/semianalytical/dsst/FieldDSSTPropagator.java
+++ b/src/main/java/org/orekit/propagation/semianalytical/dsst/FieldDSSTPropagator.java
@@ -144,6 +144,12 @@ public class FieldDSSTPropagator<T extends RealFieldElement<T>> extends FieldAbs
     /** Number of grid points per integration step to be used in interpolation of short periodics coefficients.*/
     private static final int INTERPOLATION_POINTS_PER_STEP = 3;
 
+    /** Default value for epsilon. */
+    private static final double EPSILON_DEFAULT = 1.0e-13;
+
+    /** Default value for maxIterations. */
+    private static final int MAX_ITERATIONS_DEFAULT = 200;
+
     /** Flag specifying whether the initial orbital state is given with osculating elements. */
     private boolean initialIsOsculating;
 
@@ -494,7 +500,36 @@ public class FieldDSSTPropagator<T extends RealFieldElement<T>> extends FieldAbs
     public FieldSpacecraftState<T> computeMeanState(final FieldSpacecraftState<T> osculating,
                                                     final AttitudeProvider attitudeProvider,
                                                     final Collection<DSSTForceModel> forceModel) {
-        final FieldOrbit<T> meanOrbit = computeMeanOrbit(osculating, attitudeProvider, forceModel);
+        return computeMeanState(osculating, attitudeProvider, forceModel, EPSILON_DEFAULT, MAX_ITERATIONS_DEFAULT);
+    }
+
+    /** Conversion from osculating to mean orbit.
+     * <p>
+     * Compute mean state <b>in a DSST sense</b>, corresponding to the
+     * osculating SpacecraftState in input, and according to the Force models
+     * taken into account.
+     * </p><p>
+     * Since the osculating state is obtained with the computation of
+     * short-periodic variation of each force model, the resulting output will
+     * depend on the force models parameterized in input.
+     * </p><p>
+     * The computation is done through a fixed-point iteration process.
+     * </p>
+     * @param osculating Osculating state to convert
+     * @param attitudeProvider attitude provider (may be null if there are no Gaussian force models
+     * like atmospheric drag, radiation pressure or specific user-defined models)
+     * @param forceModel Forces to take into account
+     * @param epsilon convergence threshold for mean parameters conversion
+     * @param maxIterations maximum iterations for mean parameters conversion
+     * @return mean state in a DSST sense
+     * @since 10.1
+     */
+    public FieldSpacecraftState<T> computeMeanState(final FieldSpacecraftState<T> osculating,
+                                                    final AttitudeProvider attitudeProvider,
+                                                    final Collection<DSSTForceModel> forceModel,
+                                                    final double epsilon,
+                                                    final int maxIterations) {
+        final FieldOrbit<T> meanOrbit = computeMeanOrbit(osculating, attitudeProvider, forceModel, epsilon, maxIterations);
         return new FieldSpacecraftState<>(meanOrbit, osculating.getAttitude(), osculating.getMass(), osculating.getAdditionalStates());
     }
 
@@ -599,12 +634,14 @@ public class FieldDSSTPropagator<T extends RealFieldElement<T>> extends FieldAbs
      * @param attitudeProvider attitude provider (may be null if there are no Gaussian force models
      * like atmospheric drag, radiation pressure or specific user-defined models)
      * @param forceModel force models
+     * @param epsilon convergence threshold for mean parameters conversion
+     * @param maxIterations maximum iterations for mean parameters conversion
      * @return mean state
+     * @since 10.1
      */
     @SuppressWarnings("unchecked")
-    private FieldOrbit<T> computeMeanOrbit(final FieldSpacecraftState<T> osculating,
-                                           final AttitudeProvider attitudeProvider,
-                                           final Collection<DSSTForceModel> forceModel) {
+    private FieldOrbit<T> computeMeanOrbit(final FieldSpacecraftState<T> osculating, final AttitudeProvider attitudeProvider, final Collection<DSSTForceModel> forceModel,
+                                           final double epsilon, final int maxIterations) {
 
         // zero
         final T zero = field.getZero();
@@ -613,11 +650,11 @@ public class FieldDSSTPropagator<T extends RealFieldElement<T>> extends FieldAbs
         FieldEquinoctialOrbit<T> meanOrbit = (FieldEquinoctialOrbit<T>) OrbitType.EQUINOCTIAL.convertType(osculating.getOrbit());
 
         // threshold for each parameter
-        final T epsilon    = zero.add(1.0e-13);
-        final T thresholdA = epsilon.multiply(FastMath.abs(meanOrbit.getA()).add(1.));
-        final T thresholdE = epsilon.multiply(meanOrbit.getE().add(1.));
-        final T thresholdI = epsilon.multiply(meanOrbit.getI().add(1.));
-        final T thresholdL = epsilon.multiply(FastMath.PI);
+        final T epsilonT   = zero.add(epsilon);
+        final T thresholdA = epsilonT.multiply(FastMath.abs(meanOrbit.getA()).add(1.));
+        final T thresholdE = epsilonT.multiply(meanOrbit.getE().add(1.));
+        final T thresholdI = epsilonT.multiply(meanOrbit.getI().add(1.));
+        final T thresholdL = epsilonT.multiply(FastMath.PI);
 
         // ensure all Gaussian force models can rely on attitude
         for (final DSSTForceModel force : forceModel) {
@@ -625,7 +662,7 @@ public class FieldDSSTPropagator<T extends RealFieldElement<T>> extends FieldAbs
         }
 
         int i = 0;
-        while (i++ < 200) {
+        while (i++ < maxIterations) {
 
             final FieldSpacecraftState<T> meanState = new FieldSpacecraftState<>(meanOrbit, osculating.getAttitude(), osculating.getMass());