FundamentalNutationArguments.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.data;

  19. import java.io.BufferedReader;
  20. import java.io.IOException;
  21. import java.io.InputStream;
  22. import java.io.InputStreamReader;
  23. import java.io.Serializable;
  24. import java.nio.charset.StandardCharsets;
  25. import java.util.ArrayList;
  26. import java.util.Arrays;
  27. import java.util.HashMap;
  28. import java.util.List;
  29. import java.util.Map;
  30. import java.util.regex.Matcher;
  31. import java.util.regex.Pattern;

  33. import org.hipparchus.CalculusFieldElement;
  34. import org.hipparchus.exception.DummyLocalizable;
  35. import org.hipparchus.util.FastMath;
  36. import org.orekit.annotation.DefaultDataContext;
  37. import org.orekit.errors.OrekitException;
  38. import org.orekit.errors.OrekitInternalError;
  39. import org.orekit.errors.OrekitMessages;
  40. import org.orekit.time.AbsoluteDate;
  41. import org.orekit.time.FieldAbsoluteDate;
  42. import org.orekit.time.TimeScalarFunction;
  43. import org.orekit.time.TimeScale;
  44. import org.orekit.time.TimeScales;
  45. import org.orekit.utils.Constants;
  46. import org.orekit.utils.IERSConventions;

  48. /**
  49.  * Class computing the fundamental arguments for nutation and tides.
  50.  * <p>
  51.  * The fundamental arguments are split in two sets:
  52.  * </p>
  53.  * <ul>
  54.  *   <li>the Delaunay arguments for Moon and Sun effects</li>
  55.  *   <li>the planetary arguments for other planets</li>
  56.  * </ul>
  57.  *
  58.  * @author Luc Maisonobe
  59.  * @see SeriesTerm
  60.  * @see PoissonSeries
  61.  * @see BodiesElements
  62.  */
  63. public class FundamentalNutationArguments implements Serializable {

  65.     /** Serializable UID. */
  66.     private static final long serialVersionUID = 20131209L;

  68.     /** IERS conventions to use. */
  69.     private final IERSConventions conventions;

  71.     /** Time scale for GMST computation. */
  72.     private final TimeScale timeScale;

  74.     /** Function computing Greenwich Mean Sidereal Time. */
  75.     private final transient TimeScalarFunction gmstFunction;

  77.     /** Function computing Greenwich Mean Sidereal Time rate. */
  78.     private final transient TimeScalarFunction gmstRateFunction;

  80.     // luni-solar Delaunay arguments

  82.     /** Coefficients for mean anomaly of the Moon. */
  83.     private final double[] lCoefficients;

  85.     /** Coefficients for mean anomaly of the Sun. */
  86.     private final double[] lPrimeCoefficients;

  88.     /** Coefficients for L - Ω where L is the mean longitude of the Moon. */
  89.     private final double[] fCoefficients;

  91.     /** Coefficients for mean elongation of the Moon from the Sun. */
  92.     private final double[] dCoefficients;

  94.     /** Coefficients for mean longitude of the ascending node of the Moon. */
  95.     private final double[] omegaCoefficients;

  97.     // planetary nutation arguments

  99.     /** Coefficients for mean Mercury longitude. */
  100.     private final double[] lMeCoefficients;

  102.     /** Coefficients for mean Venus longitude. */
  103.     private final double[] lVeCoefficients;

  105.     /** Coefficients for mean Earth longitude. */
  106.     private final double[] lECoefficients;

  108.     /** Coefficients for mean Mars longitude. */
  109.     private final double[] lMaCoefficients;

  111.     /** Coefficients for mean Jupiter longitude. */
  112.     private final double[] lJCoefficients;

  114.     /** Coefficients for mean Saturn longitude. */
  115.     private final double[] lSaCoefficients;

  117.     /** Coefficients for mean Uranus longitude. */
  118.     private final double[] lUCoefficients;

  120.     /** Coefficients for mean Neptune longitude. */
  121.     private final double[] lNeCoefficients;

  123.     /** Coefficients for general accumulated precession. */
  124.     private final double[] paCoefficients;

  126.     /** Set of time scales to use in computations. */
  127.     private final transient TimeScales timeScales;

  129.     /** Build a model of fundamental arguments from an IERS table file.
  130.      *
  131.      * <p>This method uses the {@link DataContext#getDefault() default data context}.
  132.      *
  133.      * @param conventions IERS conventions to use
  134.      * @param timeScale time scale for GMST computation
  135.      * (may be null if tide parameter γ = GMST + π is not needed)
  136.      * @param stream stream containing the IERS table
  137.      * @param name name of the resource file (for error messages only)
  138.      * @see #FundamentalNutationArguments(IERSConventions, TimeScale, List, TimeScales)
  139.      * @see #FundamentalNutationArguments(IERSConventions, TimeScale, InputStream, String, TimeScales)
  140.      */
  141.     @DefaultDataContext
  142.     public FundamentalNutationArguments(final IERSConventions conventions,
  143.                                         final TimeScale timeScale,
  144.                                         final InputStream stream, final String name) {
  145.         this(conventions, timeScale, stream, name,
  146.                 DataContext.getDefault().getTimeScales());
  147.     }

  149.     /**
  150.      * Build a model of fundamental arguments from an IERS table file.
  151.      *
  152.      * @param conventions IERS conventions to use
  153.      * @param timeScale   time scale for GMST computation (may be null if tide parameter γ
  154.      *                    = GMST + π is not needed)
  155.      * @param stream      stream containing the IERS table
  156.      * @param name        name of the resource file (for error messages only)
  157.      * @param timeScales         TAI time scale
  158.      * @see #FundamentalNutationArguments(IERSConventions, TimeScale, List, TimeScales)
  159.      * @since 10.1
  160.      */
  161.     public FundamentalNutationArguments(final IERSConventions conventions,
  162.                                         final TimeScale timeScale,
  163.                                         final InputStream stream,
  164.                                         final String name,
  165.                                         final TimeScales timeScales) {
  166.         this(conventions, timeScale, parseCoefficients(stream, name), timeScales);
  167.     }

  169.     /** Build a model of fundamental arguments from an IERS table file.
  170.      *
  171.      * <p>This method uses the {@link DataContext#getDefault() default data context}.
  172.      *
  173.      * @param conventions IERS conventions to use
  174.      * @param timeScale time scale for GMST computation
  175.      * (may be null if tide parameter γ = GMST + π is not needed)
  176.      * @param coefficients list of coefficients arrays (all 14 arrays must be provided,
  177.      * the 5 Delaunay first and the 9 planetary afterwards)
  178.      * @since 6.1
  179.      * @see #FundamentalNutationArguments(IERSConventions, TimeScale, List, TimeScales)
  180.      */
  181.     @DefaultDataContext
  182.     public FundamentalNutationArguments(final IERSConventions conventions, final TimeScale timeScale,
  183.                                         final List<double[]> coefficients) {
  184.         this(conventions, timeScale, coefficients,
  185.                 DataContext.getDefault().getTimeScales());
  186.     }

  188.     /** Build a model of fundamental arguments from an IERS table file.
  189.      * @param conventions IERS conventions to use
  190.      * @param timeScale time scale for GMST computation
  191.      * (may be null if tide parameter γ = GMST + π is not needed)
  192.      * @param coefficients list of coefficients arrays (all 14 arrays must be provided,
  193.      * the 5 Delaunay first and the 9 planetary afterwards)
  194.      * @param timeScales used in the computation.
  195.      * @since 10.1
  196.      */
  197.     public FundamentalNutationArguments(final IERSConventions conventions,
  198.                                         final TimeScale timeScale,
  199.                                         final List<double[]> coefficients,
  200.                                         final TimeScales timeScales) {
  201.         this.conventions        = conventions;
  202.         this.timeScale          = timeScale;
  203.         this.timeScales         = timeScales;
  204.         this.gmstFunction       = (timeScale == null) ? null :
  205.                 conventions.getGMSTFunction(timeScale, timeScales);
  206.         this.gmstRateFunction   = (timeScale == null) ? null :
  207.                 conventions.getGMSTRateFunction(timeScale, timeScales);
  208.         this.lCoefficients      = coefficients.get( 0);
  209.         this.lPrimeCoefficients = coefficients.get( 1);
  210.         this.fCoefficients      = coefficients.get( 2);
  211.         this.dCoefficients      = coefficients.get( 3);
  212.         this.omegaCoefficients  = coefficients.get( 4);
  213.         this.lMeCoefficients    = coefficients.get( 5);
  214.         this.lVeCoefficients    = coefficients.get( 6);
  215.         this.lECoefficients     = coefficients.get( 7);
  216.         this.lMaCoefficients    = coefficients.get( 8);
  217.         this.lJCoefficients     = coefficients.get( 9);
  218.         this.lSaCoefficients    = coefficients.get(10);
  219.         this.lUCoefficients     = coefficients.get(11);
  220.         this.lNeCoefficients    = coefficients.get(12);
  221.         this.paCoefficients     = coefficients.get(13);
  222.     }

  224.     /** Parse coefficients.
  225.      * @param stream stream containing the IERS table
  226.      * @param name name of the resource file (for error messages only)
  227.      * @return list of coefficients arrays
  228.      */
  229.     private static List<double[]> parseCoefficients(final InputStream stream, final String name) {

  231.         if (stream == null) {
  232.             throw new OrekitException(OrekitMessages.UNABLE_TO_FIND_FILE, name);
  233.         }

  235.         // setup the reader
  236.         try (BufferedReader reader = new BufferedReader(new InputStreamReader(stream, StandardCharsets.UTF_8))) {

  238.             final DefinitionParser definitionParser = new DefinitionParser();

  240.             int lineNumber = 0;

  242.             // look for the reference date and the 14 polynomials
  243.             final int n = FundamentalName.values().length;
  244.             final Map<FundamentalName, double[]> polynomials = new HashMap<FundamentalName, double[]>(n);
  245.             for (String line = reader.readLine(); line != null; line = reader.readLine()) {
  246.                 lineNumber++;
  247.                 if (definitionParser.parseDefinition(line, lineNumber, name)) {
  248.                     polynomials.put(definitionParser.getParsedName(),
  249.                                     definitionParser.getParsedPolynomial());
  250.                 }
  251.             }

  253.             final List<double[]> coefficients = new ArrayList<double[]>(n);
  254.             coefficients.add(getCoefficients(FundamentalName.L,       polynomials, name));
  255.             coefficients.add(getCoefficients(FundamentalName.L_PRIME, polynomials, name));
  256.             coefficients.add(getCoefficients(FundamentalName.F,       polynomials, name));
  257.             coefficients.add(getCoefficients(FundamentalName.D,       polynomials, name));
  258.             coefficients.add(getCoefficients(FundamentalName.OMEGA,   polynomials, name));
  259.             if (polynomials.containsKey(FundamentalName.L_ME)) {
  260.                 // IERS conventions 2003 and later provide planetary nutation arguments
  261.                 coefficients.add(getCoefficients(FundamentalName.L_ME,    polynomials, name));
  262.                 coefficients.add(getCoefficients(FundamentalName.L_VE,    polynomials, name));
  263.                 coefficients.add(getCoefficients(FundamentalName.L_E,     polynomials, name));
  264.                 coefficients.add(getCoefficients(FundamentalName.L_MA,    polynomials, name));
  265.                 coefficients.add(getCoefficients(FundamentalName.L_J,     polynomials, name));
  266.                 coefficients.add(getCoefficients(FundamentalName.L_SA,    polynomials, name));
  267.                 coefficients.add(getCoefficients(FundamentalName.L_U,     polynomials, name));
  268.                 coefficients.add(getCoefficients(FundamentalName.L_NE,    polynomials, name));
  269.                 coefficients.add(getCoefficients(FundamentalName.PA,      polynomials, name));
  270.             } else {
  271.                 // IERS conventions 1996 and earlier don't provide planetary nutation arguments
  272.                 final double[] zero = new double[] {
  273.                     0.0
  274.                 };
  275.                 while (coefficients.size() < n) {
  276.                     coefficients.add(zero);
  277.                 }
  278.             }

  280.             return coefficients;

  282.         } catch (IOException ioe) {
  283.             throw new OrekitException(ioe, new DummyLocalizable(ioe.getMessage()));
  284.         }

  286.     }

  288.     /** Get the coefficients for a fundamental argument.
  289.      * @param argument fundamental argument
  290.      * @param polynomials map of the polynomials
  291.      * @param fileName name of the file from which the coefficients have been read
  292.      * @return polynomials coefficients (ordered from high degrees to low degrees)
  293.      */
  294.     private static double[] getCoefficients(final FundamentalName argument,
  295.                                             final Map<FundamentalName, double[]> polynomials,
  296.                                             final String fileName) {
  297.         if (!polynomials.containsKey(argument)) {
  298.             throw new OrekitException(OrekitMessages.NOT_A_SUPPORTED_IERS_DATA_FILE, fileName);
  299.         }
  300.         return polynomials.get(argument);
  301.     }

  303.     /** Evaluate a polynomial.
  304.      * @param tc offset in Julian centuries
  305.      * @param coefficients polynomial coefficients (ordered from low degrees to high degrees)
  306.      * @return value of the polynomial
  307.      */
  308.     private double value(final double tc, final double[] coefficients) {
  309.         double value = 0;
  310.         for (int i = coefficients.length - 1; i >= 0; --i) {
  311.             value = coefficients[i] + tc * value;
  312.         }
  313.         return value;
  314.     }

  316.     /** Evaluate a polynomial time derivative.
  317.      * @param tc offset in Julian centuries
  318.      * @param coefficients polynomial coefficients (ordered from low degrees to high degrees)
  319.      * @return time derivative of the polynomial
  320.      */
  321.     private double derivative(final double tc, final double[] coefficients) {
  322.         double derivative = 0;
  323.         for (int i = coefficients.length - 1; i > 0; --i) {
  324.             derivative = i * coefficients[i] + tc * derivative;
  325.         }
  326.         return derivative / Constants.JULIAN_CENTURY;
  327.     }

  329.     /** Evaluate a polynomial.
  330.      * @param tc offset in Julian centuries
  331.      * @param <T> type of the field elements
  332.      * @param coefficients polynomial coefficients (ordered from low degrees to high degrees)
  333.      * @return value of the polynomial
  334.      */
  335.     private <T extends CalculusFieldElement<T>> T value(final T tc, final double[] coefficients) {
  336.         T value = tc.getField().getZero();
  337.         for (int i = coefficients.length - 1; i >= 0; --i) {
  338.             value = tc.multiply(value).add(coefficients[i]);
  339.         }
  340.         return value;
  341.     }

  343.     /** Evaluate a polynomial time derivative.
  344.      * @param tc offset in Julian centuries
  345.      * @param <T> type of the field elements
  346.      * @param coefficients polynomial coefficients (ordered from low degrees to high degrees)
  347.      * @return time derivative of the polynomial
  348.      */
  349.     private <T extends CalculusFieldElement<T>> T derivative(final T tc, final double[] coefficients) {
  350.         T derivative = tc.getField().getZero();
  351.         for (int i = coefficients.length - 1; i > 0; --i) {
  352.             derivative = tc.multiply(derivative).add(i * coefficients[i]);
  353.         }
  354.         return derivative.divide(Constants.JULIAN_CENTURY);
  355.     }

  357.     /** Evaluate all fundamental arguments for the current date (Delaunay plus planetary).
  358.      * @param date current date
  359.      * @return all fundamental arguments for the current date (Delaunay plus planetary)
  360.      */
  361.     public BodiesElements evaluateAll(final AbsoluteDate date) {

  363.         final double tc       = conventions.evaluateTC(date, timeScales);
  364.         final double gamma    = gmstFunction == null ?
  365.                                 Double.NaN : gmstFunction.value(date) + FastMath.PI;
  366.         final double gammaDot = gmstRateFunction == null ?
  367.                                 Double.NaN : gmstRateFunction.value(date);

  369.         return new BodiesElements(date, tc, gamma, gammaDot,
  370.                                   value(tc, lCoefficients),           // mean anomaly of the Moon
  371.                                   derivative(tc, lCoefficients),      // mean anomaly of the Moon time derivative
  372.                                   value(tc, lPrimeCoefficients),      // mean anomaly of the Sun
  373.                                   derivative(tc, lPrimeCoefficients), // mean anomaly of the Sun time derivative
  374.                                   value(tc, fCoefficients),           // L - Ω where L is the mean longitude of the Moon
  375.                                   derivative(tc, fCoefficients),      // L - Ω where L is the mean longitude of the Moon time derivative
  376.                                   value(tc, dCoefficients),           // mean elongation of the Moon from the Sun
  377.                                   derivative(tc, dCoefficients),      // mean elongation of the Moon from the Sun time derivative
  378.                                   value(tc, omegaCoefficients),       // mean longitude of the ascending node of the Moon
  379.                                   derivative(tc, omegaCoefficients),  // mean longitude of the ascending node of the Moon time derivative
  380.                                   value(tc, lMeCoefficients),         // mean Mercury longitude
  381.                                   derivative(tc, lMeCoefficients),    // mean Mercury longitude time derivative
  382.                                   value(tc, lVeCoefficients),         // mean Venus longitude
  383.                                   derivative(tc, lVeCoefficients),    // mean Venus longitude time derivative
  384.                                   value(tc, lECoefficients),          // mean Earth longitude
  385.                                   derivative(tc, lECoefficients),     // mean Earth longitude time derivative
  386.                                   value(tc, lMaCoefficients),         // mean Mars longitude
  387.                                   derivative(tc, lMaCoefficients),    // mean Mars longitude time derivative
  388.                                   value(tc, lJCoefficients),          // mean Jupiter longitude
  389.                                   derivative(tc, lJCoefficients),     // mean Jupiter longitude time derivative
  390.                                   value(tc, lSaCoefficients),         // mean Saturn longitude
  391.                                   derivative(tc, lSaCoefficients),    // mean Saturn longitude time derivative
  392.                                   value(tc, lUCoefficients),          // mean Uranus longitude
  393.                                   derivative(tc, lUCoefficients),     // mean Uranus longitude time derivative
  394.                                   value(tc, lNeCoefficients),         // mean Neptune longitude
  395.                                   derivative(tc, lNeCoefficients),    // mean Neptune longitude time derivative
  396.                                   value(tc, paCoefficients),          // general accumulated precession in longitude
  397.                                   derivative(tc, paCoefficients));    // general accumulated precession in longitude time derivative

  399.     }

  401.     /** Evaluate all fundamental arguments for the current date (Delaunay plus planetary).
  402.      * @param date current date
  403.      * @param <T> type of the field elements
  404.      * @return all fundamental arguments for the current date (Delaunay plus planetary)
  405.      */
  406.     public <T extends CalculusFieldElement<T>> FieldBodiesElements<T> evaluateAll(final FieldAbsoluteDate<T> date) {

  408.         final T tc       = conventions.evaluateTC(date, timeScales);
  409.         final T gamma    = gmstFunction == null ?
  410.                            tc.getField().getZero().add(Double.NaN) : gmstFunction.value(date).add(tc.getPi());
  411.         final T gammaDot = gmstRateFunction == null ?
  412.                            tc.getField().getZero().add(Double.NaN) : gmstRateFunction.value(date);

  414.         return new FieldBodiesElements<>(date, tc, gamma, gammaDot,
  415.                                          value(tc, lCoefficients),           // mean anomaly of the Moon
  416.                                          derivative(tc, lCoefficients),      // mean anomaly of the Moon time derivative
  417.                                          value(tc, lPrimeCoefficients),      // mean anomaly of the Sun
  418.                                          derivative(tc, lPrimeCoefficients), // mean anomaly of the Sun time derivative
  419.                                          value(tc, fCoefficients),           // L - Ω where L is the mean longitude of the Moon
  420.                                          derivative(tc, fCoefficients),      // L - Ω where L is the mean longitude of the Moon time derivative
  421.                                          value(tc, dCoefficients),           // mean elongation of the Moon from the Sun
  422.                                          derivative(tc, dCoefficients),      // mean elongation of the Moon from the Sun time derivative
  423.                                          value(tc, omegaCoefficients),       // mean longitude of the ascending node of the Moon
  424.                                          derivative(tc, omegaCoefficients),  // mean longitude of the ascending node of the Moon time derivative
  425.                                          value(tc, lMeCoefficients),         // mean Mercury longitude
  426.                                          derivative(tc, lMeCoefficients),    // mean Mercury longitude time derivative
  427.                                          value(tc, lVeCoefficients),         // mean Venus longitude
  428.                                          derivative(tc, lVeCoefficients),    // mean Venus longitude time derivative
  429.                                          value(tc, lECoefficients),          // mean Earth longitude
  430.                                          derivative(tc, lECoefficients),     // mean Earth longitude time derivative
  431.                                          value(tc, lMaCoefficients),         // mean Mars longitude
  432.                                          derivative(tc, lMaCoefficients),    // mean Mars longitude time derivative
  433.                                          value(tc, lJCoefficients),          // mean Jupiter longitude
  434.                                          derivative(tc, lJCoefficients),     // mean Jupiter longitude time derivative
  435.                                          value(tc, lSaCoefficients),         // mean Saturn longitude
  436.                                          derivative(tc, lSaCoefficients),    // mean Saturn longitude time derivative
  437.                                          value(tc, lUCoefficients),          // mean Uranus longitude
  438.                                          derivative(tc, lUCoefficients),     // mean Uranus longitude time derivative
  439.                                          value(tc, lNeCoefficients),         // mean Neptune longitude
  440.                                          derivative(tc, lNeCoefficients),    // mean Neptune longitude time derivative
  441.                                          value(tc, paCoefficients),          // general accumulated precession in longitude
  442.                                          derivative(tc, paCoefficients));    // general accumulated precession in longitude time derivative

  444.     }

  446.     /** Replace the instance with a data transfer object for serialization.
  447.      * <p>
  448.      * This intermediate class serializes only the frame key.
  449.      * </p>
  450.      * @return data transfer object that will be serialized
  451.      */
  452.     @DefaultDataContext
  453.     private Object writeReplace() {
  454.         return new DataTransferObject(conventions, timeScale,
  455.                                       Arrays.asList(lCoefficients, lPrimeCoefficients, fCoefficients,
  456.                                                     dCoefficients, omegaCoefficients,
  457.                                                     lMeCoefficients, lVeCoefficients, lECoefficients,
  458.                                                     lMaCoefficients, lJCoefficients, lSaCoefficients,
  459.                                                     lUCoefficients, lNeCoefficients, paCoefficients));
  460.     }

  462.     /** Internal class used only for serialization. */
  463.     @DefaultDataContext
  464.     private static class DataTransferObject implements Serializable {

  466.         /** Serializable UID. */
  467.         private static final long serialVersionUID = 20131209L;

  469.         /** IERS conventions to use. */
  470.         private final IERSConventions conventions;

  472.         /** Time scale for GMST computation. */
  473.         private final TimeScale timeScale;

  475.         /** All coefficients. */
  476.         private final List<double[]> coefficients;

  478.         /** Simple constructor.
  479.          * @param conventions IERS conventions to use
  480.          * @param timeScale time scale for GMST computation
  481.          * @param coefficients all coefficients
  482.          */
  483.         DataTransferObject(final IERSConventions conventions, final TimeScale timeScale,
  484.                                   final List<double[]> coefficients) {
  485.             this.conventions  = conventions;
  486.             this.timeScale    = timeScale;
  487.             this.coefficients = coefficients;
  488.         }

  490.         /** Replace the deserialized data transfer object with a {@link TIRFProvider}.
  491.          * @return replacement {@link TIRFProvider}
  492.          */
  493.         private Object readResolve() {
  494.             try {
  495.                 // retrieve a managed frame
  496.                 return new FundamentalNutationArguments(conventions, timeScale, coefficients);
  497.             } catch (OrekitException oe) {
  498.                 throw new OrekitInternalError(oe);
  499.             }
  500.         }

  502.     }

  504.     /** Enumerate for the fundamental names. */
  505.     private enum FundamentalName {

  507.         /** Constant for Mean anomaly of the Moon. */
  508.         L() {
  509.             /** {@inheritDoc} */
  510.             public String getArgumentName() {
  511.                 return "l";
  512.             }
  513.         },

  515.         /** Constant for Mean anomaly of the Sun. */
  516.         L_PRIME() {
  517.             /** {@inheritDoc} */
  518.             public String getArgumentName() {
  519.                 return "l'";
  520.             }
  521.         },

  523.         /** Constant for L - Ω where L is the mean longitude of the Moon. */
  524.         F() {
  525.             /** {@inheritDoc} */
  526.             public String getArgumentName() {
  527.                 return "F";
  528.             }
  529.         },

  531.         /** Constant for mean elongation of the Moon from the Sun. */
  532.         D() {
  533.             /** {@inheritDoc} */
  534.             public String getArgumentName() {
  535.                 return "D";
  536.             }
  537.         },

  539.         /** Constant for longitude of the ascending node of the Moon. */
  540.         OMEGA() {
  541.             /** {@inheritDoc} */
  542.             public String getArgumentName() {
  543.                 return "\u03a9";
  544.             }
  545.         },

  547.         /** Constant for mean Mercury longitude. */
  548.         L_ME() {
  549.             /** {@inheritDoc} */
  550.             public String getArgumentName() {
  551.                 return "LMe";
  552.             }
  553.         },

  555.         /** Constant for mean Venus longitude. */
  556.         L_VE() {
  557.             /** {@inheritDoc} */
  558.             public String getArgumentName() {
  559.                 return "LVe";
  560.             }
  561.         },

  563.         /** Constant for mean Earth longitude. */
  564.         L_E() {
  565.             /** {@inheritDoc} */
  566.             public String getArgumentName() {
  567.                 return "LE";
  568.             }
  569.         },

  571.         /** Constant for mean Mars longitude. */
  572.         L_MA() {
  573.             /** {@inheritDoc} */
  574.             public String getArgumentName() {
  575.                 return "LMa";
  576.             }
  577.         },

  579.         /** Constant for mean Jupiter longitude. */
  580.         L_J() {
  581.             /** {@inheritDoc} */
  582.             public String getArgumentName() {
  583.                 return "LJ";
  584.             }
  585.         },

  587.         /** Constant for mean Saturn longitude. */
  588.         L_SA() {
  589.             /** {@inheritDoc} */
  590.             public String getArgumentName() {
  591.                 return "LSa";
  592.             }
  593.         },

  595.         /** Constant for mean Uranus longitude. */
  596.         L_U() {
  597.             /** {@inheritDoc} */
  598.             public String getArgumentName() {
  599.                 return "LU";
  600.             }
  601.         },

  603.         /** Constant for mean Neptune longitude. */
  604.         L_NE() {
  605.             /** {@inheritDoc} */
  606.             public String getArgumentName() {
  607.                 return "LNe";
  608.             }
  609.         },

  611.         /** Constant for general accumulated precession in longitude. */
  612.         PA() {
  613.             /** {@inheritDoc} */
  614.             public String getArgumentName() {
  615.                 return "pA";
  616.             }
  617.         };

  619.         /** Get the fundamental name.
  620.          * @return fundamental name
  621.          */
  622.         public abstract String getArgumentName();

  624.     }

  626.     /** Local parser for argument definition lines. */
  627.     private static class DefinitionParser {

  629.         /** Regular expression pattern for definitions. */
  630.         private final Pattern pattern;

  632.         /** Parser for polynomials. */
  633.         private PolynomialParser polynomialParser;

  635.         /** Last parsed fundamental name. */
  636.         private FundamentalName parsedName;

  638.         /** Last parsed polynomial. */
  639.         private double[] parsedPolynomial;

  641.         /** Simple constructor. */
  642.         DefinitionParser() {

  644.             // the luni-solar Delaunay arguments polynomial parts should read something like:
  645.             // F5 ≡ Ω = 125.04455501° − 6962890.5431″t + 7.4722″t² + 0.007702″t³ − 0.00005939″t⁴
  646.             // whereas the planetary arguments polynomial parts should read something like:
  647.             // F14 ≡ pA  = 0.02438175 × t + 0.00000538691 × t²
  648.             final String unicodeIdenticalTo = "\u2261";

  650.             // pattern for the global line
  651.             final StringBuilder builder = new StringBuilder();
  652.             for (final FundamentalName fn : FundamentalName.values()) {
  653.                 if (builder.length() > 0) {
  654.                     builder.append('|');
  655.                 }
  656.                 builder.append(fn.getArgumentName());
  657.             }
  658.             final String fundamentalName = "\\p{Space}*((?:" + builder.toString() + ")+)";
  659.             pattern = Pattern.compile("\\p{Space}*F\\p{Digit}+\\p{Space}*" + unicodeIdenticalTo +
  660.                                       fundamentalName + "\\p{Space}*=\\p{Space}*(.*)");

  662.             polynomialParser = new PolynomialParser('t', PolynomialParser.Unit.NO_UNITS);

  664.         }

  666.         /** Parse a definition line.
  667.          * @param line line to parse
  668.          * @param lineNumber line number
  669.          * @param fileName name of the file
  670.          * @return true if a definition has been parsed
  671.          */
  672.         public boolean parseDefinition(final String line, final int lineNumber, final String fileName) {

  674.             parsedName       = null;
  675.             parsedPolynomial = null;

  677.             final Matcher matcher = pattern.matcher(line);
  678.             if (matcher.matches()) {
  679.                 for (FundamentalName fn : FundamentalName.values()) {
  680.                     if (fn.getArgumentName().equals(matcher.group(1))) {
  681.                         parsedName = fn;
  682.                     }
  683.                 }

  685.                 // parse the polynomial
  686.                 parsedPolynomial = polynomialParser.parse(matcher.group(2));

  688.                 return true;

  690.             } else {
  691.                 return false;
  692.             }

  694.         }

  696.         /** Get the last parsed fundamental name.
  697.          * @return last parsed fundamental name
  698.          */
  699.         public FundamentalName getParsedName() {
  700.             return parsedName;
  701.         }

  703.         /** Get the last parsed polynomial.
  704.          * @return last parsed polynomial
  705.          */
  706.         public double[] getParsedPolynomial() {
  707.             return parsedPolynomial.clone();
  708.         }

  710.     }

  712. }
Created with JaCoCo 0.8.11.202310140853