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

  29. import org.orekit.data.DataLoader;
  30. import org.orekit.data.DataProvidersManager;
  31. import org.orekit.errors.OrekitException;
  32. import org.orekit.errors.OrekitMessages;
  33. import org.orekit.time.AbsoluteDate;
  34. import org.orekit.time.DateComponents;
  35. import org.orekit.time.TimeScalesFactory;
  36. import org.orekit.utils.Constants;
  37. import org.orekit.utils.IERSConventions;

  39. /** Loader for EOP 08 C04 files.
  40.  * <p>EOP 08 C04 files contain {@link EOPEntry
  41.  * Earth Orientation Parameters} consistent with ITRF2008 for one year periods.</p>
  42.  * <p>The EOP 08 C04 files are recognized thanks to their base names, which
  43.  * must match one of the the patterns <code>eopc04_08_IAU2000.##</code> or
  44.  * <code>eopc04_08.##</code> (or the same ending with <code>.gz</code> for
  45.  * gzip-compressed files) where # stands for a digit character.</p>
  46.  * <p>Between 2002 and 2007, another series of Earth Orientation Parameters was
  47.  * in use: EOPC04 (without the 08). These parameters were consistent with the
  48.  * previous ITRS realization: ITRF2000.</p>
  49.  * <p>Between 2008 and 20011, another series of Earth Orientation Parameters was
  50.  * in use: EOP 05 C04 (instead of 08). These parameters were consistent with the
  51.  * previous ITRS realization: ITRF2005.</p>
  52.  * <p>These files are no longer provided by IERS and only the new files consistent
  53.  * with ITRF 2008 are available now (as of early 2013). The content of the older
  54.  * pre-2005 files is not the same as the content of the new files supported by this class,
  55.  * however IERS uses the same file naming convention for all of them. If a file from the older
  56.  * series is found by this class, a parse error will be triggered. Users must remove
  57.  * such files to avoid being lured in believing they do have EOP data.</p>
  58.  * <p>Files containing old data (back to 1962) have been regenerated in the new file
  59.  * format and are available at IERS web site: <a
  60.  * href="http://hpiers.obspm.fr/eoppc/eop/eopc04/">Index of /eoppc/eop/eopc04</a>.</p>
  61.  * <p>
  62.  * This class is immutable and hence thread-safe
  63.  * </p>
  64.  * @author Luc Maisonobe
  65.  */
  66. class EOP08C04FilesLoader implements EOPHistoryLoader {

  68.     /** Pattern to match the columns header. */
  69.     private static final Pattern COLUMNS_HEADER_PATTERN;

  71.     /** Pattern for data lines. */
  72.     private static final Pattern DATA_LINE_PATTERN;

  74.     /** Year field. */
  75.     private static final int YEAR_FIELD;

  77.     /** Month field. */
  78.     private static final int MONTH_FIELD;

  80.     /** Day field. */
  81.     private static final int DAY_FIELD;

  83.     /** MJD field. */
  84.     private static final int MJD_FIELD;

  86.     /** X component of pole motion field. */
  87.     private static final int POLE_X_FIELD;

  89.     /** Y component of pole motion field. */
  90.     private static final int POLE_Y_FIELD;

  92.     /** UT1-UTC field. */
  93.     private static final int UT1_UTC_FIELD;

  95.     /** LoD field. */
  96.     private static final int LOD_FIELD;

  98.     /** Correction for nutation first field (either dX or dPsi). */
  99.     private static final int NUT_0_FIELD;

  101.     /** Correction for nutation second field (either dY or dEps). */
  102.     private static final int NUT_1_FIELD;

  104.     static {
  105.         // Header have either the following form:
  106.         //       Date      MJD      x          y        UT1-UTC       LOD         dPsi      dEps       x Err     y Err   UT1-UTC Err  LOD Err    dPsi Err   dEpsilon Err
  107.         //                          "          "           s           s            "         "        "          "          s           s            "         "
  108.         //      (0h UTC)
  109.         // or the following form:
  110.         //       Date      MJD      x          y        UT1-UTC       LOD         dX        dY        x Err     y Err   UT1-UTC Err  LOD Err     dX Err       dY Err
  111.         //                          "          "           s           s          "         "           "          "          s         s            "           "
  112.         //      (0h UTC)
  113.         //
  114.         COLUMNS_HEADER_PATTERN = Pattern.compile("^ *Date +MJD +x +y +UT1-UTC +LOD +((?:dPsi +dEps)|(?:dX +dY)) .*");

  116.         // The data lines in the EOP 08 C04 yearly data files have the following fixed form:
  117.         // year month day MJD ...12 floating values fields in decimal format...
  118.         // 2000   1   1  51544   0.043242   0.377915   0.3554777   ...
  119.         // 2000   1   2  51545   0.043515   0.377753   0.3546065   ...
  120.         // 2000   1   3  51546   0.043623   0.377452   0.3538444   ...
  121.         // the corresponding fortran format is:
  122.         // 3(I4),I7,2(F11.6),2(F12.7),2(F12.6),2(F11.6),2(F12.7),2F12.6
  123.         DATA_LINE_PATTERN = Pattern.compile("^\\d+ +\\d+ +\\d+ +\\d+(?: +-?\\d+\\.\\d+){12}$");

  125.         YEAR_FIELD    = 0;
  126.         MONTH_FIELD   = 1;
  127.         DAY_FIELD     = 2;
  128.         MJD_FIELD     = 3;
  129.         POLE_X_FIELD  = 4;
  130.         POLE_Y_FIELD  = 5;
  131.         UT1_UTC_FIELD = 6;
  132.         LOD_FIELD     = 7;
  133.         NUT_0_FIELD   = 8;
  134.         NUT_1_FIELD   = 9;

  136.     }

  138.     /** Regular expression for supported files names. */
  139.     private final String supportedNames;

  141.     /** Build a loader for IERS EOP 08 C04 files.
  142.      * @param supportedNames regular expression for supported files names
  143.      */
  144.     public EOP08C04FilesLoader(final String supportedNames) {
  145.         this.supportedNames = supportedNames;
  146.     }

  148.     /** {@inheritDoc} */
  149.     public void fillHistory(final IERSConventions.NutationCorrectionConverter converter,
  150.                             final SortedSet<EOPEntry> history)
  151.         throws OrekitException {
  152.         final Parser parser = new Parser(converter);
  153.         DataProvidersManager.getInstance().feed(supportedNames, parser);
  154.         history.addAll(parser.history);
  155.     }

  157.     /** Internal class performing the parsing. */
  158.     private static class Parser implements DataLoader {

  160.         /** Converter for nutation corrections. */
  161.         private final IERSConventions.NutationCorrectionConverter converter;

  163.         /** History entries. */
  164.         private final List<EOPEntry> history;

  166.         /** Current line number. */
  167.         private int lineNumber;

  169.         /** Current line. */
  170.         private String line;

  172.         /** Indicator for header parsing. */
  173.         private boolean inHeader;

  175.         /** Indicator for Non-Rotating Origin. */
  176.         private boolean isNonRotatingOrigin;

  178.         /** Simple constructor.
  179.          * @param converter converter to use
  180.          */
  181.         public Parser(final IERSConventions.NutationCorrectionConverter converter) {
  182.             this.converter           = converter;
  183.             this.history             = new ArrayList<EOPEntry>();
  184.             this.lineNumber          = 0;
  185.             this.inHeader            = true;
  186.             this.isNonRotatingOrigin = false;
  187.         }

  189.         /** {@inheritDoc} */
  190.         public boolean stillAcceptsData() {
  191.             return true;
  192.         }

  194.         /** {@inheritDoc} */
  195.         public void loadData(final InputStream input, final String name)
  196.             throws IOException, OrekitException {

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

  201.             // reset parse info to start new file (do not clear history!)
  202.             lineNumber          = 0;
  203.             inHeader            = true;
  204.             isNonRotatingOrigin = false;

  206.             // read all file
  207.             for (line = reader.readLine(); line != null; line = reader.readLine()) {
  208.                 ++lineNumber;
  209.                 boolean parsed = false;

  211.                 if (inHeader) {
  212.                     final Matcher matcher = COLUMNS_HEADER_PATTERN.matcher(line);
  213.                     if (matcher.matches()) {
  214.                         if (matcher.group(1).startsWith("dX")) {
  215.                             isNonRotatingOrigin = true;
  216.                         }
  217.                     }
  218.                 }

  220.                 if (DATA_LINE_PATTERN.matcher(line).matches()) {
  221.                     inHeader = false;
  222.                     // this is a data line, build an entry from the extracted fields
  223.                     final String[] fields = line.split(" +");
  224.                     final DateComponents dc = new DateComponents(Integer.parseInt(fields[YEAR_FIELD]),
  225.                                                                  Integer.parseInt(fields[MONTH_FIELD]),
  226.                                                                  Integer.parseInt(fields[DAY_FIELD]));
  227.                     final int    mjd   = Integer.parseInt(fields[MJD_FIELD]);
  228.                     if (dc.getMJD() != mjd) {
  229.                         throw new OrekitException(OrekitMessages.INCONSISTENT_DATES_IN_IERS_FILE,
  230.                                                   name, dc.getYear(), dc.getMonth(), dc.getDay(), mjd);
  231.                     }
  232.                     final AbsoluteDate date = new AbsoluteDate(dc, TimeScalesFactory.getUTC());

  234.                     // the first six fields are consistent with the expected format
  235.                     final double x     = Double.parseDouble(fields[POLE_X_FIELD]) * Constants.ARC_SECONDS_TO_RADIANS;
  236.                     final double y     = Double.parseDouble(fields[POLE_Y_FIELD]) * Constants.ARC_SECONDS_TO_RADIANS;
  237.                     final double dtu1  = Double.parseDouble(fields[UT1_UTC_FIELD]);
  238.                     final double lod   = Double.parseDouble(fields[LOD_FIELD]);
  239.                     final double[] equinox;
  240.                     final double[] nro;
  241.                     if (isNonRotatingOrigin) {
  242.                         nro = new double[] {
  243.                             Double.parseDouble(fields[NUT_0_FIELD]) * Constants.ARC_SECONDS_TO_RADIANS,
  244.                             Double.parseDouble(fields[NUT_1_FIELD]) * Constants.ARC_SECONDS_TO_RADIANS
  245.                         };
  246.                         equinox = converter.toEquinox(date, nro[0], nro[1]);
  247.                     } else {
  248.                         equinox = new double[] {
  249.                             Double.parseDouble(fields[NUT_0_FIELD]) * Constants.ARC_SECONDS_TO_RADIANS,
  250.                             Double.parseDouble(fields[NUT_1_FIELD]) * Constants.ARC_SECONDS_TO_RADIANS
  251.                         };
  252.                         nro = converter.toNonRotating(date, equinox[0], equinox[1]);
  253.                     }
  254.                     history.add(new EOPEntry(mjd, dtu1, lod, x, y, equinox[0], equinox[1], nro[0], nro[1]));
  255.                     parsed = true;

  257.                 }
  258.                 if (!(inHeader || parsed)) {
  259.                     throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  260.                                               lineNumber, name, line);
  261.                 }
  262.             }

  264.             // check if we have read something
  265.             if (inHeader) {
  266.                 throw new OrekitException(OrekitMessages.NOT_A_SUPPORTED_IERS_DATA_FILE, name);
  267.             }

  269.         }

  271.     }

  273. }
Created with JaCoCo 0.6.3.201306030806