OceanLoadingCoefficientsBLQFactory.java

  1. /* Copyright 2002-2018 CS Systèmes d'Information
  2.  * Licensed to CS Systèmes d'Information (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.models.earth.displacement;

  19. import java.io.BufferedReader;
  20. import java.io.IOException;
  21. import java.io.InputStream;
  22. import java.io.InputStreamReader;
  23. import java.util.ArrayList;
  24. import java.util.List;
  25. import java.util.Optional;
  26. import java.util.regex.Matcher;
  27. import java.util.regex.Pattern;
  28. import java.util.stream.Collectors;

  30. import org.hipparchus.util.FastMath;
  31. import org.orekit.bodies.GeodeticPoint;
  32. import org.orekit.data.DataLoader;
  33. import org.orekit.data.DataProvidersManager;
  34. import org.orekit.errors.OrekitException;
  35. import org.orekit.errors.OrekitMessages;

  37. /**
  38.  * Factory for ocean loading coefficients, using Onsala Space Observatory files in BLQ format.
  39.  * <p>
  40.  * Files in BLQ format can be generated using the form at the
  41.  * <a href="http://holt.oso.chalmers.se/loading/">Bos-Scherneck web site</a>,
  42.  * selecting BLQ as the output format.
  43.  * </p>
  44.  * <p>
  45.  * The sites names are extracted from the file content, not the file name, because the
  46.  * file can contain more than one station. As we expect existing files may have been
  47.  * stripped from headers and footers, we do not attempt to parse them. We only parse
  48.  * the series of 7 lines blocks starting with the lines with the station names and their
  49.  * coordinates and the 6 data lines that follows. Several such blocks may appear in the
  50.  * file. Copy-pasting the entire mail received from OSO after completing the web site
  51.  * form works, as intermediate lines between the 7 lines blocks are simply ignored.
  52.  * </p>
  53.  * @see OceanLoadingCoefficients
  54.  * @see OceanLoading
  55.  * @since 9.1
  56.  * @author Luc Maisonobe
  57.  */
  58. public class OceanLoadingCoefficientsBLQFactory {

  60.     /** Default supported files name pattern for Onsala Space Observatory files in BLQ format. */
  61.     public static final String DEFAULT_BLQ_SUPPORTED_NAMES = "^.+\\.blq$";

  63.     /** Main tides. */
  64.     private static final Tide[][] TIDES = {
  65.         {
  66.             Tide.SSA, Tide.MM, Tide.MF
  67.         }, {
  68.             Tide.Q1,  Tide.O1, Tide.P1, Tide.K1
  69.         }, {
  70.             Tide.N2,  Tide.M2, Tide.S2, Tide.K2
  71.         }
  72.     };

  74.     /** Species index for each column. */
  75.     private static final int[] I = {
  76.         2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0
  77.     };

  79.     /** Tides index for each column. */
  80.     private static final int[] J = {
  81.         1, 2, 0, 3, 3, 1, 2, 0, 2, 1, 0
  82.     };

  84.     /** Regular expression for supported files names. */
  85.     private final String supportedNames;

  87.     /** Parsed coefficients. */
  88.     private final List<OceanLoadingCoefficients> coefficients;

  90.     /** Simple constructor.
  91.      * <p>
  92.      * Files in BLQ format can be generated using the form at the
  93.      * <a href="http://holt.oso.chalmers.se/loading/">Bos-Scherneck web site</a>,
  94.      * selecting BLQ as the output format.
  95.      * </p>
  96.      * @param supportedNames regular expression for supported files names
  97.      * @see #DEFAULT_BLQ_SUPPORTED_NAMES
  98.      */
  99.     public OceanLoadingCoefficientsBLQFactory(final String supportedNames) {

  101.         this.supportedNames = supportedNames;
  102.         this.coefficients   = new ArrayList<>();

  104.     }

  106.     /** Lazy loading of coefficients.
  107.      * @exception OrekitException if coefficients cannot be read
  108.      */
  109.     private void loadsIfNeeded() throws OrekitException {
  110.         if (coefficients.isEmpty()) {
  111.             DataProvidersManager.getInstance().feed(supportedNames, new BLQParser());
  112.         }
  113.     }

  115.     /** Get the list of sites for which we have found coefficients, in lexicographic order ignoring case.
  116.      * @return list of sites for which we have found coefficients, in lexicographic order ignoring case
  117.      * @exception OrekitException if coefficients cannot be read
  118.      */
  119.     public List<String> getSites()
  120.         throws OrekitException {

  122.         loadsIfNeeded();

  124.         // extract sites names from the map
  125.         final List<String> sites = coefficients.stream().map(c -> c.getSiteName()).collect(Collectors.toList());

  127.         // sort to ensure we have a reproducible order
  128.         sites.sort((s1, s2) -> s1.compareToIgnoreCase(s2));

  130.         return sites;

  132.     }

  134.     /** Get the coefficients for a given site.
  135.      * @param site site name (as it appears in the Onsala Space Observatory files in BLQ format),
  136.      * ignoring case
  137.      * @return coefficients for the site
  138.      * @exception OrekitException if no coefficients are found for the specified site
  139.      */
  140.     public OceanLoadingCoefficients getCoefficients(final String site)
  141.         throws OrekitException {

  143.         loadsIfNeeded();

  145.         final Optional<OceanLoadingCoefficients> optional =
  146.                         coefficients.stream().filter(c -> c.getSiteName().equalsIgnoreCase(site)).findFirst();
  147.         if (!optional.isPresent()) {
  148.             throw new OrekitException(OrekitMessages.STATION_NOT_FOUND,
  149.                                       site,
  150.                                       getSites().stream().collect(Collectors.joining(", ")));
  151.         }

  153.         return optional.get();

  155.     }

  157.     /** Local parser for the Onsala Space Observatory BLQ files.
  158.      * <p>
  159.      * when completing the web site form, the email received as the following form:
  160.      * </p>
  161.      * <pre>
  162.      * $$ Ocean loading displacement
  163.      * $$
  164.      * $$ Calculated on holt using olfg/olmpp of H.-G. Scherneck
  165.      * $$
  166.      * $$ COLUMN ORDER:  M2  S2  N2  K2  K1  O1  P1  Q1  MF  MM SSA
  167.      * $$
  168.      * $$ ROW ORDER:
  169.      * $$ AMPLITUDES (m)
  170.      * $$   RADIAL
  171.      * $$   TANGENTL    EW
  172.      * $$   TANGENTL    NS
  173.      * $$ PHASES (degrees)
  174.      * $$   RADIAL
  175.      * $$   TANGENTL    EW
  176.      * $$   TANGENTL    NS
  177.      * $$
  178.      * $$ Displacement is defined positive in upwards, South and West direction.
  179.      * $$ The phase lag is relative to Greenwich and lags positive. The
  180.      * $$ Gutenberg-Bullen Greens function is used. In the ocean tide model the
  181.      * $$ deficit of tidal water mass has been corrected by subtracting a uniform
  182.      * $$ layer of water with a certain phase lag globally.
  183.      * $$
  184.      * $$ Complete <model name> : No interpolation of ocean model was necessary
  185.      * $$ <model name>_PP       : Ocean model has been interpolated near the station
  186.      * $$                         (PP = Post-Processing)
  187.      * $$
  188.      * $$ Ocean tide model: CSR4.0, long-period tides from FES99
  189.      * $$
  190.      * $$ END HEADER
  191.      * $$
  192.      *   Goldstone
  193.      * $$ Complete CSR4.0_f
  194.      * $$ Computed by OLFG, H.-G. Scherneck, Onsala Space Observatory 2017-Sep-28
  195.      * $$ Goldstone,                 RADI TANG  lon/lat:  243.1105   35.4259    0.000
  196.      *   .00130 .00155 .00064 .00052 .01031 .00661 .00339 .00119 .00005 .00002 .00003
  197.      *   .00136 .00020 .00024 .00004 .00322 .00202 .00106 .00036 .00007 .00003 .00001
  198.      *   .00372 .00165 .00082 .00045 .00175 .00113 .00057 .00022 .00004 .00002 .00003
  199.      *     -2.7 -106.3  -62.6 -106.8   41.6   27.3   40.4   24.0 -119.1 -123.2 -169.7
  200.      *   -145.3  -88.4  178.5  -66.3 -130.5 -145.3 -131.7 -148.7  124.3  139.6   23.3
  201.      *     90.7  111.1   74.1  111.3  176.9  165.3  175.8  164.0   48.9   25.3    4.5
  202.      * $$
  203.      *   ONSALA
  204.      * $$ CSR4.0_f_PP ID: 2017-09-28 15:01:14
  205.      * $$ Computed by OLMPP by H G Scherneck, Onsala Space Observatory, 2017
  206.      * $$ Onsala,                    RADI TANG  lon/lat:   11.9264   57.3958    0.000
  207.      *   .00344 .00121 .00078 .00031 .00189 .00116 .00064 .00004 .00090 .00048 .00041
  208.      *   .00143 .00035 .00035 .00008 .00053 .00051 .00018 .00009 .00013 .00006 .00007
  209.      *   .00086 .00023 .00023 .00006 .00029 .00025 .00010 .00008 .00003 .00001 .00000
  210.      *    -64.6  -50.3  -95.0  -53.1  -58.8 -152.4  -65.5 -133.8    9.8    5.8    2.1
  211.      *     85.4  115.2   56.7  114.7   99.5   15.9   94.2  -10.0 -166.3 -169.8 -177.7
  212.      *    110.7  147.1   93.9  148.6   49.4  -56.5   34.8 -169.9  -35.3   -3.7   10.1
  213.      * $$ END TABLE
  214.      * Errors:
  215.      * Warnings:
  216.      * </pre>
  217.      * <p>
  218.      * We only parse blocks 7 lines blocks starting with the lines with the station names
  219.      * and their coordinates and the 6 data lines that follows. Several such blocks may
  220.      * appear in the file.
  221.      * </p>
  222.      */
  223.     private class BLQParser implements DataLoader {

  225.         /** Pattern for fields with real type. */
  226.         private static final String  REAL_TYPE_PATTERN = "[-+]?(?:(?:\\p{Digit}+(?:\\.\\p{Digit}*)?)|(?:\\.\\p{Digit}+))(?:[eE][-+]?\\p{Digit}+)?";

  228.         /** Pattern for extracted real fields. */
  229.         private static final String  REAL_FIELD_PATTERN = "\\p{Space}*(" + REAL_TYPE_PATTERN + ")";

  231.         /** Pattern for end of line. */
  232.         private static final String  END_OF_LINE_PATTERN = "\\p{Space}*$";

  234.         /** Pattern for site name and coordinates lines. */
  235.         private static final String  SITE_LINE_PATTERN = "^\\$\\$ *([^,]*),\\p{Space}*(?:RADI TANG)?\\p{Space}*lon/lat:" +
  236.                                                          REAL_FIELD_PATTERN +
  237.                                                          REAL_FIELD_PATTERN +
  238.                                                          REAL_FIELD_PATTERN +
  239.                                                          END_OF_LINE_PATTERN;

  241.         /** Pattern for coefficients lines. */
  242.         private static final String  DATA_LINE_PATTERN = "^" +
  243.                                                          REAL_FIELD_PATTERN + // M₂ tide
  244.                                                          REAL_FIELD_PATTERN + // S₂ tide
  245.                                                          REAL_FIELD_PATTERN + // N₂ tide
  246.                                                          REAL_FIELD_PATTERN + // K₂ tide
  247.                                                          REAL_FIELD_PATTERN + // K₁ tide
  248.                                                          REAL_FIELD_PATTERN + // O₁ tide
  249.                                                          REAL_FIELD_PATTERN + // P₁ tide
  250.                                                          REAL_FIELD_PATTERN + // Q₁ tide
  251.                                                          REAL_FIELD_PATTERN + // Mf tide
  252.                                                          REAL_FIELD_PATTERN + // Mm tide
  253.                                                          REAL_FIELD_PATTERN + // Ssa tide
  254.                                                          END_OF_LINE_PATTERN;

  256.         /** Pattern for site name and coordinates lines. */
  257.         private final Pattern sitePattern;

  259.         /** Pattern for coefficients lines. */
  260.         private final Pattern dataPattern;

  262.         /** Simple constructor.
  263.          */
  264.         BLQParser() {
  265.             sitePattern = Pattern.compile(SITE_LINE_PATTERN);
  266.             dataPattern = Pattern.compile(DATA_LINE_PATTERN);
  267.         }

  269.         /** {@inheritDoc} */
  270.         @Override
  271.         public boolean stillAcceptsData() {
  272.             // as data for different stations may be in different files
  273.             // we always accept new data, even if we have already parsed
  274.             // some files
  275.             return true;
  276.         }

  278.         /** {@inheritDoc} */
  279.         @Override
  280.         public void loadData(final InputStream input, final String name)
  281.             throws IOException, OrekitException {

  283.             // temporary holders for parsed data
  284.             String         siteName     = null;
  285.             GeodeticPoint  siteLocation = null;
  286.             final double[][][] data     = new double[6][3][];
  287.             for (int i = 0; i < data.length; ++i) {
  288.                 data[i][0] = new double[3];
  289.                 data[i][1] = new double[4];
  290.                 data[i][2] = new double[4];
  291.             }

  293.             try (BufferedReader reader = new BufferedReader(new InputStreamReader(input, "UTF-8"))) {

  295.                 int     lineNumber = 0;
  296.                 int     dataLine   = -1;
  297.                 for (String line = reader.readLine(); line != null; line = reader.readLine()) {
  298.                     ++lineNumber;

  300.                     if (dataLine < 0) {
  301.                         // we are looking for a site line
  302.                         final Matcher matcher = sitePattern.matcher(line);
  303.                         if (matcher.matches()) {
  304.                             // the current line is a site description line
  305.                             siteName = matcher.group(1);
  306.                             siteLocation = new GeodeticPoint(FastMath.toRadians(Double.parseDouble(matcher.group(3))),
  307.                                                              FastMath.toRadians(Double.parseDouble(matcher.group(2))),
  308.                                                              Double.parseDouble(matcher.group(4)));
  309.                             // next line must be line 0 of the data
  310.                             dataLine = 0;
  311.                         }
  312.                     } else {
  313.                         // we are looking for a data line
  314.                         final Matcher matcher = dataPattern.matcher(line);
  315.                         if (!matcher.matches()) {
  316.                             throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  317.                                                       lineNumber, name, line);
  318.                         }
  319.                         for (int k = 0; k < I.length; ++k) {
  320.                             if (dataLine < 3) {
  321.                                 // amplitude data
  322.                                 data[dataLine][I[k]][J[k]] = Double.parseDouble(matcher.group(k + 1));
  323.                             } else {
  324.                                 // phase data (reversed to be negative for lags)
  325.                                 data[dataLine][I[k]][J[k]] = -FastMath.toRadians(Double.parseDouble(matcher.group(k + 1)));
  326.                             }
  327.                         }
  328.                         if (dataLine < data.length - 1) {
  329.                             // we need more data
  330.                             ++dataLine;
  331.                         } else {
  332.                             // it was the last data line
  333.                             coefficients.add(new OceanLoadingCoefficients(siteName, siteLocation, TIDES,
  334.                                                                           data[0], data[3],
  335.                                                                           data[1], data[4],
  336.                                                                           data[2], data[5]));
  337.                             dataLine = -1;
  338.                         }
  339.                     }
  340.                 }

  342.                 if (dataLine >= 0) {
  343.                     // we were looking for a line that did not appear
  344.                     throw new OrekitException(OrekitMessages.UNEXPECTED_END_OF_FILE_AFTER_LINE,
  345.                                               name, lineNumber);
  346.                 }

  348.             }
  349.         }

  351.     }

  353. }
Created with JaCoCo 0.7.9.201702052155