BulletinBFilesLoader.java

  1. /* Copyright 2002-2013 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.frames;

  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.HashMap;
  25. import java.util.List;
  26. import java.util.Map;
  27. import java.util.SortedSet;
  28. import java.util.regex.Matcher;
  29. import java.util.regex.Pattern;

  31. import org.apache.commons.math3.util.FastMath;
  32. import org.orekit.data.DataLoader;
  33. import org.orekit.data.DataProvidersManager;
  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.Month;
  39. import org.orekit.time.TimeScalesFactory;
  40. import org.orekit.utils.Constants;
  41. import org.orekit.utils.IERSConventions;

  43. /** Loader for bulletin B files.
  44.  * <p>Bulletin B files contain {@link EOPEntry
  45.  * Earth Orientation Parameters} for a few months periods.</p>
  46.  * <p>The bulletin B files are recognized thanks to their base names,
  47.  * which must match one of the the patterns <code>bulletinb_IAU2000-###.txt</code>,
  48.  * <code>bulletinb_IAU2000.###</code>, <code>bulletinb-###.txt</code> or
  49.  * <code>bulletinb.###</code> (or the same ending with <code>.gz</code>
  50.  * for gzip-compressed files) where # stands for a digit character.</p>
  51.  * <p>
  52.  * Starting with bulletin B 252 published in February 2009, buletins B are
  53.  * written in a format containing nutation corrections for both the
  54.  * new IAU2000 nutation model as dx, dy entries in its section 1 and nutation
  55.  * corrections for the old IAU1976 nutation model as dPsi, dEpsilon entries in
  56.  * its sections 2. These buletins are available from IERS main site <a
  57.  * href="http://www.iers.org/IERS/EN/DataProducts/EarthOrientationData/eop.html">
  58.  * Earth Orientation Parameters</a> section. They are also available with exactly the same content
  59.  * (but a different naming convention) from <a
  60.  * href="http://hpiers.obspm.fr/eoppc/bul/bulb_new/">Paris-Meudon
  61.  * observatory site</a>.
  62.  * </p>
  63.  * <p>
  64.  * Ending with bulletin B 263 published in January 2010, bulletins B were
  65.  * written in a format containing only one type of nutation corrections in its
  66.  * section 1, either for new IAU2000 nutation model as dx, dy entries or the old
  67.  * IAU1976 nutation model as dPsi, dEpsilon entries, depending on the file (a pair of
  68.  * files with different name was published each month between March 2003 and January 2010).
  69.  * </p>
  70.  * <p>
  71.  * This class handles both the old and the new format.
  72.  * </p>
  73.  * <p>
  74.  * This class is immutable and hence thread-safe
  75.  * </p>
  76.  * @author Luc Maisonobe
  77.  */
  78. class BulletinBFilesLoader implements EOPHistoryLoader {

  80.     /** Conversion factor. */
  81.     private static final double MILLI_ARC_SECONDS_TO_RADIANS = Constants.ARC_SECONDS_TO_RADIANS / 1000;

  83.     /** Conversion factor. */
  84.     private static final double MILLI_SECONDS_TO_SECONDS = 1.e-3;

  86.     /** Section 1 header pattern. */
  87.     private static final Pattern SECTION_1_HEADER;

  89.     /** Section 2 header pattern for old format. */
  90.     private static final Pattern SECTION_2_HEADER_OLD;

  92.     /** Section 3 header pattern. */
  93.     private static final Pattern SECTION_3_HEADER;

  95.     /** Pattern for line introducing the final bulletin B values. */
  96.     private static final Pattern FINAL_VALUES_START;

  98.     /** Pattern for line introducing the bulletin B preliminary extension. */
  99.     private static final Pattern FINAL_VALUES_END;

  101.     /** Data line pattern in section 1 (old format). */
  102.     private static final Pattern SECTION_1_DATA_OLD_FORMAT;

  104.     /** Data line pattern in section 2. */
  105.     private static final Pattern SECTION_2_DATA_OLD_FORMAT;

  107.     /** Data line pattern in section 1 (new format). */
  108.     private static final Pattern SECTION_1_DATA_NEW_FORMAT;

  110.     /** Data line pattern in section 3 (new format). */
  111.     private static final Pattern SECTION_3_DATA_NEW_FORMAT;

  113.     static {

  115.         // the section headers lines in the old bulletin B monthly data files have
  116.         // the following form (the indentation discrepancy for section 6 is really
  117.         // present in the available files):
  118.         // 1 - EARTH ORIENTATION PARAMETERS (IERS evaluation).
  119.         // either
  120.         // 2 - SMOOTHED VALUES OF x, y, UT1, D, DPSI, DEPSILON (IERS EVALUATION)
  121.         // or
  122.         // 2 - SMOOTHED VALUES OF x, y, UT1, D, dX, dY (IERS EVALUATION)
  123.         // 3 - NORMAL VALUES OF THE EARTH ORIENTATION PARAMETERS AT FIVE-DAY INTERVALS
  124.         // 4 - DURATION OF THE DAY AND ANGULAR VELOCITY OF THE EARTH (IERS evaluation).
  125.         // 5 - INFORMATION ON TIME SCALES
  126.         //       6 - SUMMARY OF CONTRIBUTED EARTH ORIENTATION PARAMETERS SERIES
  127.         //
  128.         // the section headers lines in the new bulletin B monthly data files have
  129.         // the following form:
  130.         // 1 - DAILY FINAL VALUES OF  x, y, UT1-UTC, dX, dY
  131.         // 2 - DAILY FINAL VALUES OF CELESTIAL POLE OFFSETS dPsi1980 & dEps1980
  132.         // 3 - EARTH ANGULAR VELOCITY : DAILY FINAL VALUES OF LOD, OMEGA AT 0hUTC
  133.         // 4 - INFORMATION ON TIME SCALES
  134.         // 5 - SUMMARY OF CONTRIBUTED EARTH ORIENTATION PARAMETERS SERIES
  135.         SECTION_1_HEADER     = Pattern.compile("^ +1 - (\\p{Upper}+) \\p{Upper}+ \\p{Upper}+.*");
  136.         SECTION_2_HEADER_OLD = Pattern.compile("^ +2 - SMOOTHED \\p{Upper}+ \\p{Upper}+.*((?:DPSI, DEPSILON)|(?:dX, dY)).*");
  137.         SECTION_3_HEADER     = Pattern.compile("^ +3 - \\p{Upper}+ \\p{Upper}+ \\p{Upper}+.*");

  139.         // the markers bracketing the final values in section 1 in the old bulletin B
  140.         // monthly data files have the following form:
  141.         //
  142.         //  Final Bulletin B values.
  143.         //   ...
  144.         //  Preliminary extension, to be updated weekly in Bulletin A and monthly
  145.         //  in Bulletin B.
  146.         //
  147.         // the markers bracketing the final values in section 1 in the new bulletin B
  148.         // monthly data files have the following form:
  149.         //
  150.         //  Final values
  151.         //   ...
  152.         //  Preliminary extension
  153.         //
  154.         FINAL_VALUES_START = Pattern.compile("^\\p{Blank}+Final( Bulletin B)? values.*");
  155.         FINAL_VALUES_END   = Pattern.compile("^\\p{Blank}+Preliminary extension.*");

  157.         // the data lines in the old bulletin B monthly data files have the following form:
  158.         // in section 1:
  159.         // AUG   1  55044  0.22176 0.49302  0.231416  -33.768584   -69.1    -8.9
  160.         // AUG   6  55049  0.23202 0.48003  0.230263  -33.769737   -69.5    -8.5
  161.         // in section 2:
  162.         // AUG   1   55044  0.22176  0.49302  0.230581 -0.835  -0.310  -69.1   -8.9
  163.         // AUG   2   55045  0.22395  0.49041  0.230928 -0.296  -0.328  -69.5   -8.9
  164.         //
  165.         // the data lines in the new bulletin B monthly data files have the following form:
  166.         // in section 1:
  167.         // 2009   8   2   55045  223.954  490.410  230.9277    0.214 -0.056    0.008    0.009    0.0641  0.048  0.121
  168.         // 2009   8   3   55046  225.925  487.700  231.2186    0.300 -0.138    0.010    0.012    0.0466  0.099  0.248
  169.         // 2009   8   4   55047  227.931  485.078  231.3929    0.347 -0.231    0.019    0.023    0.0360  0.099  0.249
  170.         // 2009   8   5   55048  230.016  482.445  231.4601    0.321 -0.291    0.025    0.028    0.0441  0.095  0.240
  171.         // 2009   8   6   55049  232.017  480.026  231.3619    0.267 -0.273    0.025    0.029    0.0477  0.038  0.095
  172.         // in section 2:
  173.         // 2009   8   2   55045   -69.474    -8.929     0.199     0.121
  174.         // 2009   8   3   55046   -69.459    -9.016     0.250     0.248
  175.         // 2009   8   4   55047   -69.401    -9.039     0.250     0.249
  176.         // 2009   8   5   55048   -69.425    -8.864     0.247     0.240
  177.         // 2009   8   6   55049   -69.510    -8.539     0.153     0.095
  178.         // in section 3:
  179.         // 2009   8   2   55045 -0.3284  0.0013  15.04106723584    0.00000000023
  180.         // 2009   8   3   55046 -0.2438  0.0013  15.04106722111    0.00000000023
  181.         // 2009   8   4   55047 -0.1233  0.0013  15.04106720014    0.00000000023
  182.         // 2009   8   5   55048  0.0119  0.0013  15.04106717660    0.00000000023
  183.         // 2009   8   6   55049  0.1914  0.0013  15.04106714535    0.00000000023
  184.         final StringBuilder builder = new StringBuilder("^\\p{Blank}+(?:");
  185.         for (final Month month : Month.values()) {
  186.             builder.append(month.getUpperCaseAbbreviation());
  187.             builder.append('|');
  188.         }
  189.         builder.delete(builder.length() - 1, builder.length());
  190.         builder.append(")");
  191.         final String monthNameField      = builder.toString();
  192.         final String ignoredIntegerField = "\\p{Blank}*(?:\\p{Digit})+";
  193.         final String storedIntegerField  = "\\p{Blank}*(\\p{Digit}+)";
  194.         final String mjdField            = "\\p{Blank}+(\\p{Digit}\\p{Digit}\\p{Digit}\\p{Digit}\\p{Digit})";
  195.         final String storedRealField     = "\\p{Blank}+(-?\\p{Digit}+\\.(?:\\p{Digit})+)";
  196.         final String ignoredRealField    = "\\p{Blank}+-?\\p{Digit}+\\.(?:\\p{Digit})+";
  197.         final String finalBlanks         = "\\p{Blank}*$";
  198.         SECTION_1_DATA_OLD_FORMAT = Pattern.compile(monthNameField + ignoredIntegerField + mjdField +
  199.                                                     ignoredRealField + ignoredRealField + ignoredRealField +
  200.                                                     ignoredRealField + ignoredRealField + ignoredRealField +
  201.                                                     finalBlanks);
  202.         SECTION_2_DATA_OLD_FORMAT = Pattern.compile(monthNameField + ignoredIntegerField + mjdField +
  203.                                                     storedRealField  + storedRealField  + storedRealField +
  204.                                                     ignoredRealField +
  205.                                                     storedRealField + storedRealField + storedRealField +
  206.                                                     finalBlanks);
  207.         SECTION_1_DATA_NEW_FORMAT = Pattern.compile(storedIntegerField + storedIntegerField + storedIntegerField + mjdField +
  208.                                                     storedRealField + storedRealField + storedRealField +
  209.                                                     storedRealField + storedRealField + ignoredRealField + ignoredRealField +
  210.                                                     ignoredRealField + ignoredRealField + ignoredRealField +
  211.                                                     finalBlanks);
  212.         SECTION_3_DATA_NEW_FORMAT = Pattern.compile(ignoredIntegerField + ignoredIntegerField + ignoredIntegerField + mjdField +
  213.                                                     storedRealField +
  214.                                                     ignoredRealField + ignoredRealField + ignoredRealField +
  215.                                                     finalBlanks);

  217.     }

  219.     /** Regular expression for supported files names. */
  220.     private final String supportedNames;

  222.     /** Build a loader for IERS bulletins B files.
  223.     * @param supportedNames regular expression for supported files names
  224.     */
  225.     public BulletinBFilesLoader(final String supportedNames) {
  226.         this.supportedNames = supportedNames;
  227.     }

  229.     /** {@inheritDoc} */
  230.     public void fillHistory(final IERSConventions.NutationCorrectionConverter converter,
  231.                             final SortedSet<EOPEntry> history)
  232.         throws OrekitException {
  233.         final Parser parser = new Parser(converter);
  234.         DataProvidersManager.getInstance().feed(supportedNames, parser);
  235.         history.addAll(parser.history);
  236.     }

  238.     /** Internal class performing the parsing. */
  239.     private static class Parser implements DataLoader {

  241.         /** Converter for nutation corrections. */
  242.         private final IERSConventions.NutationCorrectionConverter converter;

  244.         /** History entries. */
  245.         private final List<EOPEntry> history;

  247.         /** Map for fields read in different sections. */
  248.         private final Map<Integer, double[]> fieldsMap;

  250.         /** Current line number. */
  251.         private int lineNumber;

  253.         /** Current line. */
  254.         private String line;

  256.         /** Start of final data. */
  257.         private int mjdMin;

  259.         /** End of final data. */
  260.         private int mjdMax;

  262.         /** Simple constructor.
  263.          * @param converter converter to use
  264.          */
  265.         public Parser(final IERSConventions.NutationCorrectionConverter converter) {
  266.             this.converter  = converter;
  267.             this.history    = new ArrayList<EOPEntry>();
  268.             this.fieldsMap  = new HashMap<Integer, double[]>();
  269.             this.lineNumber = 0;
  270.             this.mjdMin     = Integer.MAX_VALUE;
  271.             this.mjdMax     = Integer.MIN_VALUE;
  272.         }

  274.         /** {@inheritDoc} */
  275.         public boolean stillAcceptsData() {
  276.             return true;
  277.         }

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

  283.             // set up a reader for line-oriented bulletin B files
  284.             final BufferedReader reader = new BufferedReader(new InputStreamReader(input, "UTF-8"));

  286.             // reset parse info to start new file (do not clear history!)
  287.             fieldsMap.clear();
  288.             lineNumber = 0;
  289.             mjdMin     = Integer.MAX_VALUE;
  290.             mjdMax     = Integer.MIN_VALUE;

  292.             // skip header up to section 1 and check if we are parsing an old or new format file
  293.             final Matcher section1Matcher = seekToLine(SECTION_1_HEADER, reader, name);
  294.             final boolean isOldFormat = "EARTH".equals(section1Matcher.group(1));

  296.             if (isOldFormat) {

  298.                 // extract MJD bounds for final data from section 1
  299.                 loadMJDBoundsOldFormat(reader, name);

  301.                 final Matcher section2Matcher = seekToLine(SECTION_2_HEADER_OLD, reader, name);
  302.                 final boolean isNonRotatingOrigin = section2Matcher.group(1).startsWith("dX");
  303.                 loadEOPOldFormat(isNonRotatingOrigin, reader, name);

  305.             } else {

  307.                 // extract x, y, UT1-UTC, dx, dy from section 1
  308.                 loadXYDTDxDyNewFormat(reader, name);

  310.                 // skip to section 3
  311.                 seekToLine(SECTION_3_HEADER, reader, name);

  313.                 // extract LOD data from section 3
  314.                 loadLODNewFormat(reader, name);

  316.                 // set up the EOP entries
  317.                 for (Map.Entry<Integer, double[]> entry : fieldsMap.entrySet()) {
  318.                     final int mjd = entry.getKey();
  319.                     final double[] array = entry.getValue();
  320.                     if (Double.isNaN(array[0]) || Double.isNaN(array[1]) ||
  321.                             Double.isNaN(array[2]) || Double.isNaN(array[3]) ||
  322.                             Double.isNaN(array[4]) || Double.isNaN(array[5])) {
  323.                         throw notifyUnexpectedErrorEncountered(name);
  324.                     }
  325.                     final AbsoluteDate mjdDate =
  326.                             new AbsoluteDate(new DateComponents(DateComponents.MODIFIED_JULIAN_EPOCH, mjd),
  327.                                              TimeScalesFactory.getUTC());
  328.                     final double[] equinox = converter.toEquinox(mjdDate, array[4], array[5]);
  329.                     history.add(new EOPEntry(mjd, array[0], array[1], array[2], array[3],
  330.                                              equinox[0], equinox[1], array[4], array[5]));
  331.                 }

  333.             }

  335.         }

  337.         /** Read until a line matching a pattern is found.
  338.          * @param pattern pattern to look for
  339.          * @param reader reader from where file content is obtained
  340.          * @param name name of the file (or zip entry)
  341.          * @return the matching matcher for the line
  342.          * @exception IOException if data can't be read
  343.          * @exception OrekitException if end of file is reached before line has been found
  344.          */
  345.         private Matcher seekToLine(final Pattern pattern, final BufferedReader reader, final String name)
  346.             throws IOException, OrekitException {

  348.             for (line = reader.readLine(); line != null; line = reader.readLine()) {
  349.                 ++lineNumber;
  350.                 final Matcher matcher = pattern.matcher(line);
  351.                 if (matcher.matches()) {
  352.                     return matcher;
  353.                 }
  354.             }

  356.             // we have reached end of file and not found a matching line
  357.             throw new OrekitException(OrekitMessages.UNEXPECTED_END_OF_FILE_AFTER_LINE,
  358.                                       name, lineNumber);

  360.         }

  362.         /** Read MJD bounds of the final data part from section 1 in the old bulletin B format.
  363.          * @param reader reader from where file content is obtained
  364.          * @param name name of the file (or zip entry)
  365.          * @exception IOException if data can't be read
  366.          * @exception OrekitException if some data is missing or if some loader specific error occurs
  367.          */
  368.         private void loadMJDBoundsOldFormat(final BufferedReader reader, final String name)
  369.             throws OrekitException, IOException {

  371.             boolean inFinalValuesPart = false;
  372.             for (line = reader.readLine(); line != null; line = reader.readLine()) {
  373.                 lineNumber++;
  374.                 Matcher matcher = FINAL_VALUES_START.matcher(line);
  375.                 if (matcher.matches()) {
  376.                     // we are entering final values part (in section 1)
  377.                     inFinalValuesPart = true;
  378.                 } else if (inFinalValuesPart) {
  379.                     matcher = SECTION_1_DATA_OLD_FORMAT.matcher(line);
  380.                     if (matcher.matches()) {
  381.                         // this is a data line, build an entry from the extracted fields
  382.                         final int mjd = Integer.parseInt(matcher.group(1));
  383.                         mjdMin = FastMath.min(mjdMin, mjd);
  384.                         mjdMax = FastMath.max(mjdMax, mjd);
  385.                     } else {
  386.                         matcher = FINAL_VALUES_END.matcher(line);
  387.                         if (matcher.matches()) {
  388.                             // we leave final values part
  389.                             return;
  390.                         }
  391.                     }
  392.                 }
  393.             }

  395.             throw new OrekitException(OrekitMessages.UNEXPECTED_END_OF_FILE_AFTER_LINE,
  396.                                       name, lineNumber);

  398.         }

  400.         /** Read EOP data from section 2 in the old bulletin B format.
  401.          * @param isNonRotatingOrigin if true, the file contain Non-Rotating Origin nutation corrections
  402.          * @param reader reader from where file content is obtained
  403.          * @param name name of the file (or zip entry)
  404.          * @exception IOException if data can't be read
  405.          * @exception OrekitException if some data is missing or if some loader specific error occurs
  406.          */
  407.         private void loadEOPOldFormat(final boolean isNonRotatingOrigin,
  408.                                       final BufferedReader reader, final String name)
  409.             throws OrekitException, IOException {

  411.             // read the data lines in the final values part inside section 2
  412.             for (line = reader.readLine(); line != null; line = reader.readLine()) {
  413.                 lineNumber++;
  414.                 final Matcher matcher = SECTION_2_DATA_OLD_FORMAT.matcher(line);
  415.                 if (matcher.matches()) {
  416.                     // this is a data line, build an entry from the extracted fields
  417.                     final int    mjd   = Integer.parseInt(matcher.group(1));
  418.                     final double x     = Double.parseDouble(matcher.group(2)) * Constants.ARC_SECONDS_TO_RADIANS;
  419.                     final double y     = Double.parseDouble(matcher.group(3)) * Constants.ARC_SECONDS_TO_RADIANS;
  420.                     final double dtu1  = Double.parseDouble(matcher.group(4));
  421.                     final double lod   = Double.parseDouble(matcher.group(5)) * MILLI_SECONDS_TO_SECONDS;
  422.                     if (mjd >= mjdMin) {
  423.                         final AbsoluteDate mjdDate =
  424.                                 new AbsoluteDate(new DateComponents(DateComponents.MODIFIED_JULIAN_EPOCH, mjd),
  425.                                                  TimeScalesFactory.getUTC());
  426.                         final double[] equinox;
  427.                         final double[] nro;
  428.                         if (isNonRotatingOrigin) {
  429.                             nro = new double[] {
  430.                                 Double.parseDouble(matcher.group(6)) * MILLI_ARC_SECONDS_TO_RADIANS,
  431.                                 Double.parseDouble(matcher.group(7)) * MILLI_ARC_SECONDS_TO_RADIANS
  432.                             };
  433.                             equinox = converter.toEquinox(mjdDate, nro[0], nro[1]);
  434.                         } else {
  435.                             equinox = new double[] {
  436.                                 Double.parseDouble(matcher.group(6)) * MILLI_ARC_SECONDS_TO_RADIANS,
  437.                                 Double.parseDouble(matcher.group(7)) * MILLI_ARC_SECONDS_TO_RADIANS
  438.                             };
  439.                             nro = converter.toNonRotating(mjdDate, equinox[0], equinox[1]);
  440.                         }
  441.                         history.add(new EOPEntry(mjd, dtu1, lod, x, y, equinox[0], equinox[1], nro[0], nro[1]));
  442.                         if (mjd >= mjdMax) {
  443.                             // don't bother reading the rest of the file
  444.                             return;
  445.                         }
  446.                     }
  447.                 }
  448.             }

  450.         }

  452.         /** Read X, Y, UT1-UTC, dx, dy from section 1 in the new bulletin B format.
  453.          * @param reader reader from where file content is obtained
  454.          * @param name name of the file (or zip entry)
  455.          * @exception IOException if data can't be read
  456.          * @exception OrekitException if some data is missing or if some loader specific error occurs
  457.          */
  458.         private void loadXYDTDxDyNewFormat(final BufferedReader reader, final String name)
  459.             throws OrekitException, IOException {

  461.             boolean inFinalValuesPart = false;
  462.             for (line = reader.readLine(); line != null; line = reader.readLine()) {
  463.                 lineNumber++;
  464.                 Matcher matcher = FINAL_VALUES_START.matcher(line);
  465.                 if (matcher.matches()) {
  466.                     // we are entering final values part (in section 1)
  467.                     inFinalValuesPart = true;
  468.                 } else if (inFinalValuesPart) {
  469.                     matcher = SECTION_1_DATA_NEW_FORMAT.matcher(line);
  470.                     if (matcher.matches()) {
  471.                         // this is a data line, build an entry from the extracted fields
  472.                         final int year  = Integer.parseInt(matcher.group(1));
  473.                         final int month = Integer.parseInt(matcher.group(2));
  474.                         final int day   = Integer.parseInt(matcher.group(3));
  475.                         final int mjd   = Integer.parseInt(matcher.group(4));
  476.                         if (new DateComponents(year, month, day).getMJD() != mjd) {
  477.                             throw new OrekitException(OrekitMessages.INCONSISTENT_DATES_IN_IERS_FILE,
  478.                                                       name, year, month, day, mjd);
  479.                         }
  480.                         mjdMin = FastMath.min(mjdMin, mjd);
  481.                         mjdMax = FastMath.max(mjdMax, mjd);
  482.                         final double x    = Double.parseDouble(matcher.group(5)) * MILLI_ARC_SECONDS_TO_RADIANS;
  483.                         final double y    = Double.parseDouble(matcher.group(6)) * MILLI_ARC_SECONDS_TO_RADIANS;
  484.                         final double dtu1 = Double.parseDouble(matcher.group(7)) * MILLI_SECONDS_TO_SECONDS;
  485.                         final double dx   = Double.parseDouble(matcher.group(8)) * MILLI_ARC_SECONDS_TO_RADIANS;
  486.                         final double dy   = Double.parseDouble(matcher.group(9)) * MILLI_ARC_SECONDS_TO_RADIANS;
  487.                         fieldsMap.put(mjd,
  488.                                       new double[] {
  489.                                           dtu1, Double.NaN, x, y, dx, dy
  490.                                       });
  491.                     } else {
  492.                         matcher = FINAL_VALUES_END.matcher(line);
  493.                         if (matcher.matches()) {
  494.                             // we leave final values part
  495.                             return;
  496.                         }
  497.                     }
  498.                 }
  499.             }
  500.         }

  502.         /** Read LOD from section 3 in the new bulletin B format.
  503.          * @param reader reader from where file content is obtained
  504.          * @param name name of the file (or zip entry)
  505.          * @exception IOException if data can't be read
  506.          * @exception OrekitException if some data is missing or if some loader specific error occurs
  507.          */
  508.         private void loadLODNewFormat(final BufferedReader reader, final String name)
  509.             throws OrekitException, IOException {
  510.             for (line = reader.readLine(); line != null; line = reader.readLine()) {
  511.                 lineNumber++;
  512.                 final Matcher matcher = SECTION_3_DATA_NEW_FORMAT.matcher(line);
  513.                 if (matcher.matches()) {
  514.                     // this is a data line, build an entry from the extracted fields
  515.                     final int    mjd = Integer.parseInt(matcher.group(1));
  516.                     if (mjd >= mjdMin) {
  517.                         final double lod = Double.parseDouble(matcher.group(2)) * MILLI_SECONDS_TO_SECONDS;
  518.                         final double[] array = fieldsMap.get(mjd);
  519.                         if (array == null) {
  520.                             throw notifyUnexpectedErrorEncountered(name);
  521.                         }
  522.                         array[1] = lod;
  523.                         if (mjd >= mjdMax) {
  524.                             // don't bother reading the rest of the file
  525.                             return;
  526.                         }
  527.                     }
  528.                 }
  529.             }
  530.         }

  532.         /** Create an exception to be thrown.
  533.          * @param name name of the file (or zip entry)
  534.          * @return OrekitException always thrown to notify an unexpected error has been
  535.          * encountered by the caller
  536.          */
  537.         private OrekitException notifyUnexpectedErrorEncountered(final String name) {
  538.             String loaderName = BulletinBFilesLoader.class.getName();
  539.             loaderName = loaderName.substring(loaderName.lastIndexOf('.') + 1);
  540.             return new OrekitException(OrekitMessages.UNEXPECTED_FILE_FORMAT_ERROR_FOR_LOADER,
  541.                                        name, loaderName);
  542.         }

  544.     }

  546. }
Created with JaCoCo 0.6.3.201306030806