RapidDataAndPredictionColumnsLoader.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.IERSConventions;

  38. /** Loader for IERS rapid data and prediction files in columns format (finals file).
  39.  * <p>Rapid data and prediction files contain {@link EOPEntry
  40.  * Earth Orientation Parameters} for several years periods, in one file
  41.  * only that is updated regularly.</p>
  42.  * <p>
  43.  * These files contain both the data from IERS Bulletin A and IERS bulletin B.
  44.  * This class parses only the part from Bulletin A.
  45.  * </p>
  46.  * <p>The rapid data and prediction file is recognized thanks to its base name,
  47.  * which must match one of the the patterns <code>finals.*</code> or
  48.  * <code>finals2000A.*</code> (or the same ending with <code>.gz</code>
  49.  * for gzip-compressed files) where * stands for a word like "all", "daily",
  50.  * or "data". The file with 2000A in their name correspond to the
  51.  * IAU-2000 precession-nutation model whereas the files without any identifier
  52.  * correspond to the IAU-1980 precession-nutation model. The files with the all
  53.  * suffix start from 1973-01-01, the file with the data suffix start
  54.  * from 1992-01-01 and the files with the daily suffix.</p>
  55.  * <p>
  56.  * This class is immutable and hence thread-safe
  57.  * </p>
  58.  * @author Romain Di Costanzo
  59.  * @see <a href="http://maia.usno.navy.mil/ser7/readme.finals2000A">finals2000A file format description at USNO</a>
  60.  * @see <a href="http://maia.usno.navy.mil/ser7/readme.finals">finals file format description at USNO</a>
  61.  */
  62. class RapidDataAndPredictionColumnsLoader implements EOPHistoryLoader {

  64.     /** Conversion factor. */
  65.     private static final double  ARC_SECONDS_TO_RADIANS       = 2 * Math.PI / 1296000;

  67.     /** Conversion factor. */
  68.     private static final double  MILLI_ARC_SECONDS_TO_RADIANS = ARC_SECONDS_TO_RADIANS / 1000;

  70.     /** Conversion factor. */
  71.     private static final double  MILLI_SECONDS_TO_SECONDS     = 1.0e-3;

  73.     /** Field for year, month and day parsing. */
  74.     private static final String  INTEGER2_FIELD               = "((?:\\p{Blank}|\\p{Digit})\\p{Digit})";

  76.     /** Field for modified Julian day parsing. */
  77.     private static final String  MJD_FIELD                    = "\\p{Blank}+(\\p{Digit}+)(?:\\.00*)";

  79.     /** Field for separator parsing. */
  80.     private static final String  SEPARATOR                    = "\\p{Blank}*[IP]";

  82.     /** Field for real parsing. */
  83.     private static final String  REAL_FIELD                   = "\\p{Blank}*(-?\\p{Digit}*\\.\\p{Digit}*)";

  85.     /** Start index of the date part of the line. */
  86.     private static int DATE_START = 0;

  88.     /** end index of the date part of the line. */
  89.     private static int DATE_END   = 15;

  91.     /** Pattern to match the date part of the line (always present). */
  92.     private static final Pattern DATE_PATTERN = Pattern.compile(INTEGER2_FIELD + INTEGER2_FIELD + INTEGER2_FIELD + MJD_FIELD);

  94.     /** Start index of the pole part of the line. */
  95.     private static int POLE_START = 16;

  97.     /** end index of the pole part of the line. */
  98.     private static int POLE_END   = 55;

  100.     /** Pattern to match the pole part of the line. */
  101.     private static final Pattern POLE_PATTERN = Pattern.compile(SEPARATOR + REAL_FIELD + REAL_FIELD + REAL_FIELD + REAL_FIELD);

  103.     /** Start index of the UT1-UTC part of the line. */
  104.     private static int UT1_UTC_START = 57;

  106.     /** end index of the UT1-UTC part of the line. */
  107.     private static int UT1_UTC_END   = 78;

  109.     /** Pattern to match the UT1-UTC part of the line. */
  110.     private static final Pattern UT1_UTC_PATTERN = Pattern.compile(SEPARATOR + REAL_FIELD + REAL_FIELD);

  112.     /** Start index of the LOD part of the line. */
  113.     private static int LOD_START = 79;

  115.     /** end index of the LOD part of the line. */
  116.     private static int LOD_END   = 93;

  118.     /** Pattern to match the LOD part of the line. */
  119.     private static final Pattern LOD_PATTERN = Pattern.compile(REAL_FIELD + REAL_FIELD);

  121.     /** Start index of the nutation part of the line. */
  122.     private static int NUTATION_START = 95;

  124.     /** end index of the nutation part of the line. */
  125.     private static int NUTATION_END   = 134;

  127.     /** Pattern to match the nutation part of the line. */
  128.     private static final Pattern NUTATION_PATTERN = Pattern.compile(SEPARATOR + REAL_FIELD + REAL_FIELD + REAL_FIELD + REAL_FIELD);

  130.     /** Type of nutation corrections. */
  131.     private final boolean isNonRotatingOrigin;

  133.     /** File supported name. */
  134.     private final String  supportedNames;

  136.     /** Build a loader for IERS bulletins B files.
  137.      * @param isNonRotatingOrigin if true the supported files <em>must</em>
  138.      * contain &delta;X/&delta;Y nutation corrections, otherwise they
  139.      * <em>must</em> contain &delta;&Delta;&psi;/&delta;&Delta;&epsilon; nutation
  140.      * corrections
  141.      * @param supportedNames regular expression for supported files names
  142.      */
  143.     public RapidDataAndPredictionColumnsLoader(final boolean isNonRotatingOrigin,
  144.                                                final String supportedNames) {
  145.         this.isNonRotatingOrigin = isNonRotatingOrigin;
  146.         this.supportedNames      = supportedNames;
  147.     }

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

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

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

  164.         /** Indicator for Non-Rotating Origin. */
  165.         private final boolean isNonRotatingOrigin;

  167.         /** History entries. */
  168.         private final List<EOPEntry> history;

  170.         /** Current line number. */
  171.         private int lineNumber;

  173.         /** Current line. */
  174.         private String line;

  176.         /** Simple constructor.
  177.          * @param converter converter to use
  178.          * @param isNonRotatingOrigin type of nutation correction
  179.          */
  180.         public Parser(final IERSConventions.NutationCorrectionConverter converter,
  181.                       final boolean isNonRotatingOrigin) {
  182.             this.converter           = converter;
  183.             this.isNonRotatingOrigin = isNonRotatingOrigin;
  184.             this.history             = new ArrayList<EOPEntry>();
  185.             this.lineNumber          = 0;
  186.         }

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

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

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

  200.             // reset parse info to start new file (do not clear history!)
  201.             lineNumber = 0;

  203.             for (line = reader.readLine(); line != null; line = reader.readLine()) {

  205.                 lineNumber++;

  207.                 // split the lines in its various columns (some of them can be blank)
  208.                 final String datePart      = (line.length() >= DATE_END)     ? line.substring(DATE_START,       DATE_END)     : "";
  209.                 final String polePart      = (line.length() >= POLE_END)     ? line.substring(POLE_START,       POLE_END)     : "";
  210.                 final String ut1utcPart    = (line.length() >= UT1_UTC_END ) ? line.substring(UT1_UTC_START,    UT1_UTC_END)  : "";
  211.                 final String lodPart       = (line.length() >= LOD_END)      ? line.substring(LOD_START,        LOD_END)      : "";
  212.                 final String nutationPart  = (line.length() >= NUTATION_END) ? line.substring(NUTATION_START,   NUTATION_END) : "";

  214.                 // parse the date part
  215.                 final Matcher dateMatcher = DATE_PATTERN.matcher(datePart);
  216.                 final int mjd;
  217.                 if (dateMatcher.matches()) {
  218.                     final int yy = Integer.parseInt(dateMatcher.group(1).trim());
  219.                     final int mm = Integer.parseInt(dateMatcher.group(2).trim());
  220.                     final int dd = Integer.parseInt(dateMatcher.group(3).trim());
  221.                     final int yyyy = (yy > 70) ? yy + 1900 : yy + 2000;
  222.                     mjd = Integer.parseInt(dateMatcher.group(4).trim());
  223.                     final int reconstructedDate = new DateComponents(yyyy, mm, dd).getMJD();
  224.                     if (reconstructedDate != mjd) {
  225.                         throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  226.                                                   lineNumber, name, line);
  227.                     }
  228.                 } else {
  229.                     throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  230.                                               lineNumber, name, line);
  231.                 }

  233.                 // parse the pole part
  234.                 final double x;
  235.                 final double y;
  236.                 if (polePart.trim().length() == 0) {
  237.                     // pole part is blank
  238.                     x = 0;
  239.                     y = 0;
  240.                 } else {
  241.                     final Matcher poleMatcher = POLE_PATTERN.matcher(polePart);
  242.                     if (poleMatcher.matches()) {
  243.                         x = ARC_SECONDS_TO_RADIANS * Double.parseDouble(poleMatcher.group(1));
  244.                         y = ARC_SECONDS_TO_RADIANS * Double.parseDouble(poleMatcher.group(3));
  245.                     } else {
  246.                         throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  247.                                                   lineNumber, name, line);
  248.                     }
  249.                 }

  251.                 // parse the UT1-UTC part
  252.                 final double dtu1;
  253.                 if (ut1utcPart.trim().length() == 0) {
  254.                     // UT1-UTC part is blank
  255.                     dtu1 = 0;
  256.                 } else {
  257.                     final Matcher ut1utcMatcher = UT1_UTC_PATTERN.matcher(ut1utcPart);
  258.                     if (ut1utcMatcher.matches()) {
  259.                         dtu1 = Double.parseDouble(ut1utcMatcher.group(1));
  260.                     } else {
  261.                         throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  262.                                                   lineNumber, name, line);
  263.                     }
  264.                 }

  266.                 // parse the lod part
  267.                 final double lod;
  268.                 if (lodPart.trim().length() == 0) {
  269.                     // lod part is blank
  270.                     lod = 0;
  271.                 } else {
  272.                     final Matcher lodMatcher = LOD_PATTERN.matcher(lodPart);
  273.                     if (lodMatcher.matches()) {
  274.                         lod = MILLI_SECONDS_TO_SECONDS * Double.parseDouble(lodMatcher.group(1));
  275.                     } else {
  276.                         throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  277.                                                   lineNumber, name, line);
  278.                     }
  279.                 }

  281.                 // parse the nutation part
  282.                 final double[] nro;
  283.                 final double[] equinox;
  284.                 if (nutationPart.trim().length() == 0) {
  285.                     // nutation part is blank
  286.                     nro     = new double[2];
  287.                     equinox = new double[2];
  288.                 } else {
  289.                     final Matcher nutationMatcher = NUTATION_PATTERN.matcher(nutationPart);
  290.                     final AbsoluteDate mjdDate =
  291.                             new AbsoluteDate(new DateComponents(DateComponents.MODIFIED_JULIAN_EPOCH, mjd),
  292.                                              TimeScalesFactory.getUTC());
  293.                     if (nutationMatcher.matches()) {
  294.                         if (isNonRotatingOrigin) {
  295.                             nro = new double[] {
  296.                                 MILLI_ARC_SECONDS_TO_RADIANS * Double.parseDouble(nutationMatcher.group(1)),
  297.                                 MILLI_ARC_SECONDS_TO_RADIANS * Double.parseDouble(nutationMatcher.group(3))
  298.                             };
  299.                             equinox = converter.toEquinox(mjdDate, nro[0], nro[1]);
  300.                         } else {
  301.                             equinox = new double[] {
  302.                                 MILLI_ARC_SECONDS_TO_RADIANS * Double.parseDouble(nutationMatcher.group(1)),
  303.                                 MILLI_ARC_SECONDS_TO_RADIANS * Double.parseDouble(nutationMatcher.group(3))
  304.                             };
  305.                             nro = converter.toNonRotating(mjdDate, equinox[0], equinox[1]);
  306.                         }
  307.                     } else {
  308.                         throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  309.                                                   lineNumber, name, line);
  310.                     }
  311.                 }

  313.                 history.add(new EOPEntry(mjd, dtu1, lod, x, y, equinox[0], equinox[1], nro[0], nro[1]));

  315.             }

  317.         }

  319.     }

  321. }
Created with JaCoCo 0.6.3.201306030806