SHMFormatReader.java

  1. /* Copyright 2002-2020 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.forces.gravity.potential;

  19. import java.io.BufferedReader;
  20. import java.io.IOException;
  21. import java.io.InputStream;
  22. import java.io.InputStreamReader;
  23. import java.nio.charset.StandardCharsets;
  24. import java.text.ParseException;
  25. import java.util.ArrayList;
  26. import java.util.List;
  27. import java.util.Locale;
  28. import java.util.regex.Pattern;

  30. import org.hipparchus.util.FastMath;
  31. import org.hipparchus.util.Precision;
  32. import org.orekit.annotation.DefaultDataContext;
  33. import org.orekit.data.DataContext;
  34. import org.orekit.errors.OrekitException;
  35. import org.orekit.errors.OrekitMessages;
  36. import org.orekit.time.AbsoluteDate;
  37. import org.orekit.time.DateComponents;
  38. import org.orekit.time.TimeScale;
  39. import org.orekit.utils.Constants;

  41. /** Reader for the SHM gravity field format.
  42.  *
  43.  * <p> This format was used to describe the gravity field of EIGEN models
  44.  * published by the GFZ Potsdam up to 2003. It was then replaced by
  45.  * {@link ICGEMFormatReader ICGEM format}. The SHM format is described in
  46.  * <a href="http://op.gfz-potsdam.de/champ/docs_CHAMP/CH-FORMAT-REFLINKS.html"> Potsdam university
  47.  * website</a>.
  48.  *
  49.  * <p> The proper way to use this class is to call the {@link GravityFieldFactory}
  50.  *  which will determine which reader to use with the selected gravity field file.</p>
  51.  *
  52.  * @see GravityFields
  53.  * @author Fabien Maussion
  54.  */
  55. public class SHMFormatReader extends PotentialCoefficientsReader {

  57.     /** Pattern for delimiting regular expressions. */
  58.     private static final Pattern SEPARATOR = Pattern.compile("\\s+");

  60.     /** First field labels. */
  61.     private static final String GRCOEF = "GRCOEF";

  63.     /** Second field labels. */
  64.     private static final String GRCOF2 = "GRCOF2";

  66.     /** Drift coefficients labels. */
  67.     private static final String GRDOTA = "GRDOTA";

  69.     /** Reference date. */
  70.     private AbsoluteDate referenceDate;

  72.     /** Secular drift of the cosine coefficients. */
  73.     private final List<List<Double>> cDot;

  75.     /** Secular drift of the sine coefficients. */
  76.     private final List<List<Double>> sDot;

  78.     /** Simple constructor.
  79.      *
  80.      * <p>This constructor uses the {@link DataContext#getDefault() default data context}.
  81.      *
  82.      * @param supportedNames regular expression for supported files names
  83.      * @param missingCoefficientsAllowed if true, allows missing coefficients in the input data
  84.      * @see #SHMFormatReader(String, boolean, TimeScale)
  85.      */
  86.     @DefaultDataContext
  87.     public SHMFormatReader(final String supportedNames, final boolean missingCoefficientsAllowed) {
  88.         this(supportedNames, missingCoefficientsAllowed,
  89.                 DataContext.getDefault().getTimeScales().getTT());
  90.     }

  92.     /** Simple constructor.
  93.      * @param supportedNames regular expression for supported files names
  94.      * @param missingCoefficientsAllowed if true, allows missing coefficients in the input data
  95.      * @param timeScale for parsing dates.
  96.      * @since 10.1
  97.      */
  98.     public SHMFormatReader(final String supportedNames,
  99.                            final boolean missingCoefficientsAllowed,
  100.                            final TimeScale timeScale) {
  101.         super(supportedNames, missingCoefficientsAllowed, timeScale);
  102.         referenceDate = null;
  103.         cDot = new ArrayList<>();
  104.         sDot = new ArrayList<>();
  105.     }

  107.     /** {@inheritDoc} */
  108.     public void loadData(final InputStream input, final String name)
  109.         throws IOException, ParseException, OrekitException {

  111.         // reset the indicator before loading any data
  112.         setReadComplete(false);
  113.         referenceDate = null;
  114.         cDot.clear();
  115.         sDot.clear();

  117.         boolean    normalized = false;
  118.         TideSystem tideSystem = TideSystem.UNKNOWN;

  120.         boolean okEarth  = false;
  121.         boolean okSHM    = false;
  122.         boolean okCoeffs = false;
  123.         double[][] c     = null;
  124.         double[][] s     = null;
  125.         String line      = null;
  126.         int lineNumber   = 1;
  127.         try (BufferedReader r = new BufferedReader(new InputStreamReader(input, StandardCharsets.UTF_8))) {
  128.             line = r.readLine();
  129.             if ((line != null) &&
  130.                 "FIRST ".equals(line.substring(0, 6)) &&
  131.                 "SHM    ".equals(line.substring(49, 56))) {
  132.                 for (line = r.readLine(); line != null; line = r.readLine()) {
  133.                     lineNumber++;
  134.                     if (line.length() >= 6) {
  135.                         final String[] tab = SEPARATOR.split(line);

  137.                         // read the earth values
  138.                         if ("EARTH".equals(tab[0])) {
  139.                             setMu(parseDouble(tab[1]));
  140.                             setAe(parseDouble(tab[2]));
  141.                             okEarth = true;
  142.                         }

  144.                         // initialize the arrays
  145.                         if ("SHM".equals(tab[0])) {

  147.                             final int degree = FastMath.min(getMaxParseDegree(), Integer.parseInt(tab[1]));
  148.                             final int order  = FastMath.min(getMaxParseOrder(), degree);
  149.                             c = buildTriangularArray(degree, order, missingCoefficientsAllowed() ? 0.0 : Double.NaN);
  150.                             s = buildTriangularArray(degree, order, missingCoefficientsAllowed() ? 0.0 : Double.NaN);
  151.                             final String lowerCaseLine = line.toLowerCase(Locale.US);
  152.                             normalized = lowerCaseLine.contains("fully normalized");
  153.                             if (lowerCaseLine.contains("exclusive permanent tide")) {
  154.                                 tideSystem = TideSystem.TIDE_FREE;
  155.                             } else {
  156.                                 tideSystem = TideSystem.UNKNOWN;
  157.                             }
  158.                             okSHM = true;
  159.                         }

  161.                         // fill the arrays
  162.                         if (GRCOEF.equals(line.substring(0, 6)) || GRCOF2.equals(tab[0]) || GRDOTA.equals(tab[0])) {
  163.                             final int i = Integer.parseInt(tab[1]);
  164.                             final int j = Integer.parseInt(tab[2]);
  165.                             if (i < c.length && j < c[i].length) {
  166.                                 if (GRDOTA.equals(tab[0])) {

  168.                                     // store the secular drift coefficients
  169.                                     extendListOfLists(cDot, i, j, 0.0);
  170.                                     extendListOfLists(sDot, i, j, 0.0);
  171.                                     parseCoefficient(tab[3], cDot, i, j, "Cdot", name);
  172.                                     parseCoefficient(tab[4], sDot, i, j, "Sdot", name);

  174.                                     // check the reference date (format yyyymmdd)
  175.                                     final DateComponents localRef = new DateComponents(Integer.parseInt(tab[7].substring(0, 4)),
  176.                                                                                        Integer.parseInt(tab[7].substring(4, 6)),
  177.                                                                                        Integer.parseInt(tab[7].substring(6, 8)));
  178.                                     if (referenceDate == null) {
  179.                                         // first reference found, store it
  180.                                         referenceDate = toDate(localRef);
  181.                                     } else if (!referenceDate.equals(toDate(localRef))) {
  182.                                         throw new OrekitException(OrekitMessages.SEVERAL_REFERENCE_DATES_IN_GRAVITY_FIELD,
  183.                                                                   referenceDate, toDate(localRef), name);
  184.                                     }

  186.                                 } else {

  188.                                     // store the constant coefficients
  189.                                     parseCoefficient(tab[3], c, i, j, "C", name);
  190.                                     parseCoefficient(tab[4], s, i, j, "S", name);
  191.                                     okCoeffs = true;

  193.                                 }
  194.                             }
  195.                         }

  197.                     }
  198.                 }
  199.             }
  200.         } catch (NumberFormatException nfe) {
  201.             throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  202.                                       lineNumber, name, line);
  203.         }

  205.         if (missingCoefficientsAllowed() && c.length > 0 && c[0].length > 0) {
  206.             // ensure at least the (0, 0) element is properly set
  207.             if (Precision.equals(c[0][0], 0.0, 0)) {
  208.                 c[0][0] = 1.0;
  209.             }
  210.         }

  212.         if (!(okEarth && okSHM && okCoeffs)) {
  213.             String loaderName = getClass().getName();
  214.             loaderName = loaderName.substring(loaderName.lastIndexOf('.') + 1);
  215.             throw new OrekitException(OrekitMessages.UNEXPECTED_FILE_FORMAT_ERROR_FOR_LOADER,
  216.                                       name, loaderName);
  217.         }

  219.         setRawCoefficients(normalized, c, s, name);
  220.         setTideSystem(tideSystem);
  221.         setReadComplete(true);

  223.     }

  225.     /** Get a provider for read spherical harmonics coefficients.
  226.      * <p>
  227.      * SHM fields do include time-dependent parts which are taken into account
  228.      * in the returned provider.
  229.      * </p>
  230.      * @param wantNormalized if true, the provider will provide normalized coefficients,
  231.      * otherwise it will provide un-normalized coefficients
  232.      * @param degree maximal degree
  233.      * @param order maximal order
  234.      * @return a new provider
  235.      * @since 6.0
  236.      */
  237.     public RawSphericalHarmonicsProvider getProvider(final boolean wantNormalized,
  238.                                                      final int degree, final int order) {

  240.         // get the constant part
  241.         RawSphericalHarmonicsProvider provider = getConstantProvider(wantNormalized, degree, order);

  243.         if (!cDot.isEmpty()) {

  245.             // add the secular trend layer
  246.             final double[][] cArray = toArray(cDot);
  247.             final double[][] sArray = toArray(sDot);
  248.             rescale(1.0 / Constants.JULIAN_YEAR, true, cArray, sArray, wantNormalized, cArray, sArray);
  249.             provider = new SecularTrendSphericalHarmonics(provider, referenceDate, cArray, sArray);

  251.         }

  253.         return provider;

  255.     }

  257. }
Created with JaCoCo 0.8.6.202009150832