UTCTAIBulletinAFilesLoader.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.time;

  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.Arrays;
  25. import java.util.List;
  26. import java.util.Map;
  27. import java.util.SortedMap;
  28. import java.util.TreeMap;
  29. import java.util.regex.Matcher;
  30. import java.util.regex.Pattern;

  32. import org.hipparchus.util.FastMath;
  33. import org.orekit.data.DataLoader;
  34. import org.orekit.data.DataProvidersManager;
  35. import org.orekit.errors.OrekitException;
  36. import org.orekit.errors.OrekitMessages;

  38. /** Loader for UTC-TAI extracted from bulletin A files.
  39.  * <p>This class is a modified version of {@code BulletinAFileLoader}
  40.  * that only parses the TAI-UTC header line and checks the UT1-UTC column
  41.  * for discontinuities.
  42.  * </p>
  43.  * <p>
  44.  * Note that extracting UTC-TAI from bulletin A files is <em>NOT</em>
  45.  * recommended. There are known issues in some past bulletin A
  46.  * (for example bulletina-xix-001.txt from 2006-01-05 has a wrong year
  47.  * for last leap second and bulletina-xxi-053.txt from 2008-12-31 has an
  48.  * off by one value for TAI-UTC on MJD 54832). This is a known problem,
  49.  * and the Earth Orientation Department at USNO told us this TAI-UTC
  50.  * data was only provided as a convenience and this data should rather
  51.  * be sourced from other official files. As the bulletin A files are
  52.  * a record of past publications, they cannot modify archived bulletins,
  53.  * hence the errors above will remain forever. This UTC-TAI loader should
  54.  * therefore be used with great care.
  55.  * </p>
  56.  * <p>
  57.  * This class is immutable and hence thread-safe
  58.  * </p>
  59.  * @author Luc Maisonobe
  60.  * @since 7.1
  61.  */
  62. public class UTCTAIBulletinAFilesLoader implements UTCTAIOffsetsLoader {

  64.     /** Regular expression for supported files names. */
  65.     private final String supportedNames;

  67.     /** Build a loader for IERS bulletins A files.
  68.     * @param supportedNames regular expression for supported files names
  69.     */
  70.     public UTCTAIBulletinAFilesLoader(final String supportedNames) {
  71.         this.supportedNames = supportedNames;
  72.     }

  74.     /** {@inheritDoc} */
  75.     @Override
  76.     public List<OffsetModel> loadOffsets() throws OrekitException {

  78.         final Parser parser = new Parser();
  79.         DataProvidersManager.getInstance().feed(supportedNames, parser);
  80.         final SortedMap<Integer, Integer> taiUtc = parser.getTaiUtc();
  81.         final SortedMap<Integer, Double>  ut1Utc = parser.getUt1Utc();

  83.         // identify UT1-UTC discontinuities
  84.         final List<Integer> leapDays = new ArrayList<Integer>();
  85.         Map.Entry<Integer, Double> previous = null;
  86.         for (final Map.Entry<Integer, Double> entry : ut1Utc.entrySet()) {
  87.             if (previous != null) {
  88.                 final double delta = entry.getValue() - previous.getValue();
  89.                 if (FastMath.abs(delta) > 0.5) {
  90.                     // discontinuity found between previous and current entry, a leap second has occurred
  91.                     leapDays.add(entry.getKey());
  92.                 }
  93.             }
  94.             previous = entry;
  95.         }

  97.         final List<OffsetModel> offsets = new ArrayList<OffsetModel>();

  99.         if (!taiUtc.isEmpty()) {

  101.             // find the start offset, before the first UT1-UTC entry
  102.             final Map.Entry<Integer, Integer> firstTaiMUtc = taiUtc.entrySet().iterator().next();
  103.             int offset = firstTaiMUtc.getValue();
  104.             final int refMJD = firstTaiMUtc.getKey();
  105.             for (final int leapMJD : leapDays) {
  106.                 if (leapMJD > refMJD) {
  107.                     break;
  108.                 }
  109.                 --offset;
  110.             }

  112.             // set all known time steps
  113.             for (final int leapMJD : leapDays) {
  114.                 offsets.add(new OffsetModel(new DateComponents(DateComponents.MODIFIED_JULIAN_EPOCH, leapMJD),
  115.                                             ++offset));
  116.             }

  118.             // check for missing time steps
  119.             for (final Map.Entry<Integer, Integer> refTaiMUtc : taiUtc.entrySet()) {
  120.                 final DateComponents refDC = new DateComponents(DateComponents.MODIFIED_JULIAN_EPOCH,
  121.                                                                 refTaiMUtc.getKey() + 1);
  122.                 OffsetModel before = null;
  123.                 for (final OffsetModel o : offsets) {
  124.                     if (o.getStart().compareTo(refDC) < 0) {
  125.                         before = o;
  126.                     }
  127.                 }
  128.                 if (before != null) {
  129.                     if (refTaiMUtc.getValue() != (int) FastMath.rint(before.getOffset())) {
  130.                         throw new OrekitException(OrekitMessages.MISSING_EARTH_ORIENTATION_PARAMETERS_BETWEEN_DATES,
  131.                                                   before.getStart(), refDC);
  132.                     }
  133.                 }
  134.             }

  136.             // make sure we stop the linear drift that was used before 1972
  137.             if (offsets.isEmpty()) {
  138.                 offsets.add(0, new OffsetModel(new DateComponents(1972, 1, 1), taiUtc.get(taiUtc.firstKey())));
  139.             } else {
  140.                 if (offsets.get(0).getStart().getYear() > 1972) {
  141.                     offsets.add(0, new OffsetModel(new DateComponents(1972, 1, 1),
  142.                                                 ((int) FastMath.rint(offsets.get(0).getOffset())) - 1));
  143.                 }
  144.             }

  146.         }

  148.         return offsets;

  150.     }

  152.     /** Internal class performing the parsing. */
  153.     private static class Parser implements DataLoader {

  155.         /** Regular expression matching blanks at start of line. */
  156.         private static final String LINE_START_REGEXP     = "^\\p{Blank}+";

  158.         /** Regular expression matching blanks at end of line. */
  159.         private static final String LINE_END_REGEXP       = "\\p{Blank}*$";

  161.         /** Regular expression matching integers. */
  162.         private static final String INTEGER_REGEXP        = "[-+]?\\p{Digit}+";

  164.         /** Regular expression matching real numbers. */
  165.         private static final String REAL_REGEXP           = "[-+]?(?:(?:\\p{Digit}+(?:\\.\\p{Digit}*)?)|(?:\\.\\p{Digit}+))(?:[eE][-+]?\\p{Digit}+)?";

  167.         /** Regular expression matching an integer field to store. */
  168.         private static final String STORED_INTEGER_FIELD  = "\\p{Blank}*(" + INTEGER_REGEXP + ")";

  170.         /** regular expression matching a Modified Julian Day field to store. */
  171.         private static final String STORED_MJD_FIELD      = "\\p{Blank}+(\\p{Digit}\\p{Digit}\\p{Digit}\\p{Digit}\\p{Digit})";

  173.         /** Regular expression matching a real field to store. */
  174.         private static final String STORED_REAL_FIELD     = "\\p{Blank}+(" + REAL_REGEXP + ")";

  176.         /** Regular expression matching a real field to ignore. */
  177.         private static final String IGNORED_REAL_FIELD    = "\\p{Blank}+" + REAL_REGEXP;

  179.         /** Enum for files sections, in expected order.
  180.          * <p>The bulletin A weekly data files contain several sections,
  181.          * each introduced with some fixed header text and followed by tabular data.
  182.          * </p>
  183.          */
  184.         private enum Section {

  186.             /** Earth Orientation Parameters rapid service. */
  187.             // section 2 always contain rapid service data including error fields
  188.             //      COMBINED EARTH ORIENTATION PARAMETERS:
  189.             //
  190.             //                              IERS Rapid Service
  191.             //              MJD      x    error     y    error   UT1-UTC   error
  192.             //                       "      "       "      "        s        s
  193.             //   13  8 30  56534 0.16762 .00009 0.32705 .00009  0.038697 0.000019
  194.             //   13  8 31  56535 0.16669 .00010 0.32564 .00010  0.038471 0.000019
  195.             //   13  9  1  56536 0.16592 .00009 0.32410 .00010  0.038206 0.000024
  196.             //   13  9  2  56537 0.16557 .00009 0.32270 .00009  0.037834 0.000024
  197.             //   13  9  3  56538 0.16532 .00009 0.32147 .00010  0.037351 0.000024
  198.             //   13  9  4  56539 0.16488 .00009 0.32044 .00010  0.036756 0.000023
  199.             //   13  9  5  56540 0.16435 .00009 0.31948 .00009  0.036036 0.000024
  200.             EOP_RAPID_SERVICE("^ *COMBINED EARTH ORIENTATION PARAMETERS: *$",
  201.                               LINE_START_REGEXP +
  202.                               STORED_INTEGER_FIELD + STORED_INTEGER_FIELD + STORED_INTEGER_FIELD +
  203.                               STORED_MJD_FIELD +
  204.                               IGNORED_REAL_FIELD + IGNORED_REAL_FIELD +
  205.                               IGNORED_REAL_FIELD + IGNORED_REAL_FIELD +
  206.                               STORED_REAL_FIELD  + IGNORED_REAL_FIELD +
  207.                               LINE_END_REGEXP),

  209.            /** Earth Orientation Parameters final values. */
  210.            // the first bulletin A of each month also includes final values for the
  211.            // period covering from day 2 of month m-2 to day 1 of month m-1.
  212.            //                                IERS Final Values
  213.            //                                 MJD        x        y      UT1-UTC
  214.            //                                            "        "         s
  215.            //             13  7  2           56475    0.1441   0.3901   0.05717
  216.            //             13  7  3           56476    0.1457   0.3895   0.05716
  217.            //             13  7  4           56477    0.1467   0.3887   0.05728
  218.            //             13  7  5           56478    0.1477   0.3875   0.05755
  219.            //             13  7  6           56479    0.1490   0.3862   0.05793
  220.            //             13  7  7           56480    0.1504   0.3849   0.05832
  221.            //             13  7  8           56481    0.1516   0.3835   0.05858
  222.            //             13  7  9           56482    0.1530   0.3822   0.05877
  223.            EOP_FINAL_VALUES("^ *IERS Final Values *$",
  224.                             LINE_START_REGEXP +
  225.                             STORED_INTEGER_FIELD + STORED_INTEGER_FIELD + STORED_INTEGER_FIELD +
  226.                             STORED_MJD_FIELD +
  227.                             IGNORED_REAL_FIELD +
  228.                             IGNORED_REAL_FIELD +
  229.                             STORED_REAL_FIELD +
  230.                             LINE_END_REGEXP),

  232.            /** TAI-UTC part of the Earth Orientation Parameters prediction.. */
  233.            // section 3 always contain prediction data without error fields
  234.            //
  235.            //         PREDICTIONS:
  236.            //         The following formulas will not reproduce the predictions given below,
  237.            //         but may be used to extend the predictions beyond the end of this table.
  238.            //
  239.            //         x =  0.0969 + 0.1110 cos A - 0.0103 sin A - 0.0435 cos C - 0.0171 sin C
  240.            //         y =  0.3457 - 0.0061 cos A - 0.1001 sin A - 0.0171 cos C + 0.0435 sin C
  241.            //            UT1-UTC = -0.0052 - 0.00104 (MJD - 56548) - (UT2-UT1)
  242.            //
  243.            //         where A = 2*pi*(MJD-56540)/365.25 and C = 2*pi*(MJD-56540)/435.
  244.            //
  245.            //            TAI-UTC(MJD 56541) = 35.0
  246.            //         The accuracy may be estimated from the expressions:
  247.            //         S x,y = 0.00068 (MJD-56540)**0.80   S t = 0.00025 (MJD-56540)**0.75
  248.            //         Estimated accuracies are:  Predictions     10 d   20 d   30 d   40 d
  249.            //                                    Polar coord's  0.004  0.007  0.010  0.013
  250.            //                                    UT1-UTC        0.0014 0.0024 0.0032 0.0040
  251.            //
  252.            //                       MJD      x(arcsec)   y(arcsec)   UT1-UTC(sec)
  253.            //          2013  9  6  56541       0.1638      0.3185      0.03517
  254.            //          2013  9  7  56542       0.1633      0.3175      0.03420
  255.            //          2013  9  8  56543       0.1628      0.3164      0.03322
  256.            //          2013  9  9  56544       0.1623      0.3153      0.03229
  257.            //          2013  9 10  56545       0.1618      0.3142      0.03144
  258.            //          2013  9 11  56546       0.1612      0.3131      0.03071
  259.            //          2013  9 12  56547       0.1607      0.3119      0.03008
  260.            TAI_UTC("^ *PREDICTIONS: *$",
  261.                     LINE_START_REGEXP +
  262.                     "TAI-UTC\\(MJD *" +
  263.                     STORED_MJD_FIELD +
  264.                     "\\) *= *" +
  265.                     STORED_INTEGER_FIELD + "(?:\\.0*)?" +
  266.                     LINE_END_REGEXP),

  268.             /** Earth Orientation Parameters prediction. */
  269.             // section 3 always contain prediction data without error fields
  270.             //
  271.             //         PREDICTIONS:
  272.             //         The following formulas will not reproduce the predictions given below,
  273.             //         but may be used to extend the predictions beyond the end of this table.
  274.             //
  275.             //         x =  0.0969 + 0.1110 cos A - 0.0103 sin A - 0.0435 cos C - 0.0171 sin C
  276.             //         y =  0.3457 - 0.0061 cos A - 0.1001 sin A - 0.0171 cos C + 0.0435 sin C
  277.             //            UT1-UTC = -0.0052 - 0.00104 (MJD - 56548) - (UT2-UT1)
  278.             //
  279.             //         where A = 2*pi*(MJD-56540)/365.25 and C = 2*pi*(MJD-56540)/435.
  280.             //
  281.             //            TAI-UTC(MJD 56541) = 35.0
  282.             //         The accuracy may be estimated from the expressions:
  283.             //         S x,y = 0.00068 (MJD-56540)**0.80   S t = 0.00025 (MJD-56540)**0.75
  284.             //         Estimated accuracies are:  Predictions     10 d   20 d   30 d   40 d
  285.             //                                    Polar coord's  0.004  0.007  0.010  0.013
  286.             //                                    UT1-UTC        0.0014 0.0024 0.0032 0.0040
  287.             //
  288.             //                       MJD      x(arcsec)   y(arcsec)   UT1-UTC(sec)
  289.             //          2013  9  6  56541       0.1638      0.3185      0.03517
  290.             //          2013  9  7  56542       0.1633      0.3175      0.03420
  291.             //          2013  9  8  56543       0.1628      0.3164      0.03322
  292.             //          2013  9  9  56544       0.1623      0.3153      0.03229
  293.             //          2013  9 10  56545       0.1618      0.3142      0.03144
  294.             //          2013  9 11  56546       0.1612      0.3131      0.03071
  295.             //          2013  9 12  56547       0.1607      0.3119      0.03008
  296.             EOP_PREDICTION("^ *MJD *x\\(arcsec\\) *y\\(arcsec\\) *UT1-UTC\\(sec\\) *$",
  297.                            LINE_START_REGEXP +
  298.                            STORED_INTEGER_FIELD + STORED_INTEGER_FIELD + STORED_INTEGER_FIELD +
  299.                            STORED_MJD_FIELD +
  300.                            IGNORED_REAL_FIELD +
  301.                            IGNORED_REAL_FIELD +
  302.                            STORED_REAL_FIELD +
  303.                            LINE_END_REGEXP);

  305.             /** Header pattern. */
  306.             private final Pattern header;

  308.             /** Data pattern. */
  309.             private final Pattern data;

  311.             /** Simple constructor.
  312.              * @param headerRegExp regular expression for header
  313.              * @param dataRegExp regular expression for data
  314.              */
  315.             Section(final String headerRegExp, final String dataRegExp) {
  316.                 this.header = Pattern.compile(headerRegExp);
  317.                 this.data   = Pattern.compile(dataRegExp);
  318.             }

  320.             /** Check if a line matches the section header.
  321.              * @param l line to check
  322.              * @return true if the line matches the header
  323.              */
  324.             public boolean matchesHeader(final String l) {
  325.                 return header.matcher(l).matches();
  326.             }

  328.             /** Get the data fields from a line.
  329.              * @param l line to parse
  330.              * @return extracted fields, or null if line does not match data format
  331.              */
  332.             public String[] getFields(final String l) {
  333.                 final Matcher matcher = data.matcher(l);
  334.                 if (matcher.matches()) {
  335.                     final String[] fields = new String[matcher.groupCount()];
  336.                     for (int i = 0; i < fields.length; ++i) {
  337.                         fields[i] = matcher.group(i + 1);
  338.                     }
  339.                     return fields;
  340.                 } else {
  341.                     return null;
  342.                 }
  343.             }

  345.         }

  347.         /** TAI-UTC history. */
  348.         private final SortedMap<Integer, Integer> taiUtc;

  350.         /** UT1-UTC history. */
  351.         private final SortedMap<Integer, Double> ut1Utc;

  353.         /** Current line number. */
  354.         private int lineNumber;

  356.         /** Current line. */
  357.         private String line;

  359.         /** Simple constructor.
  360.          */
  361.         Parser() {
  362.             this.taiUtc     = new TreeMap<Integer, Integer>();
  363.             this.ut1Utc     = new TreeMap<Integer, Double>();
  364.             this.lineNumber = 0;
  365.         }

  367.         /** Get TAI-UTC history.
  368.          * @return TAI-UTC history
  369.          */
  370.         public SortedMap<Integer, Integer> getTaiUtc() {
  371.             return taiUtc;
  372.         }

  374.         /** Get UT1-UTC history.
  375.          * @return UT1-UTC history
  376.          */
  377.         public SortedMap<Integer, Double> getUt1Utc() {
  378.             return ut1Utc;
  379.         }

  381.         /** {@inheritDoc} */
  382.         @Override
  383.         public boolean stillAcceptsData() {
  384.             return true;
  385.         }

  387.         /** {@inheritDoc} */
  388.         @Override
  389.         public void loadData(final InputStream input, final String name)
  390.             throws OrekitException, IOException {

  392.             // set up a reader for line-oriented bulletin A files
  393.             final BufferedReader reader = new BufferedReader(new InputStreamReader(input, "UTF-8"));
  394.             lineNumber =  0;

  396.             // loop over sections
  397.             final List<Section> remaining = new ArrayList<Section>();
  398.             remaining.addAll(Arrays.asList(Section.values()));
  399.             for (Section section = nextSection(remaining, reader, name);
  400.                     section != null;
  401.                     section = nextSection(remaining, reader, name)) {

  403.                 if (section == Section.TAI_UTC) {
  404.                     loadTaiUtc(section, reader, name);
  405.                 } else {
  406.                     // load the values
  407.                     loadTimeSteps(section, reader, name);
  408.                 }

  410.                 // remove the already parsed section from the list
  411.                 remaining.remove(section);

  413.             }

  415.             // check that the mandatory sections have been parsed
  416.             if (remaining.contains(Section.EOP_RAPID_SERVICE) || remaining.contains(Section.EOP_PREDICTION)) {
  417.                 throw new OrekitException(OrekitMessages.NOT_A_SUPPORTED_IERS_DATA_FILE, name);
  418.             }

  420.         }

  422.         /** Skip to next section header.
  423.          * @param sections sections to check for
  424.          * @param reader reader from where file content is obtained
  425.          * @param name name of the file (or zip entry)
  426.          * @return the next section or null if no section is found until end of file
  427.          * @exception IOException if data can't be read
  428.          */
  429.         private Section nextSection(final List<Section> sections, final BufferedReader reader, final String name)
  430.             throws IOException {

  432.             for (line = reader.readLine(); line != null; line = reader.readLine()) {
  433.                 ++lineNumber;
  434.                 for (Section section : sections) {
  435.                     if (section.matchesHeader(line)) {
  436.                         return section;
  437.                     }
  438.                 }
  439.             }

  441.             // we have reached end of file and not found a matching section header
  442.             return null;

  444.         }

  446.         /** Read TAI-UTC.
  447.          * @param section section to parse
  448.          * @param reader reader from where file content is obtained
  449.          * @param name name of the file (or zip entry)
  450.          * @exception IOException if data can't be read
  451.          * @exception OrekitException if some data is missing or if some loader specific error occurs
  452.          */
  453.         private void loadTaiUtc(final Section section, final BufferedReader reader, final String name)
  454.             throws OrekitException, IOException {

  456.             for (line = reader.readLine(); line != null; line = reader.readLine()) {
  457.                 lineNumber++;
  458.                 final String[] fields = section.getFields(line);
  459.                 if (fields != null) {
  460.                     // we have found the single line we are looking for
  461.                     final int mjd    = Integer.parseInt(fields[0]);
  462.                     final int offset = Integer.parseInt(fields[1]);
  463.                     taiUtc.put(mjd, offset);
  464.                     return;
  465.                 }
  466.             }

  468.             throw new OrekitException(OrekitMessages.UNEXPECTED_END_OF_FILE_AFTER_LINE,
  469.                                       name, lineNumber);

  471.         }

  473.         /** Read UT1-UTC.
  474.          * @param section section to parse
  475.          * @param reader reader from where file content is obtained
  476.          * @param name name of the file (or zip entry)
  477.          * @exception IOException if data can't be read
  478.          * @exception OrekitException if some data is missing or if some loader specific error occurs
  479.          */
  480.         private void loadTimeSteps(final Section section, final BufferedReader reader, final String name)
  481.             throws OrekitException, IOException {

  483.             boolean inValuesPart = false;
  484.             for (line = reader.readLine(); line != null; line = reader.readLine()) {
  485.                 lineNumber++;
  486.                 final String[] fields = section.getFields(line);
  487.                 if (fields != null) {

  489.                     // we are within the values part
  490.                     inValuesPart = true;

  492.                     // this is a data line, build an entry from the extracted fields
  493.                     final int year  = Integer.parseInt(fields[0]);
  494.                     final int month = Integer.parseInt(fields[1]);
  495.                     final int day   = Integer.parseInt(fields[2]);
  496.                     final int mjd   = Integer.parseInt(fields[3]);
  497.                     final DateComponents dc = new DateComponents(DateComponents.MODIFIED_JULIAN_EPOCH, mjd);
  498.                     if ((dc.getYear() % 100) != (year % 100) ||
  499.                             dc.getMonth() != month ||
  500.                             dc.getDay() != day) {
  501.                         throw new OrekitException(OrekitMessages.INCONSISTENT_DATES_IN_IERS_FILE,
  502.                                                   name, year, month, day, mjd);
  503.                     }

  505.                     final double offset = Double.parseDouble(fields[4]);
  506.                     ut1Utc.put(mjd, offset);

  508.                 } else if (inValuesPart) {
  509.                     // we leave values part
  510.                     return;
  511.                 }
  512.             }

  514.             throw new OrekitException(OrekitMessages.UNEXPECTED_END_OF_FILE_AFTER_LINE,
  515.                                       name, lineNumber);

  517.         }

  519.     }

  521. }
Created with JaCoCo 0.7.9.201702052155