RapidDataAndPredictionXMLLoader.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.frames;

  19. import java.io.IOException;
  20. import java.io.InputStream;
  21. import java.io.InputStreamReader;
  22. import java.util.ArrayList;
  23. import java.util.List;
  24. import java.util.SortedSet;

  26. import javax.xml.parsers.ParserConfigurationException;
  27. import javax.xml.parsers.SAXParserFactory;

  29. import org.hipparchus.exception.LocalizedCoreFormats;
  30. import org.orekit.data.DataLoader;
  31. import org.orekit.data.DataProvidersManager;
  32. import org.orekit.errors.OrekitException;
  33. import org.orekit.errors.OrekitMessages;
  34. import org.orekit.time.AbsoluteDate;
  35. import org.orekit.time.DateComponents;
  36. import org.orekit.time.TimeScalesFactory;
  37. import org.orekit.utils.Constants;
  38. import org.orekit.utils.IERSConventions;
  39. import org.xml.sax.Attributes;
  40. import org.xml.sax.InputSource;
  41. import org.xml.sax.SAXException;
  42. import org.xml.sax.XMLReader;
  43. import org.xml.sax.helpers.DefaultHandler;

  45. /** Loader for IERS rapid data and prediction file in XML format (finals file).
  46.  * <p>Rapid data and prediction file contain {@link EOPEntry
  47.  * Earth Orientation Parameters} for several years periods, in one file
  48.  * only that is updated regularly.</p>
  49.  * <p>The XML EOP files are recognized thanks to their base names, which
  50.  * must match one of the the patterns <code>finals.2000A.*.xml</code> or
  51.  * <code>finals.*.xml</code> (or the same ending with <code>.gz</code> for
  52.  * gzip-compressed files) where * stands for a word like "all", "daily",
  53.  * or "data".</p>
  54.  * <p>Files containing data (back to 1973) are available at IERS web site: <a
  55.  * href="http://www.iers.org/IERS/EN/DataProducts/EarthOrientationData/eop.html">Earth orientation data</a>.</p>
  56.  * <p>
  57.  * This class is immutable and hence thread-safe
  58.  * </p>
  59.  * @author Luc Maisonobe
  60.  */
  61. class RapidDataAndPredictionXMLLoader implements EOPHistoryLoader {

  63.     /** Conversion factor for milli-arc seconds entries. */
  64.     private static final double MILLI_ARC_SECONDS_TO_RADIANS = Constants.ARC_SECONDS_TO_RADIANS / 1000.0;

  66.     /** Conversion factor for milli seconds entries. */
  67.     private static final double MILLI_SECONDS_TO_SECONDS = 1.0 / 1000.0;

  69.     /** Regular expression for supported files names. */
  70.     private final String supportedNames;

  72.     /** Build a loader for IERS XML EOP files.
  73.      * @param supportedNames regular expression for supported files names
  74.      */
  75.     RapidDataAndPredictionXMLLoader(final String supportedNames) {
  76.         this.supportedNames = supportedNames;
  77.     }

  79.     /** {@inheritDoc} */
  80.     public void fillHistory(final IERSConventions.NutationCorrectionConverter converter,
  81.                             final SortedSet<EOPEntry> history)
  82.         throws OrekitException {
  83.         final Parser parser = new Parser(converter);
  84.         DataProvidersManager.getInstance().feed(supportedNames, parser);
  85.         history.addAll(parser.history);
  86.     }

  88.     /** Internal class performing the parsing. */
  89.     private static class Parser implements DataLoader {

  91.         /** Converter for nutation corrections. */
  92.         private final IERSConventions.NutationCorrectionConverter converter;

  94.         /** Configuration for ITRF versions. */
  95.         private final ITRFVersionLoader itrfVersionLoader;

  97.         /** History entries. */
  98.         private final List<EOPEntry> history;

  100.         /** Simple constructor.
  101.          * @param converter converter to use
  102.          * @exception OrekitException if ITRF version loader cannot be parsed
  103.          */
  104.         Parser(final IERSConventions.NutationCorrectionConverter converter)
  105.             throws OrekitException {
  106.             this.converter         = converter;
  107.             this.itrfVersionLoader = new ITRFVersionLoader(ITRFVersionLoader.SUPPORTED_NAMES);
  108.             this.history           = new ArrayList<EOPEntry>();
  109.         }

  111.         /** {@inheritDoc} */
  112.         public boolean stillAcceptsData() {
  113.             return true;
  114.         }

  116.         /** {@inheritDoc} */
  117.         public void loadData(final InputStream input, final String name)
  118.             throws IOException, OrekitException {
  119.             try {
  120.                 // set up a reader for line-oriented bulletin B files
  121.                 final XMLReader reader = SAXParserFactory.newInstance().newSAXParser().getXMLReader();
  122.                 reader.setContentHandler(new EOPContentHandler(name));
  123.                 // disable external entities
  124.                 reader.setEntityResolver((publicId, systemId) -> new InputSource());

  126.                 // read all file, ignoring header
  127.                 reader.parse(new InputSource(new InputStreamReader(input, "UTF-8")));

  129.             } catch (SAXException se) {
  130.                 if ((se.getCause() != null) && (se.getCause() instanceof OrekitException)) {
  131.                     throw (OrekitException) se.getCause();
  132.                 }
  133.                 throw new OrekitException(se, LocalizedCoreFormats.SIMPLE_MESSAGE, se.getMessage());
  134.             } catch (ParserConfigurationException pce) {
  135.                 throw new OrekitException(pce, LocalizedCoreFormats.SIMPLE_MESSAGE, pce.getMessage());
  136.             }
  137.         }

  139.         /** Local content handler for XML EOP files. */
  140.         private class EOPContentHandler extends DefaultHandler {

  142.             // CHECKSTYLE: stop JavadocVariable check

  144.             // elements and attributes used in both daily and finals data files
  145.             private static final String MJD_ELT           = "MJD";
  146.             private static final String LOD_ELT           = "LOD";
  147.             private static final String X_ELT             = "X";
  148.             private static final String Y_ELT             = "Y";
  149.             private static final String DPSI_ELT          = "dPsi";
  150.             private static final String DEPSILON_ELT      = "dEpsilon";
  151.             private static final String DX_ELT            = "dX";
  152.             private static final String DY_ELT            = "dY";

  154.             // elements and attributes specific to daily data files
  155.             private static final String DATA_EOP_ELT      = "dataEOP";
  156.             private static final String TIME_SERIES_ELT   = "timeSeries";
  157.             private static final String DATE_YEAR_ELT     = "dateYear";
  158.             private static final String DATE_MONTH_ELT    = "dateMonth";
  159.             private static final String DATE_DAY_ELT      = "dateDay";
  160.             private static final String POLE_ELT          = "pole";
  161.             private static final String UT_ELT            = "UT";
  162.             private static final String UT1_U_UTC_ELT     = "UT1_UTC";
  163.             private static final String NUTATION_ELT      = "nutation";
  164.             private static final String SOURCE_ATTR       = "source";
  165.             private static final String BULLETIN_A_SOURCE = "BulletinA";

  167.             // elements and attributes specific to finals data files
  168.             private static final String FINALS_ELT        = "Finals";
  169.             private static final String DATE_ELT          = "date";
  170.             private static final String EOP_SET_ELT       = "EOPSet";
  171.             private static final String BULLETIN_A_ELT    = "bulletinA";
  172.             private static final String UT1_M_UTC_ELT     = "UT1-UTC";

  174.             private boolean inBulletinA;
  175.             private int     year;
  176.             private int     month;
  177.             private int     day;
  178.             private int     mjd;
  179.             private AbsoluteDate mjdDate;
  180.             private double  dtu1;
  181.             private double  lod;
  182.             private double  x;
  183.             private double  y;
  184.             private double  dpsi;
  185.             private double  deps;
  186.             private double  dx;
  187.             private double  dy;

  189.             // CHECKSTYLE: resume JavadocVariable check

  191.             /** File name. */
  192.             private final String name;

  194.             /** Buffer for read characters. */
  195.             private final StringBuffer buffer;

  197.             /** Indicator for daily data XML format or final data XML format. */
  198.             private DataFileContent content;

  200.             /** ITRF version configuration. */
  201.             private ITRFVersionLoader.ITRFVersionConfiguration configuration;

  203.             /** Simple constructor.
  204.              * @param name file name
  205.              */
  206.             EOPContentHandler(final String name) {
  207.                 this.name   = name;
  208.                 this.buffer = new StringBuffer();
  209.             }

  211.             /** {@inheritDoc} */
  212.             @Override
  213.             public void startDocument() {
  214.                 content       = DataFileContent.UNKNOWN;
  215.                 configuration = null;
  216.             }

  218.             /** {@inheritDoc} */
  219.             @Override
  220.             public void characters(final char[] ch, final int start, final int length) {
  221.                 buffer.append(ch, start, length);
  222.             }

  224.             /** {@inheritDoc} */
  225.             @Override
  226.             public void startElement(final String uri, final String localName,
  227.                                      final String qName, final Attributes atts) {

  229.                 // reset the buffer to empty
  230.                 buffer.delete(0, buffer.length());

  232.                 if (content == DataFileContent.UNKNOWN) {
  233.                     // try to identify file content
  234.                     if (qName.equals(TIME_SERIES_ELT)) {
  235.                         // the file contains final data
  236.                         content = DataFileContent.DAILY;
  237.                     } else if (qName.equals(FINALS_ELT)) {
  238.                         // the file contains final data
  239.                         content = DataFileContent.FINAL;
  240.                     }
  241.                 }

  243.                 if (content == DataFileContent.DAILY) {
  244.                     startDailyElement(qName, atts);
  245.                 } else if (content == DataFileContent.FINAL) {
  246.                     startFinalElement(qName, atts);
  247.                 }

  249.             }

  251.             /** Handle end of an element in a daily data file.
  252.              * @param qName name of the element
  253.              * @param atts element attributes
  254.              */
  255.             private void startDailyElement(final String qName, final Attributes atts) {
  256.                 if (qName.equals(TIME_SERIES_ELT)) {
  257.                     // reset EOP data
  258.                     resetEOPData();
  259.                 } else if (qName.equals(POLE_ELT) || qName.equals(UT_ELT) || qName.equals(NUTATION_ELT)) {
  260.                     final String source = atts.getValue(SOURCE_ATTR);
  261.                     if (source != null) {
  262.                         inBulletinA = source.equals(BULLETIN_A_SOURCE);
  263.                     }
  264.                 }
  265.             }

  267.             /** Handle end of an element in a final data file.
  268.              * @param qName name of the element
  269.              * @param atts element attributes
  270.              */
  271.             private void startFinalElement(final String qName, final Attributes atts) {
  272.                 if (qName.equals(EOP_SET_ELT)) {
  273.                     // reset EOP data
  274.                     resetEOPData();
  275.                 } else if (qName.equals(BULLETIN_A_ELT)) {
  276.                     inBulletinA = true;
  277.                 }
  278.             }

  280.             /** Reset EOP data.
  281.              */
  282.             private void resetEOPData() {
  283.                 inBulletinA = false;
  284.                 year        = -1;
  285.                 month       = -1;
  286.                 day         = -1;
  287.                 mjd         = -1;
  288.                 mjdDate     = null;
  289.                 dtu1        = Double.NaN;
  290.                 lod         = Double.NaN;
  291.                 x           = Double.NaN;
  292.                 y           = Double.NaN;
  293.                 dpsi        = Double.NaN;
  294.                 deps        = Double.NaN;
  295.                 dx          = Double.NaN;
  296.                 dy          = Double.NaN;
  297.             }

  299.             /** {@inheritDoc} */
  300.             @Override
  301.             public void endElement(final String uri, final String localName, final String qName)
  302.                 throws SAXException {
  303.                 try {
  304.                     if (content == DataFileContent.DAILY) {
  305.                         endDailyElement(qName);
  306.                     } else if (content == DataFileContent.FINAL) {
  307.                         endFinalElement(qName);
  308.                     }
  309.                 } catch (OrekitException oe) {
  310.                     throw new SAXException(oe);
  311.                 }
  312.             }

  314.             /** Handle end of an element in a daily data file.
  315.              * @param qName name of the element
  316.              * @exception OrekitException if an EOP element cannot be built
  317.              */
  318.             private void endDailyElement(final String qName) throws OrekitException {
  319.                 if (qName.equals(DATE_YEAR_ELT) && (buffer.length() > 0)) {
  320.                     year = Integer.parseInt(buffer.toString());
  321.                 } else if (qName.equals(DATE_MONTH_ELT) && (buffer.length() > 0)) {
  322.                     month = Integer.parseInt(buffer.toString());
  323.                 } else if (qName.equals(DATE_DAY_ELT) && (buffer.length() > 0)) {
  324.                     day = Integer.parseInt(buffer.toString());
  325.                 } else if (qName.equals(MJD_ELT) && (buffer.length() > 0)) {
  326.                     mjd     = Integer.parseInt(buffer.toString());
  327.                     mjdDate = new AbsoluteDate(new DateComponents(DateComponents.MODIFIED_JULIAN_EPOCH, mjd),
  328.                                                TimeScalesFactory.getUTC());
  329.                 } else if (qName.equals(UT1_M_UTC_ELT)) {
  330.                     dtu1 = overwrite(dtu1, 1.0);
  331.                 } else if (qName.equals(LOD_ELT)) {
  332.                     lod = overwrite(lod, MILLI_SECONDS_TO_SECONDS);
  333.                 } else if (qName.equals(X_ELT)) {
  334.                     x = overwrite(x, Constants.ARC_SECONDS_TO_RADIANS);
  335.                 } else if (qName.equals(Y_ELT)) {
  336.                     y = overwrite(y, Constants.ARC_SECONDS_TO_RADIANS);
  337.                 } else if (qName.equals(DPSI_ELT)) {
  338.                     dpsi = overwrite(dpsi, MILLI_ARC_SECONDS_TO_RADIANS);
  339.                 } else if (qName.equals(DEPSILON_ELT)) {
  340.                     deps = overwrite(deps, MILLI_ARC_SECONDS_TO_RADIANS);
  341.                 } else if (qName.equals(DX_ELT)) {
  342.                     dx   = overwrite(dx, MILLI_ARC_SECONDS_TO_RADIANS);
  343.                 } else if (qName.equals(DY_ELT)) {
  344.                     dy   = overwrite(dy, MILLI_ARC_SECONDS_TO_RADIANS);
  345.                 } else if (qName.equals(POLE_ELT) || qName.equals(UT_ELT) || qName.equals(NUTATION_ELT)) {
  346.                     inBulletinA = false;
  347.                 } else if (qName.equals(DATA_EOP_ELT)) {
  348.                     checkDates();
  349.                     if ((!Double.isNaN(dtu1)) && (!Double.isNaN(lod)) && (!Double.isNaN(x)) && (!Double.isNaN(y))) {
  350.                         final double[] equinox;
  351.                         final double[] nro;
  352.                         if (Double.isNaN(dpsi)) {
  353.                             nro = new double[] {
  354.                                 dx, dy
  355.                             };
  356.                             equinox = converter.toEquinox(mjdDate, nro[0], nro[1]);
  357.                         } else {
  358.                             equinox = new double[] {
  359.                                 dpsi, deps
  360.                             };
  361.                             nro = converter.toNonRotating(mjdDate, equinox[0], equinox[1]);
  362.                         }
  363.                         if (configuration == null || !configuration.isValid(mjd)) {
  364.                             // get a configuration for current name and date range
  365.                             configuration = itrfVersionLoader.getConfiguration(name, mjd);
  366.                         }
  367.                         history.add(new EOPEntry(mjd, dtu1, lod, x, y, equinox[0], equinox[1], nro[0], nro[1],
  368.                                                  configuration.getVersion()));
  369.                     }
  370.                 }
  371.             }

  373.             /** Handle end of an element in a final data file.
  374.              * @param qName name of the element
  375.              * @exception OrekitException if an EOP element cannot be built
  376.              */
  377.             private void endFinalElement(final String qName) throws OrekitException {
  378.                 if (qName.equals(DATE_ELT) && (buffer.length() > 0)) {
  379.                     final String[] fields = buffer.toString().split("-");
  380.                     if (fields.length == 3) {
  381.                         year  = Integer.parseInt(fields[0]);
  382.                         month = Integer.parseInt(fields[1]);
  383.                         day   = Integer.parseInt(fields[2]);
  384.                     }
  385.                 } else if (qName.equals(MJD_ELT) && (buffer.length() > 0)) {
  386.                     mjd     = Integer.parseInt(buffer.toString());
  387.                     mjdDate = new AbsoluteDate(new DateComponents(DateComponents.MODIFIED_JULIAN_EPOCH, mjd),
  388.                                                TimeScalesFactory.getUTC());
  389.                 } else if (qName.equals(UT1_U_UTC_ELT)) {
  390.                     dtu1 = overwrite(dtu1, 1.0);
  391.                 } else if (qName.equals(LOD_ELT)) {
  392.                     lod = overwrite(lod, MILLI_SECONDS_TO_SECONDS);
  393.                 } else if (qName.equals(X_ELT)) {
  394.                     x = overwrite(x, Constants.ARC_SECONDS_TO_RADIANS);
  395.                 } else if (qName.equals(Y_ELT)) {
  396.                     y = overwrite(y, Constants.ARC_SECONDS_TO_RADIANS);
  397.                 } else if (qName.equals(DPSI_ELT)) {
  398.                     dpsi = overwrite(dpsi, MILLI_ARC_SECONDS_TO_RADIANS);
  399.                 } else if (qName.equals(DEPSILON_ELT)) {
  400.                     deps = overwrite(deps, MILLI_ARC_SECONDS_TO_RADIANS);
  401.                 } else if (qName.equals(DX_ELT)) {
  402.                     dx   = overwrite(dx, MILLI_ARC_SECONDS_TO_RADIANS);
  403.                 } else if (qName.equals(DY_ELT)) {
  404.                     dy   = overwrite(dy, MILLI_ARC_SECONDS_TO_RADIANS);
  405.                 } else if (qName.equals(BULLETIN_A_ELT)) {
  406.                     inBulletinA = false;
  407.                 } else if (qName.equals(EOP_SET_ELT)) {
  408.                     checkDates();
  409.                     if ((!Double.isNaN(dtu1)) && (!Double.isNaN(lod)) && (!Double.isNaN(x)) && (!Double.isNaN(y))) {
  410.                         final double[] equinox;
  411.                         final double[] nro;
  412.                         if (Double.isNaN(dpsi)) {
  413.                             nro = new double[] {
  414.                                 dx, dy
  415.                             };
  416.                             equinox = converter.toEquinox(mjdDate, nro[0], nro[1]);
  417.                         } else {
  418.                             equinox = new double[] {
  419.                                 dpsi, deps
  420.                             };
  421.                             nro = converter.toNonRotating(mjdDate, equinox[0], equinox[1]);
  422.                         }
  423.                         if (configuration == null || !configuration.isValid(mjd)) {
  424.                             // get a configuration for current name and date range
  425.                             configuration = itrfVersionLoader.getConfiguration(name, mjd);
  426.                         }
  427.                         history.add(new EOPEntry(mjd, dtu1, lod, x, y, equinox[0], equinox[1], nro[0], nro[1],
  428.                                                  configuration.getVersion()));
  429.                     }
  430.                 }
  431.             }

  433.             /** Overwrite a value if it is not set or if we are in a bulletinB.
  434.              * @param oldValue old value to overwrite (may be NaN)
  435.              * @param factor multiplicative factor to apply to raw read data
  436.              * @return a new value
  437.              */
  438.             private double overwrite(final double oldValue, final double factor) {
  439.                 if (buffer.length() == 0) {
  440.                     // there is nothing to overwrite with
  441.                     return oldValue;
  442.                 } else if (inBulletinA && (!Double.isNaN(oldValue))) {
  443.                     // the value is already set and bulletin A values have a low priority
  444.                     return oldValue;
  445.                 } else {
  446.                     // either the value is not set or it is a high priority bulletin B value
  447.                     return Double.parseDouble(buffer.toString()) * factor;
  448.                 }
  449.             }

  451.             /** Check if the year, month, day date and MJD date are consistent.
  452.              * @exception OrekitException if dates are not consistent
  453.              */
  454.             private void checkDates() throws OrekitException {
  455.                 if (new DateComponents(year, month, day).getMJD() != mjd) {
  456.                     throw new OrekitException(OrekitMessages.INCONSISTENT_DATES_IN_IERS_FILE,
  457.                                               name, year, month, day, mjd);
  458.                 }
  459.             }

  461.         }

  463.         /** Enumerate for data file content. */
  464.         private enum DataFileContent {

  466.             /** Unknown content. */
  467.             UNKNOWN,

  469.             /** Daily data. */
  470.             DAILY,

  472.             /** Final data. */
  473.             FINAL;

  475.         }

  477.     }

  479. }
Created with JaCoCo 0.7.9.201702052155