AntexLoader.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.gnss.antenna;

  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.Collections;
  25. import java.util.HashMap;
  26. import java.util.List;
  27. import java.util.Map;
  28. import java.util.Optional;

  30. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  31. import org.hipparchus.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.OrekitIllegalArgumentException;
  36. import org.orekit.errors.OrekitMessages;
  37. import org.orekit.gnss.Frequency;
  38. import org.orekit.gnss.SatelliteSystem;
  39. import org.orekit.time.AbsoluteDate;
  40. import org.orekit.time.TimeScalesFactory;
  41. import org.orekit.utils.TimeSpanMap;

  43. /**
  44.  * Factory for GNSS antennas (both receiver and satellite).
  45.  * <p>
  46.  * The factory creates antennas by parsing an
  47.  * <a href="ftp://www.igs.org/pub/station/general/antex14.txt">ANTEX</a> file.
  48.  * </p>
  49.  *
  50.  * @author Luc Maisonobe
  51.  * @since 9.2
  52.  */
  53. public class AntexLoader {

  55.     /** Default supported files name pattern for antex files. */
  56.     public static final String DEFAULT_ANTEX_SUPPORTED_NAMES = "^\\w{5}(?:_\\d{4})?\\.atx$";

  58.     /** Satellites antennas. */
  59.     private final List<TimeSpanMap<SatelliteAntenna>> satellitesAntennas;

  61.     /** Receivers antennas. */
  62.     private final List<ReceiverAntenna> receiversAntennas;

  64.     /** Simple constructor.
  65.      * @param supportedNames regular expression for supported files names
  66.      * @exception OrekitException if no antex file can be read
  67.      */
  68.     public AntexLoader(final String supportedNames)
  69.         throws OrekitException {
  70.         satellitesAntennas = new ArrayList<>();
  71.         receiversAntennas  = new ArrayList<>();
  72.         DataProvidersManager.getInstance().feed(supportedNames, new Parser());
  73.     }

  75.     /** Add a satellite antenna.
  76.      * @param antenna satellite antenna to add
  77.      */
  78.     private void addSatelliteAntenna(final SatelliteAntenna antenna) {
  79.         try {
  80.             final TimeSpanMap<SatelliteAntenna> existing =
  81.                             findSatelliteAntenna(antenna.getSatelliteSystem(), antenna.getPrnNumber());
  82.             // this is an update for a satellite antenna, with new time span
  83.             existing.addValidAfter(antenna, antenna.getValidFrom());
  84.         } catch (OrekitException oe) {
  85.             // this is a new satellite antenna
  86.             satellitesAntennas.add(new TimeSpanMap<>(antenna));
  87.         }
  88.     }

  90.     /** Get parsed satellites antennas.
  91.      * @return unmodifiable view of parsed satellites antennas
  92.      */
  93.     public List<TimeSpanMap<SatelliteAntenna>> getSatellitesAntennas() {
  94.         return Collections.unmodifiableList(satellitesAntennas);
  95.     }

  97.     /** Find the time map for a specific satellite antenna.
  98.      * @param satelliteSystem satellite system
  99.      * @param prnNumber number within the satellite system
  100.      * @return time map for the antenna
  101.      * @exception OrekitException if satellite cannot be found
  102.      */
  103.     public TimeSpanMap<SatelliteAntenna> findSatelliteAntenna(final SatelliteSystem satelliteSystem,
  104.                                                               final int prnNumber)
  105.         throws OrekitException {
  106.         final Optional<TimeSpanMap<SatelliteAntenna>> existing =
  107.                         satellitesAntennas.
  108.                         stream().
  109.                         filter(m -> {
  110.                             final SatelliteAntenna first = m.getTransitions().first().getBefore();
  111.                             return first.getSatelliteSystem() == satelliteSystem &&
  112.                                    first.getPrnNumber() == prnNumber;
  113.                         }).findFirst();
  114.         if (existing.isPresent()) {
  115.             return existing.get();
  116.         } else {
  117.             throw new OrekitException(OrekitMessages.CANNOT_FIND_SATELLITE_IN_SYSTEM,
  118.                                       prnNumber, satelliteSystem);
  119.         }
  120.     }

  122.     /** Add a receiver antenna.
  123.      * @param antenna receiver antenna to add
  124.      */
  125.     private void addReceiverAntenna(final ReceiverAntenna antenna) {
  126.         receiversAntennas.add(antenna);
  127.     }

  129.     /** Get parsed receivers antennas.
  130.      * @return unmodifiable view of parsed receivers antennas
  131.      */
  132.     public List<ReceiverAntenna> getReceiversAntennas() {
  133.         return Collections.unmodifiableList(receiversAntennas);
  134.     }

  136.     /** Parser for antex files.
  137.      * @see <a href="ftp://www.igs.org/pub/station/general/antex14.txt">ANTEX: The Antenna Exchange Format, Version 1.4</a>
  138.      */
  139.     private class Parser implements DataLoader {

  141.         /** Index of label in data lines. */
  142.         private static final int LABEL_START = 60;

  144.         /** Supported format version. */
  145.         private static final double FORMAT_VERSION = 1.4;

  147.         /** Phase center eccentricities conversion factor. */
  148.         private static final double MM_TO_M = 0.001;

  150.         /** {@inheritDoc} */
  151.         @Override
  152.         public boolean stillAcceptsData() {
  153.             // we load all antex files we can find
  154.             return true;
  155.         }

  157.         /** {@inheritDoc} */
  158.         @Override
  159.         public void loadData(final InputStream input, final String name)
  160.             throws IOException, OrekitException {

  162.             try (BufferedReader reader = new BufferedReader(new InputStreamReader(input, "UTF-8"))) {

  164.                 // placeholders for parsed data
  165.                 int                              lineNumber           = 0;
  166.                 SatelliteSystem                  satelliteSystem      = null;
  167.                 String                           antennaType          = null;
  168.                 SatelliteAntennaCode             satelliteAntennaCode = null;
  169.                 String                           serialNumber         = null;
  170.                 int                              prnNumber            = -1;
  171.                 int                              satelliteCode        = -1;
  172.                 String                           cosparID             = null;
  173.                 AbsoluteDate                     validFrom            = AbsoluteDate.PAST_INFINITY;
  174.                 AbsoluteDate                     validUntil           = AbsoluteDate.FUTURE_INFINITY;
  175.                 String                           sinexCode            = null;
  176.                 double                           azimuthStep          = Double.NaN;
  177.                 double                           polarStart           = Double.NaN;
  178.                 double                           polarStop            = Double.NaN;
  179.                 double                           polarStep            = Double.NaN;
  180.                 double[]                         grid1D               = null;
  181.                 double[][]                       grid2D               = null;
  182.                 Vector3D                         eccentricities       = Vector3D.ZERO;
  183.                 int                              nbFrequencies        = -1;
  184.                 Frequency                        frequency            = null;
  185.                 Map<Frequency, FrequencyPattern> patterns             = null;
  186.                 boolean                          inFrequency          = false;
  187.                 boolean                          inRMS                = false;

  189.                 for (String line = reader.readLine(); line != null; line = reader.readLine()) {
  190.                     ++lineNumber;
  191.                     switch(line.substring(LABEL_START).trim()) {
  192.                         case "COMMENT" :
  193.                             // nothing to do
  194.                             break;
  195.                         case "ANTEX VERSION / SYST" :
  196.                             if (FastMath.abs(parseDouble(line, 0, 8) - FORMAT_VERSION) > 0.001) {
  197.                                 throw new OrekitException(OrekitMessages.UNSUPPORTED_FILE_FORMAT, name);
  198.                             }
  199.                             // we parse the general setting for satellite system to check for format errors,
  200.                             // but otherwise ignore it
  201.                             SatelliteSystem.parseSatelliteSystem(parseString(line, 20, 1));
  202.                             break;
  203.                         case "PCV TYPE / REFANT" :
  204.                             // TODO
  205.                             break;
  206.                         case "END OF HEADER" :
  207.                             // nothing to do
  208.                             break;
  209.                         case "START OF ANTENNA" :
  210.                             // reset antenna data
  211.                             satelliteSystem      = null;
  212.                             antennaType          = null;
  213.                             satelliteAntennaCode = null;
  214.                             serialNumber         = null;
  215.                             prnNumber            = -1;
  216.                             satelliteCode        = -1;
  217.                             cosparID             = null;
  218.                             validFrom            = AbsoluteDate.PAST_INFINITY;
  219.                             validUntil           = AbsoluteDate.FUTURE_INFINITY;
  220.                             sinexCode            = null;
  221.                             azimuthStep          = Double.NaN;
  222.                             polarStart           = Double.NaN;
  223.                             polarStop            = Double.NaN;
  224.                             polarStep            = Double.NaN;
  225.                             grid1D               = null;
  226.                             grid2D               = null;
  227.                             eccentricities       = Vector3D.ZERO;
  228.                             nbFrequencies        = -1;
  229.                             frequency            = null;
  230.                             patterns             = null;
  231.                             inFrequency          = false;
  232.                             inRMS                = false;
  233.                             break;
  234.                         case "TYPE / SERIAL NO" :
  235.                             antennaType = parseString(line, 0, 20);
  236.                             try {
  237.                                 satelliteAntennaCode = SatelliteAntennaCode.parseSatelliteAntennaCode(antennaType);
  238.                                 final String satField = parseString(line, 20, 20);
  239.                                 if (satField.length() > 0) {
  240.                                     satelliteSystem = SatelliteSystem.parseSatelliteSystem(satField);
  241.                                     final int n = parseInt(satField, 1, 19);
  242.                                     switch (satelliteSystem) {
  243.                                         case GPS:
  244.                                         case GLONASS:
  245.                                         case GALILEO:
  246.                                         case BEIDOU:
  247.                                         case IRNSS:
  248.                                             prnNumber = n;
  249.                                             break;
  250.                                         case QZSS:
  251.                                             prnNumber = n + 192;
  252.                                             break;
  253.                                         case SBAS:
  254.                                             prnNumber = n + 100;
  255.                                             break;
  256.                                         default:
  257.                                             // MIXED satellite system is not allowed here
  258.                                             throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  259.                                                                       lineNumber, name, line);
  260.                                     }
  261.                                     satelliteCode = parseInt(line, 41, 9); // we drop the system type
  262.                                     cosparID      = parseString(line, 50, 10);
  263.                                 }
  264.                             } catch (OrekitIllegalArgumentException oiae) {
  265.                                 // this is a receiver antenna, not a satellite antenna
  266.                                 serialNumber = parseString(line, 20, 20);
  267.                             }
  268.                             break;
  269.                         case "METH / BY / # / DATE" :
  270.                             // ignoreds
  271.                             break;
  272.                         case "DAZI" :
  273.                             azimuthStep = FastMath.toRadians(parseDouble(line,  2, 6));
  274.                             break;
  275.                         case "ZEN1 / ZEN2 / DZEN" :
  276.                             polarStart = FastMath.toRadians(parseDouble(line,  2, 6));
  277.                             polarStop  = FastMath.toRadians(parseDouble(line,  8, 6));
  278.                             polarStep  = FastMath.toRadians(parseDouble(line, 14, 6));
  279.                             break;
  280.                         case "# OF FREQUENCIES" :
  281.                             nbFrequencies = parseInt(line, 0, 6);
  282.                             patterns      = new HashMap<>(nbFrequencies);
  283.                             break;
  284.                         case "VALID FROM" :
  285.                             validFrom = new AbsoluteDate(parseInt(line,     0,  6),
  286.                                                          parseInt(line,     6,  6),
  287.                                                          parseInt(line,    12,  6),
  288.                                                          parseInt(line,    18,  6),
  289.                                                          parseInt(line,    24,  6),
  290.                                                          parseDouble(line, 30, 13),
  291.                                                          TimeScalesFactory.getGPS());
  292.                             break;
  293.                         case "VALID UNTIL" :
  294.                             validUntil = new AbsoluteDate(parseInt(line,     0,  6),
  295.                                                           parseInt(line,     6,  6),
  296.                                                           parseInt(line,    12,  6),
  297.                                                           parseInt(line,    18,  6),
  298.                                                           parseInt(line,    24,  6),
  299.                                                           parseDouble(line, 30, 13),
  300.                                                           TimeScalesFactory.getGPS());
  301.                             break;
  302.                         case "SINEX CODE" :
  303.                             sinexCode = parseString(line, 0, 10);
  304.                             break;
  305.                         case "START OF FREQUENCY" :
  306.                             try {
  307.                                 frequency = Frequency.valueOf(parseString(line, 3, 3));
  308.                                 grid1D    = new double[1 + (int) FastMath.round((polarStop - polarStart) / polarStep)];
  309.                                 if (azimuthStep > 0.001) {
  310.                                     grid2D = new double[1 + (int) FastMath.round(2 * FastMath.PI / azimuthStep)][grid1D.length];
  311.                                 }
  312.                             } catch (IllegalArgumentException iae) {
  313.                                 throw new OrekitException(OrekitMessages.UNKNOWN_RINEX_FREQUENCY,
  314.                                                           parseString(line, 3, 3), name, lineNumber);
  315.                             }
  316.                             inFrequency = true;
  317.                             break;
  318.                         case "NORTH / EAST / UP" :
  319.                             if (!inRMS) {
  320.                                 eccentricities = new Vector3D(parseDouble(line,  0, 10) * MM_TO_M,
  321.                                                               parseDouble(line, 10, 10) * MM_TO_M,
  322.                                                               parseDouble(line, 20, 10) * MM_TO_M);
  323.                             }
  324.                             break;
  325.                         case "END OF FREQUENCY" : {
  326.                             final String endFrequency = parseString(line, 3, 3);
  327.                             if (!frequency.toString().equals(endFrequency)) {
  328.                                 throw new OrekitException(OrekitMessages.MISMATCHED_FREQUENCIES,
  329.                                                           name, lineNumber, frequency.toString(), endFrequency);

  331.                             }

  333.                             final PhaseCenterVariationFunction phaseCenterVariation;
  334.                             if (grid2D == null) {
  335.                                 double max = 0;
  336.                                 for (final double v : grid1D) {
  337.                                     max = FastMath.max(max, FastMath.abs(v));
  338.                                 }
  339.                                 if (max == 0.0) {
  340.                                     // there are no known variations for this pattern
  341.                                     phaseCenterVariation = (polarAngle, azimuthAngle) -> 0.0;
  342.                                 } else {
  343.                                     phaseCenterVariation = new OneDVariation(polarStart, polarStep, grid1D);
  344.                                 }
  345.                             } else {
  346.                                 phaseCenterVariation = new TwoDVariation(polarStart, polarStep, azimuthStep, grid2D);
  347.                             }
  348.                             patterns.put(frequency, new FrequencyPattern(eccentricities, phaseCenterVariation));
  349.                             frequency   = null;
  350.                             grid1D      = null;
  351.                             grid2D      = null;
  352.                             inFrequency = false;
  353.                             break;
  354.                         }
  355.                         case "START OF FREQ RMS" :
  356.                             inRMS = true;
  357.                             break;
  358.                         case "END OF FREQ RMS" :
  359.                             inRMS = false;
  360.                             break;
  361.                         case "END OF ANTENNA" :
  362.                             if (satelliteAntennaCode == null) {
  363.                                 addReceiverAntenna(new ReceiverAntenna(antennaType, sinexCode, patterns, serialNumber));
  364.                             } else {
  365.                                 addSatelliteAntenna(new SatelliteAntenna(antennaType, sinexCode, patterns,
  366.                                                                          satelliteSystem, prnNumber, satelliteCode,
  367.                                                                          cosparID, validFrom, validUntil));
  368.                             }
  369.                             break;
  370.                         default :
  371.                             if (inFrequency) {
  372.                                 final String[] fields = line.trim().split("\\s+");
  373.                                 if (fields.length != grid1D.length + 1) {
  374.                                     throw new OrekitException(OrekitMessages.WRONG_COLUMNS_NUMBER,
  375.                                                               name, lineNumber, grid1D.length + 1, fields.length);
  376.                                 }
  377.                                 if ("NOAZI".equals(fields[0])) {
  378.                                     // azimuth-independent phase
  379.                                     for (int i = 0; i < grid1D.length; ++i) {
  380.                                         grid1D[i] = Double.parseDouble(fields[i + 1]) * MM_TO_M;
  381.                                     }

  383.                                 } else {
  384.                                     // azimuth-dependent phase
  385.                                     final int k = (int) FastMath.round(FastMath.toRadians(Double.parseDouble(fields[0])) / azimuthStep);
  386.                                     for (int i = 0; i < grid2D[k].length; ++i) {
  387.                                         grid2D[k][i] = Double.parseDouble(fields[i + 1]) * MM_TO_M;
  388.                                     }
  389.                                 }
  390.                             } else if (inRMS) {
  391.                                 // RMS section is ignored (furthermore there are no RMS sections in both igs08.atx and igs14.atx)
  392.                             } else {
  393.                                 throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  394.                                                           lineNumber, name, line);
  395.                             }
  396.                     }
  397.                 }

  399.             }
  400.         }

  402.         /** Extract a string from a line.
  403.          * @param line to parse
  404.          * @param start start index of the string
  405.          * @param length length of the string
  406.          * @return parsed string
  407.          */
  408.         private String parseString(final String line, final int start, final int length) {
  409.             return line.substring(start, FastMath.min(line.length(), start + length)).trim();
  410.         }

  412.         /** Extract an integer from a line.
  413.          * @param line to parse
  414.          * @param start start index of the integer
  415.          * @param length length of the integer
  416.          * @return parsed integer
  417.          */
  418.         private int parseInt(final String line, final int start, final int length) {
  419.             return Integer.parseInt(parseString(line, start, length));
  420.         }

  422.         /** Extract a double from a line.
  423.          * @param line to parse
  424.          * @param start start index of the real
  425.          * @param length length of the real
  426.          * @return parsed real
  427.          */
  428.         private double parseDouble(final String line, final int start, final int length) {
  429.             return Double.parseDouble(parseString(line, start, length));
  430.         }

  432.     }

  434. }
Created with JaCoCo 0.7.9.201702052155