1   /* Copyright 2002-2026 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.utils.drivers;
18  
19  import java.util.List;
20  
21  import org.hipparchus.CalculusFieldElement;
22  import org.hipparchus.Field;
23  import org.hipparchus.util.MathArrays;
24  import org.orekit.errors.UnsupportedParameterException;
25  
26  /** Provider for {@link ParameterDriver parameters drivers}.
27   * @author Luc Maisonobe
28   * @author Melina Vanel
29   * @author Maxime Journot
30   * @since 11.2
31   */
32  public interface ParameterDriversProvider {
33  
34      /** Find if a parameter driver with a given name already exists in a list of parameter drivers.
35       * @param driversList the list of parameter drivers
36       * @param name the parameter driver's name to filter with
37       * @return true if the name was found, false otherwise
38       * @since 13.0
39       */
40      static boolean findByName(final List<ParameterDriver> driversList, final String name) {
41          for (final ParameterDriver d : driversList) {
42              if (d.getName().equals(name)) {
43                  return true;
44              }
45          }
46          return false;
47      }
48  
49      /** Get the drivers for parameters.
50       * @return drivers for parameters
51       */
52      List<ParameterDriver> getParametersDrivers();
53  
54      /** Get model parameters.
55       * @return model parameters
56       * @since 12.0
57       */
58      default double[] getParameters() {
59          final List<ParameterDriver> drivers = getParametersDrivers();
60          final double[] parameters = new double[drivers.size()];
61          for (int i = 0; i < drivers.size(); ++i) {
62              parameters[i] = drivers.get(i).getValue();
63          }
64          return parameters;
65      }
66  
67      /** Get model parameters.
68       * @param field field to which the elements belong
69       * @param <T> type of the elements
70       * @return model parameters
71       * @since 9.0
72       */
73      default <T extends CalculusFieldElement<T>> T[] getParameters(final Field<T> field) {
74          final List<ParameterDriver> drivers = getParametersDrivers();
75          final T[] parameters = MathArrays.buildArray(field, drivers.size());
76          for (int i = 0; i < drivers.size(); ++i) {
77              parameters[i] = field.getZero().newInstance(drivers.get(i).getValue());
78          }
79          return parameters;
80      }
81  
82      /** Get parameter value from its name.
83       * @param name parameter name
84       * @return parameter value
85       * @since 8.0
86       */
87      default ParameterDriver getParameterDriver(final String name) {
88  
89          for (final ParameterDriver driver : getParametersDrivers()) {
90              if (name.equals(driver.getName())) {
91                  // we have found a parameter with that name
92                  return driver;
93              }
94          }
95          throw new UnsupportedParameterException(name, getParametersDrivers());
96      }
97  
98      /** Get parameter that matches the sub-name.
99       * @param subString a string containing text unique to a single parameter driver
100      * @return parameter value
101      * @since 14.0
102      */
103     default ParameterDriver getParameterDriverWithSubstring(final String subString) {
104         ParameterDriver result = null;
105         for (final ParameterDriver driver : getParametersDrivers()) {
106             if (driver.getName().contains(subString) && result == null) {
107                 // we have found a parameter with that name
108                 result = driver;
109             }
110             else if (driver.getName().contains(subString) && result != null) {
111                 throw new UnsupportedParameterException(subString, getParametersDrivers());
112             }
113         }
114         if (result == null) {
115             throw new UnsupportedParameterException(subString, getParametersDrivers());
116         }
117         return result;
118     }
119 
120 
121     /** Check if a parameter is supported.
122      * <p>Supported parameters are those listed by {@link #getParametersDrivers()}.</p>
123      * @param name parameter name to check
124      * @return true if the parameter is supported
125      * @see #getParametersDrivers()
126      * @since 8.0
127      */
128     default boolean isSupported(final String name) {
129         for (final ParameterDriver driver : getParametersDrivers()) {
130             if (name.equals(driver.getName())) {
131                 // we have found a parameter with that name
132                 return true;
133             }
134         }
135         // the parameter is not supported
136         return false;
137     }
138 }