UTCScale.java

  1. /* Copyright 2002-2020 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.time;

  19. import java.io.Serializable;
  20. import java.util.ArrayList;
  21. import java.util.Collection;
  22. import java.util.Comparator;
  23. import java.util.List;

  25. import org.hipparchus.RealFieldElement;
  26. import org.hipparchus.util.FastMath;
  27. import org.orekit.annotation.DefaultDataContext;
  28. import org.orekit.data.DataContext;
  29. import org.orekit.errors.OrekitException;
  30. import org.orekit.errors.OrekitInternalError;
  31. import org.orekit.utils.Constants;

  33. /** Coordinated Universal Time.
  34.  * <p>UTC is related to TAI using step adjustments from time to time
  35.  * according to IERS (International Earth Rotation Service) rules. Before 1972,
  36.  * these adjustments were piecewise linear offsets. Since 1972, these adjustments
  37.  * are piecewise constant offsets, which require introduction of leap seconds.</p>
  38.  * <p>Leap seconds are always inserted as additional seconds at the last minute
  39.  * of the day, pushing the next day forward. Such minutes are therefore more
  40.  * than 60 seconds long. In theory, there may be seconds removal instead of seconds
  41.  * insertion, but up to now (2010) it has never been used. As an example, when a
  42.  * one second leap was introduced at the end of 2005, the UTC time sequence was
  43.  * 2005-12-31T23:59:59 UTC, followed by 2005-12-31T23:59:60 UTC, followed by
  44.  * 2006-01-01T00:00:00 UTC.</p>
  45.  * <p>This is intended to be accessed thanks to {@link TimeScales},
  46.  * so there is no public constructor.</p>
  47.  * @author Luc Maisonobe
  48.  * @see AbsoluteDate
  49.  */
  50. public class UTCScale implements TimeScale {

  52.     /** Serializable UID. */
  53.     private static final long serialVersionUID = 20150402L;

  55.     /** UTC-TAI offsets. */
  56.     private UTCTAIOffset[] offsets;

  58.     /** Package private constructor for the factory.
  59.      * Used to create the prototype instance of this class that is used to
  60.      * clone all subsequent instances of {@link UTCScale}. Initializes the offset
  61.      * table that is shared among all instances.
  62.      * @param tai TAI time scale this UTC time scale references.
  63.      * @param offsets UTC-TAI offsets
  64.      */
  65.     UTCScale(final TimeScale tai, final Collection<? extends OffsetModel> offsets) {
  66.         // copy input so the original list is unmodified
  67.         final List<OffsetModel> offsetModels = new ArrayList<>(offsets);
  68.         offsetModels.sort(Comparator.comparing(OffsetModel::getStart));
  69.         if (offsetModels.get(0).getStart().getYear() > 1968) {
  70.             // the pre-1972 linear offsets are missing, add them manually
  71.             // excerpt from UTC-TAI.history file:
  72.             //  1961  Jan.  1 - 1961  Aug.  1     1.422 818 0s + (MJD - 37 300) x 0.001 296s
  73.             //        Aug.  1 - 1962  Jan.  1     1.372 818 0s +        ""
  74.             //  1962  Jan.  1 - 1963  Nov.  1     1.845 858 0s + (MJD - 37 665) x 0.001 123 2s
  75.             //  1963  Nov.  1 - 1964  Jan.  1     1.945 858 0s +        ""
  76.             //  1964  Jan.  1 -       April 1     3.240 130 0s + (MJD - 38 761) x 0.001 296s
  77.             //        April 1 -       Sept. 1     3.340 130 0s +        ""
  78.             //        Sept. 1 - 1965  Jan.  1     3.440 130 0s +        ""
  79.             //  1965  Jan.  1 -       March 1     3.540 130 0s +        ""
  80.             //        March 1 -       Jul.  1     3.640 130 0s +        ""
  81.             //        Jul.  1 -       Sept. 1     3.740 130 0s +        ""
  82.             //        Sept. 1 - 1966  Jan.  1     3.840 130 0s +        ""
  83.             //  1966  Jan.  1 - 1968  Feb.  1     4.313 170 0s + (MJD - 39 126) x 0.002 592s
  84.             //  1968  Feb.  1 - 1972  Jan.  1     4.213 170 0s +        ""
  85.             offsetModels.add( 0, new OffsetModel(new DateComponents(1961,  1, 1), 37300, 1.4228180, 0.0012960));
  86.             offsetModels.add( 1, new OffsetModel(new DateComponents(1961,  8, 1), 37300, 1.3728180, 0.0012960));
  87.             offsetModels.add( 2, new OffsetModel(new DateComponents(1962,  1, 1), 37665, 1.8458580, 0.0011232));
  88.             offsetModels.add( 3, new OffsetModel(new DateComponents(1963, 11, 1), 37665, 1.9458580, 0.0011232));
  89.             offsetModels.add( 4, new OffsetModel(new DateComponents(1964,  1, 1), 38761, 3.2401300, 0.0012960));
  90.             offsetModels.add( 5, new OffsetModel(new DateComponents(1964,  4, 1), 38761, 3.3401300, 0.0012960));
  91.             offsetModels.add( 6, new OffsetModel(new DateComponents(1964,  9, 1), 38761, 3.4401300, 0.0012960));
  92.             offsetModels.add( 7, new OffsetModel(new DateComponents(1965,  1, 1), 38761, 3.5401300, 0.0012960));
  93.             offsetModels.add( 8, new OffsetModel(new DateComponents(1965,  3, 1), 38761, 3.6401300, 0.0012960));
  94.             offsetModels.add( 9, new OffsetModel(new DateComponents(1965,  7, 1), 38761, 3.7401300, 0.0012960));
  95.             offsetModels.add(10, new OffsetModel(new DateComponents(1965,  9, 1), 38761, 3.8401300, 0.0012960));
  96.             offsetModels.add(11, new OffsetModel(new DateComponents(1966,  1, 1), 39126, 4.3131700, 0.0025920));
  97.             offsetModels.add(12, new OffsetModel(new DateComponents(1968,  2, 1), 39126, 4.2131700, 0.0025920));
  98.         }

  100.         // create cache
  101.         this.offsets = new UTCTAIOffset[offsetModels.size()];

  103.         UTCTAIOffset previous = null;

  105.         // link the offsets together
  106.         for (int i = 0; i < offsetModels.size(); ++i) {

  108.             final OffsetModel    o      = offsetModels.get(i);
  109.             final DateComponents date   = o.getStart();
  110.             final int            mjdRef = o.getMJDRef();
  111.             final double         offset = o.getOffset();
  112.             final double         slope  = o.getSlope();

  114.             // start of the leap
  115.             final double previousOffset    = (previous == null) ? 0.0 : previous.getOffset(date, TimeComponents.H00);
  116.             final AbsoluteDate leapStart   = new AbsoluteDate(date, tai).shiftedBy(previousOffset);

  118.             // end of the leap
  119.             final double startOffset       = offset + slope * (date.getMJD() - mjdRef);
  120.             final AbsoluteDate leapEnd     = new AbsoluteDate(date, tai).shiftedBy(startOffset);

  122.             // leap computed at leap start and in UTC scale
  123.             final double normalizedSlope   = slope / Constants.JULIAN_DAY;
  124.             final double leap              = leapEnd.durationFrom(leapStart) / (1 + normalizedSlope);

  126.             final AbsoluteDate reference = AbsoluteDate.createMJDDate(mjdRef, 0, tai)
  127.                     .shiftedBy(offset);
  128.             previous = new UTCTAIOffset(leapStart, date.getMJD(), leap, offset, mjdRef,
  129.                     normalizedSlope, reference);
  130.             this.offsets[i] = previous;

  132.         }

  134.     }

  136.     /** {@inheritDoc} */
  137.     @Override
  138.     public double offsetFromTAI(final AbsoluteDate date) {
  139.         final int offsetIndex = findOffsetIndex(date);
  140.         if (offsetIndex < 0) {
  141.             // the date is before the first known leap
  142.             return 0;
  143.         } else {
  144.             return -offsets[offsetIndex].getOffset(date);
  145.         }
  146.     }

  148.     /** {@inheritDoc} */
  149.     @Override
  150.     public <T extends RealFieldElement<T>> T offsetFromTAI(final FieldAbsoluteDate<T> date) {
  151.         final int offsetIndex = findOffsetIndex(date.toAbsoluteDate());
  152.         if (offsetIndex < 0) {
  153.             // the date is before the first known leap
  154.             return date.getField().getZero();
  155.         } else {
  156.             return offsets[offsetIndex].getOffset(date).negate();
  157.         }
  158.     }

  160.     /** {@inheritDoc} */
  161.     @Override
  162.     public double offsetToTAI(final DateComponents date,
  163.                               final TimeComponents time) {

  165.         // take offset from local time into account, but ignoring seconds,
  166.         // so when we parse an hour like 23:59:60.5 during leap seconds introduction,
  167.         // we do not jump to next day
  168.         final int minuteInDay = time.getHour() * 60 + time.getMinute() - time.getMinutesFromUTC();
  169.         final int correction  = minuteInDay < 0 ? (minuteInDay - 1439) / 1440 : minuteInDay / 1440;

  171.         // find close neighbors, assuming date in TAI, i.e a date earlier than real UTC date
  172.         final int mjd = date.getMJD() + correction;
  173.         final UTCTAIOffset offset = findOffset(mjd);
  174.         if (offset == null) {
  175.             // the date is before the first known leap
  176.             return 0;
  177.         } else {
  178.             return offset.getOffset(date, time);
  179.         }

  181.     }

  183.     /** {@inheritDoc} */
  184.     public String getName() {
  185.         return "UTC";
  186.     }

  188.     /** {@inheritDoc} */
  189.     public String toString() {
  190.         return getName();
  191.     }

  193.     /** Get the date of the first known leap second.
  194.      * @return date of the first known leap second
  195.      */
  196.     public AbsoluteDate getFirstKnownLeapSecond() {
  197.         return offsets[0].getDate();
  198.     }

  200.     /** Get the date of the last known leap second.
  201.      * @return date of the last known leap second
  202.      */
  203.     public AbsoluteDate getLastKnownLeapSecond() {
  204.         return offsets[offsets.length - 1].getDate();
  205.     }

  207.     /** {@inheritDoc} */
  208.     @Override
  209.     public boolean insideLeap(final AbsoluteDate date) {
  210.         final int offsetIndex = findOffsetIndex(date);
  211.         if (offsetIndex < 0) {
  212.             // the date is before the first known leap
  213.             return false;
  214.         } else {
  215.             return date.compareTo(offsets[offsetIndex].getValidityStart()) < 0;
  216.         }
  217.     }

  219.     /** {@inheritDoc} */
  220.     @Override
  221.     public <T extends RealFieldElement<T>> boolean insideLeap(final FieldAbsoluteDate<T> date) {
  222.         return insideLeap(date.toAbsoluteDate());
  223.     }

  225.     /** {@inheritDoc} */
  226.     @Override
  227.     public int minuteDuration(final AbsoluteDate date) {
  228.         final int offsetIndex = findOffsetIndex(date);
  229.         final UTCTAIOffset offset;
  230.         if (offsetIndex >= 0 &&
  231.                 date.compareTo(offsets[offsetIndex].getValidityStart()) < 0) {
  232.             // the date is during the leap itself
  233.             offset = offsets[offsetIndex];
  234.         } else if (offsetIndex + 1 < offsets.length &&
  235.             offsets[offsetIndex + 1].getDate().durationFrom(date) <= 60.0) {
  236.             // the date is after a leap, but it may be just before the next one
  237.             // the next leap will start in one minute, it will extend the current minute
  238.             offset = offsets[offsetIndex + 1];
  239.         } else {
  240.             offset = null;
  241.         }
  242.         if (offset != null) {
  243.             // since this method returns an int we can't return the precise duration in
  244.             // all cases, but we can bound it. Some leaps are more than 1s. See #694
  245.             return 60 + (int) FastMath.ceil(offset.getLeap());
  246.         }
  247.         // no leap is expected within the next minute
  248.         return 60;
  249.     }

  251.     /** {@inheritDoc} */
  252.     @Override
  253.     public <T extends RealFieldElement<T>> int minuteDuration(final FieldAbsoluteDate<T> date) {
  254.         return minuteDuration(date.toAbsoluteDate());
  255.     }

  257.     /** {@inheritDoc} */
  258.     @Override
  259.     public double getLeap(final AbsoluteDate date) {
  260.         final int offsetIndex = findOffsetIndex(date);
  261.         if (offsetIndex < 0) {
  262.             // the date is before the first known leap
  263.             return 0;
  264.         } else {
  265.             return offsets[offsetIndex].getLeap();
  266.         }
  267.     }

  269.     /** {@inheritDoc} */
  270.     @Override
  271.     public <T extends RealFieldElement<T>> T getLeap(final FieldAbsoluteDate<T> date) {
  272.         return date.getField().getZero().add(getLeap(date.toAbsoluteDate()));
  273.     }

  275.     /** Find the index of the offset valid at some date.
  276.      * @param date date at which offset is requested
  277.      * @return index of the offset valid at this date, or -1 if date is before first offset.
  278.      */
  279.     private int findOffsetIndex(final AbsoluteDate date) {
  280.         int inf = 0;
  281.         int sup = offsets.length;
  282.         while (sup - inf > 1) {
  283.             final int middle = (inf + sup) >>> 1;
  284.             if (date.compareTo(offsets[middle].getDate()) < 0) {
  285.                 sup = middle;
  286.             } else {
  287.                 inf = middle;
  288.             }
  289.         }
  290.         if (sup == offsets.length) {
  291.             // the date is after the last known leap second
  292.             return offsets.length - 1;
  293.         } else if (date.compareTo(offsets[inf].getDate()) < 0) {
  294.             // the date is before the first known leap
  295.             return -1;
  296.         } else {
  297.             return inf;
  298.         }
  299.     }

  301.     /** Find the offset valid at some date.
  302.      * @param mjd Modified Julian Day of the date at which offset is requested
  303.      * @return offset valid at this date, or null if date is before first offset.
  304.      */
  305.     private UTCTAIOffset findOffset(final int mjd) {
  306.         int inf = 0;
  307.         int sup = offsets.length;
  308.         while (sup - inf > 1) {
  309.             final int middle = (inf + sup) >>> 1;
  310.             if (mjd < offsets[middle].getMJD()) {
  311.                 sup = middle;
  312.             } else {
  313.                 inf = middle;
  314.             }
  315.         }
  316.         if (sup == offsets.length) {
  317.             // the date is after the last known leap second
  318.             return offsets[offsets.length - 1];
  319.         } else if (mjd < offsets[inf].getMJD()) {
  320.             // the date is before the first known leap
  321.             return null;
  322.         } else {
  323.             return offsets[inf];
  324.         }
  325.     }

  327.     /** Replace the instance with a data transfer object for serialization.
  328.      * @return data transfer object that will be serialized
  329.      */
  330.     @DefaultDataContext
  331.     private Object writeReplace() {
  332.         return new DataTransferObject();
  333.     }

  335.     /** Internal class used only for serialization. */
  336.     @DefaultDataContext
  337.     private static class DataTransferObject implements Serializable {

  339.         /** Serializable UID. */
  340.         private static final long serialVersionUID = 20131209L;

  342.         /** Replace the deserialized data transfer object with a {@link UTCScale}.
  343.          * @return replacement {@link UTCScale}
  344.          */
  345.         private Object readResolve() {
  346.             try {
  347.                 return DataContext.getDefault().getTimeScales().getUTC();
  348.             } catch (OrekitException oe) {
  349.                 throw new OrekitInternalError(oe);
  350.             }
  351.         }

  353.     }

  355. }
Created with JaCoCo 0.8.6.202009150832