Station.java

  1. /* Copyright 2002-2024 CS GROUP
  2.  * Licensed to CS GROUP (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.files.sinex;

  19. import java.util.HashMap;
  20. import java.util.Map;

  22. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  23. import org.orekit.errors.OrekitException;
  24. import org.orekit.errors.OrekitMessages;
  25. import org.orekit.time.AbsoluteDate;
  26. import org.orekit.utils.TimeSpanMap;

  28. /**
  29.  * Station model.
  30.  * <p>
  31.  * Since Orekit 11.1, this class handles multiple site antenna
  32.  * eccentricity.
  33.  * The {@link #getEccentricities(AbsoluteDate)} method can be
  34.  * used to access the site antenna eccentricity values for a
  35.  * given epoch.
  36.  * </p>
  37.  * @author Bryan Cazabonne
  38.  * @since 10.3
  39.  */
  40. public class Station {

  42.     /** Site code. */
  43.     private String siteCode;

  45.     /** DOMES number. */
  46.     private String domes;

  48.     /** Start of validity. */
  49.     private AbsoluteDate validFrom;

  51.     /** End of validity. */
  52.     private AbsoluteDate validUntil;

  54.     /** Eccentricity reference system. */
  55.     private ReferenceSystem eccRefSystem;

  57.     /** TimeSpanMap of site antenna eccentricities. */
  58.     private TimeSpanMap<Vector3D> eccentricitiesTimeSpanMap;

  60.     /** Antenna type.
  61.      * @since 12.0
  62.      */
  63.     private TimeSpanMap<String> antennaTypesMap;

  65.     /** Station position. */
  66.     private Vector3D position;

  68.     /** Station velocity. */
  69.     private Vector3D velocity;

  71.     /** Coordinates reference epoch. */
  72.     private AbsoluteDate epoch;

  74.     /**
  75.      * Constructor.
  76.      */
  77.     public Station() {
  78.         this.eccentricitiesTimeSpanMap = new TimeSpanMap<>(null);
  79.         this.antennaTypesMap           = new TimeSpanMap<>(null);
  80.         this.position                  = Vector3D.ZERO;
  81.         this.velocity                  = Vector3D.ZERO;
  82.     }

  84.     /**
  85.      * Get the site code (station identifier).
  86.      * @return the site code
  87.      */
  88.     public String getSiteCode() {
  89.         return siteCode;
  90.     }

  92.     /**
  93.      * Set the site code (station identifier).
  94.      * @param siteCode the site code to set
  95.      */
  96.     public void setSiteCode(final String siteCode) {
  97.         this.siteCode = siteCode;
  98.     }

  100.     /**
  101.      * Get the site DOMES number.
  102.      * @return the DOMES number
  103.      */
  104.     public String getDomes() {
  105.         return domes;
  106.     }

  108.     /**
  109.      * Set the DOMES number.
  110.      * @param domes the DOMES number to set
  111.      */
  112.     public void setDomes(final String domes) {
  113.         this.domes = domes;
  114.     }

  116.     /**
  117.      * Get start of validity.
  118.      * @return start of validity
  119.      */
  120.     public AbsoluteDate getValidFrom() {
  121.         return validFrom;
  122.     }

  124.     /**
  125.      * Set the start of validity.
  126.      * @param validFrom the start of validity to set
  127.      */
  128.     public void setValidFrom(final AbsoluteDate validFrom) {
  129.         this.validFrom = validFrom;
  130.     }

  132.     /**
  133.      * Get end of validity.
  134.      * @return end of validity
  135.      */
  136.     public AbsoluteDate getValidUntil() {
  137.         return validUntil;
  138.     }

  140.     /**
  141.      * Set the end of validity.
  142.      * @param validUntil the end of validity to set
  143.      */
  144.     public void setValidUntil(final AbsoluteDate validUntil) {
  145.         this.validUntil = validUntil;
  146.     }

  148.     /**
  149.      * Get the reference system used to define the eccentricity vector (local or cartesian).
  150.      * @return the reference system used to define the eccentricity vector
  151.      */
  152.     public ReferenceSystem getEccRefSystem() {
  153.         return eccRefSystem;
  154.     }

  156.     /**
  157.      * Set the reference system used to define the eccentricity vector (local or cartesian).
  158.      * @param eccRefSystem the reference system used to define the eccentricity vector
  159.      */
  160.     public void setEccRefSystem(final ReferenceSystem eccRefSystem) {
  161.         this.eccRefSystem = eccRefSystem;
  162.     }

  164.     /**
  165.      * Get the station antenna eccentricities for the given epoch.
  166.      * <p>
  167.      * Vector convention: X-Y-Z or UP-NORTH-EAST.
  168.      * See {@link #getEccRefSystem()} method.
  169.      * <p>
  170.      * If there is no eccentricity values for the given epoch, an
  171.      * exception is thrown.
  172.      * @param date epoch
  173.      * @return station antenna eccentricities (m)
  174.      * @since 11.1
  175.      */
  176.     public Vector3D getEccentricities(final AbsoluteDate date) {
  177.         final Vector3D eccAtEpoch = eccentricitiesTimeSpanMap.get(date);
  178.         // If the entry is null, there is no valid eccentricity values for the input epoch
  179.         if (eccAtEpoch == null) {
  180.             // Throw an exception
  181.             throw new OrekitException(OrekitMessages.MISSING_STATION_DATA_FOR_EPOCH, date);
  182.         }
  183.         return eccAtEpoch;
  184.     }

  186.     /**
  187.      * Get the TimeSpanMap of site antenna eccentricities.
  188.      * @return the TimeSpanMap of site antenna eccentricities
  189.      * @since 11.1
  190.      */
  191.     public TimeSpanMap<Vector3D> getEccentricitiesTimeSpanMap() {
  192.         return eccentricitiesTimeSpanMap;
  193.     }

  195.     /** Add a station eccentricity vector entry valid before a limit date.<br>
  196.      * Using <code>addStationEccentricitiesValidBefore(entry, t)</code> will make <code>entry</code>
  197.      * valid in ]-∞, t[ (note the open bracket).
  198.      * @param entry station eccentricity vector entry
  199.      * @param latestValidityDate date before which the entry is valid
  200.      * (must be different from <b>all</b> dates already used for transitions)
  201.      * @since 11.1
  202.      */
  203.     public void addStationEccentricitiesValidBefore(final Vector3D entry, final AbsoluteDate latestValidityDate) {
  204.         eccentricitiesTimeSpanMap.addValidBefore(entry, latestValidityDate, false);
  205.     }

  207.     /** Add a station eccentricity vector entry valid after a limit date.<br>
  208.      * Using <code>addStationEccentricitiesValidAfter(entry, t)</code> will make <code>entry</code>
  209.      * valid in [t, +∞[ (note the closed bracket).
  210.      * @param entry station eccentricity vector entry
  211.      * @param earliestValidityDate date after which the entry is valid
  212.      * (must be different from <b>all</b> dates already used for transitions)
  213.      * @since 11.1
  214.      */
  215.     public void addStationEccentricitiesValidAfter(final Vector3D entry, final AbsoluteDate earliestValidityDate) {
  216.         eccentricitiesTimeSpanMap.addValidAfter(entry, earliestValidityDate, false);
  217.     }

  219.     /**
  220.      * Get the antenna type for the given epoch.
  221.      * If there is no antenna types for the given epoch, an
  222.      * exception is thrown.
  223.      * @param date epoch
  224.      * @return antenna type
  225.      * @since 12.0
  226.      */
  227.     public String getAntennaType(final AbsoluteDate date) {
  228.         final String typeAtEpoch = antennaTypesMap.get(date);
  229.         // If the entry is null, there is no valid type for the input epoch
  230.         if (typeAtEpoch == null) {
  231.             // Throw an exception
  232.             throw new OrekitException(OrekitMessages.MISSING_STATION_DATA_FOR_EPOCH, date);
  233.         }
  234.         return typeAtEpoch;
  235.     }

  237.     /**
  238.      * Get the TimeSpanMap of site antenna type.
  239.      * @return the TimeSpanMap of site antenna type
  240.      * @since 12.0
  241.      */
  242.     public TimeSpanMap<String> getAntennaTypeTimeSpanMap() {
  243.         return antennaTypesMap;
  244.     }

  246.     /** Add a antenna type entry valid before a limit date.<br>
  247.      * Using <code>addAntennaTypeValidBefore(entry, t)</code> will make <code>entry</code>
  248.      * valid in ]-∞, t[ (note the open bracket).
  249.      * @param entry antenna type entry
  250.      * @param latestValidityDate date before which the entry is valid
  251.      * (must be different from <b>all</b> dates already used for transitions)
  252.      * @since 12.0
  253.      */
  254.     public void addAntennaTypeValidBefore(final String entry, final AbsoluteDate latestValidityDate) {
  255.         antennaTypesMap.addValidBefore(entry, latestValidityDate, false);
  256.     }

  258.     /** Add a antenna type entry valid after a limit date.<br>
  259.      * Using <code>addAntennaTypeValidAfter(entry, t)</code> will make <code>entry</code>
  260.      * valid in [t, +∞[ (note the closed bracket).
  261.      * @param entry antenna type entry
  262.      * @param earliestValidityDate date after which the entry is valid
  263.      * (must be different from <b>all</b> dates already used for transitions)
  264.      * @since 12.0
  265.      */
  266.     public void addAntennaTypeValidAfter(final String entry, final AbsoluteDate earliestValidityDate) {
  267.         antennaTypesMap.addValidAfter(entry, earliestValidityDate, false);
  268.     }

  270.     /**
  271.      * Get the station position.
  272.      * @return the station position (m)
  273.      */
  274.     public Vector3D getPosition() {
  275.         return position;
  276.     }

  278.     /**
  279.      * Set the station position.
  280.      * @param position the position to set
  281.      */
  282.     public void setPosition(final Vector3D position) {
  283.         this.position = position;
  284.     }

  286.     /**
  287.      * Get the station velocity.
  288.      * @return the station velocity (m/s)
  289.      */
  290.     public Vector3D getVelocity() {
  291.         return velocity;
  292.     }

  294.     /**
  295.      * Set the station velocity.
  296.      * @param velocity the velocity to set
  297.      */
  298.     public void setVelocity(final Vector3D velocity) {
  299.         this.velocity = velocity;
  300.     }

  302.     /**
  303.      * Get the coordinates reference epoch.
  304.      * @return the coordinates reference epoch
  305.      */
  306.     public AbsoluteDate getEpoch() {
  307.         return epoch;
  308.     }

  310.     /**
  311.      * Set the coordinates reference epoch.
  312.      * @param epoch the epoch to set
  313.      */
  314.     public void setEpoch(final AbsoluteDate epoch) {
  315.         this.epoch = epoch;
  316.     }

  318.     /** Eccentricity reference system. */
  319.     public enum ReferenceSystem {

  321.         /** Local reference system Up, North, East. */
  322.         UNE("UNE"),

  324.         /** Cartesian reference system X, Y, Z. */
  325.         XYZ("XYZ");

  327.         /** Codes map. */
  328.         private static final Map<String, ReferenceSystem> CODES_MAP = new HashMap<>();
  329.         static {
  330.             for (final ReferenceSystem type : values()) {
  331.                 CODES_MAP.put(type.getName(), type);
  332.             }
  333.         }

  335.         /** Name used to define the reference system in SINEX file. */
  336.         private final String name;

  338.         /**
  339.          * Constructor.
  340.          * @param name name used to define the reference system in SINEX file
  341.          */
  342.         ReferenceSystem(final String name) {
  343.             this.name = name;
  344.         }

  346.         /**
  347.          * Get the name used to define the reference system in SINEX file.
  348.          * @return the name
  349.          */
  350.         public String getName() {
  351.             return name;
  352.         }

  354.         /**
  355.          * Get the eccentricity reference system corresponding to the given value.
  356.          * @param value given value
  357.          * @return the corresponding eccentricity reference system
  358.          */
  359.         public static ReferenceSystem getEccRefSystem(final String value) {
  360.             return CODES_MAP.get(value);
  361.         }

  363.     }

  365. }
Created with JaCoCo 0.8.11.202310140853