CIRFProvider.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.Serializable;

  21. import org.hipparchus.RealFieldElement;
  22. import org.hipparchus.geometry.euclidean.threed.FieldRotation;
  23. import org.hipparchus.geometry.euclidean.threed.FieldVector3D;
  24. import org.hipparchus.geometry.euclidean.threed.Rotation;
  25. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  26. import org.hipparchus.util.FastMath;
  27. import org.orekit.errors.OrekitException;
  28. import org.orekit.errors.OrekitInternalError;
  29. import org.orekit.time.AbsoluteDate;
  30. import org.orekit.time.FieldAbsoluteDate;
  31. import org.orekit.time.TimeVectorFunction;

  33. /** Celestial Intermediate Reference Frame.
  34.  * <p>This provider includes precession effects according to either the IAU 2006 precession
  35.  * (also known as Nicole Capitaines's P03 precession theory) and IAU 2000A_R06 nutation
  36.  * for IERS 2010 conventions or the IAU 2000A precession-nutation model for IERS 2003
  37.  * conventions. These models replaced the older IAU-76 precession (Lieske) and IAU-80
  38.  * theory of nutation (Wahr) which were used in the classical equinox-based paradigm.
  39.  * It <strong>must</strong> be used with the Earth Rotation Angle (REA) defined by
  40.  * Capitaine's model and <strong>not</strong> IAU-82 sidereal
  41.  * time which is consistent with the older models only.</p>
  42.  * <p>Its parent frame is the GCRF frame.
  43.  */
  44. class CIRFProvider implements EOPBasedTransformProvider {

  46.     /** Serializable UID. */
  47.     private static final long serialVersionUID = 20130806L;

  49.     /** Function computing CIP/CIO components. */
  50.     private final transient TimeVectorFunction xysPxy2Function;

  52.     /** EOP history. */
  53.     private final EOPHistory eopHistory;

  55.     /** Simple constructor.
  56.      * @param eopHistory EOP history
  57.      * @exception OrekitException if the nutation model data embedded in the
  58.      * library cannot be read.
  59.      * @see Frame
  60.      */
  61.     CIRFProvider(final EOPHistory eopHistory)
  62.         throws OrekitException {

  64.         // load the nutation model
  65.         xysPxy2Function = eopHistory.getConventions().getXYSpXY2Function();

  67.         // store correction to the model
  68.         this.eopHistory = eopHistory;

  70.     }

  72.     /** {@inheritDoc} */
  73.     @Override
  74.     public EOPHistory getEOPHistory() {
  75.         return eopHistory;
  76.     }

  78.     /** {@inheritDoc} */
  79.     @Override
  80.     public CIRFProvider getNonInterpolatingProvider()
  81.         throws OrekitException {
  82.         return new CIRFProvider(eopHistory.getNonInterpolatingEOPHistory());
  83.     }

  85.     /** {@inheritDoc} */
  86.     @Override
  87.     public Transform getTransform(final AbsoluteDate date) throws OrekitException {

  89.         final double[] xys  = xysPxy2Function.value(date);
  90.         final double[] dxdy = eopHistory.getNonRotatinOriginNutationCorrection(date);

  92.         // position of the Celestial Intermediate Pole (CIP)
  93.         final double xCurrent = xys[0] + dxdy[0];
  94.         final double yCurrent = xys[1] + dxdy[1];

  96.         // position of the Celestial Intermediate Origin (CIO)
  97.         final double sCurrent = xys[2] - xCurrent * yCurrent / 2;

  99.         // set up the bias, precession and nutation rotation
  100.         final double x2Py2  = xCurrent * xCurrent + yCurrent * yCurrent;
  101.         final double zP1    = 1 + FastMath.sqrt(1 - x2Py2);
  102.         final double r      = FastMath.sqrt(x2Py2);
  103.         final double sPe2   = 0.5 * (sCurrent + FastMath.atan2(yCurrent, xCurrent));
  104.         final double cos    = FastMath.cos(sPe2);
  105.         final double sin    = FastMath.sin(sPe2);
  106.         final double xPr    = xCurrent + r;
  107.         final double xPrCos = xPr * cos;
  108.         final double xPrSin = xPr * sin;
  109.         final double yCos   = yCurrent * cos;
  110.         final double ySin   = yCurrent * sin;
  111.         final Rotation bpn  = new Rotation(zP1 * (xPrCos + ySin), -r * (yCos + xPrSin),
  112.                                            r * (xPrCos - ySin), zP1 * (yCos - xPrSin),
  113.                                            true);

  115.         return new Transform(date, bpn, Vector3D.ZERO);

  117.     }

  119.     /** {@inheritDoc} */
  120.     @Override
  121.     public <T extends RealFieldElement<T>> FieldTransform<T> getTransform(final FieldAbsoluteDate<T> date)
  122.         throws OrekitException {

  124.         final T[] xys  = xysPxy2Function.value(date);
  125.         final T[] dxdy = eopHistory.getNonRotatinOriginNutationCorrection(date);

  127.         // position of the Celestial Intermediate Pole (CIP)
  128.         final T xCurrent = xys[0].add(dxdy[0]);
  129.         final T yCurrent = xys[1].add(dxdy[1]);

  131.         // position of the Celestial Intermediate Origin (CIO)
  132.         final T sCurrent = xys[2].subtract(xCurrent.multiply(yCurrent).multiply(0.5));

  134.         // set up the bias, precession and nutation rotation
  135.         final T x2Py2  = xCurrent.multiply(xCurrent).add(yCurrent.multiply(yCurrent));
  136.         final T zP1    = x2Py2.subtract(1).negate().sqrt().add(1);
  137.         final T r      = x2Py2.sqrt();
  138.         final T sPe2   = sCurrent.add(yCurrent.atan2(xCurrent)).multiply(0.5);
  139.         final T cos    = sPe2.cos();
  140.         final T sin    = sPe2.sin();
  141.         final T xPr    = xCurrent.add(r);
  142.         final T xPrCos = xPr.multiply(cos);
  143.         final T xPrSin = xPr.multiply(sin);
  144.         final T yCos   = yCurrent.multiply(cos);
  145.         final T ySin   = yCurrent.multiply(sin);
  146.         final FieldRotation<T> bpn  = new FieldRotation<>(zP1.multiply(xPrCos.add(ySin)),
  147.                                                           r.multiply(yCos.add(xPrSin)).negate(),
  148.                                                           r.multiply(xPrCos.subtract(ySin)),
  149.                                                           zP1.multiply(yCos.subtract(xPrSin)),
  150.                                                           true);

  152.         return new FieldTransform<>(date, bpn, FieldVector3D.getZero(date.getField()));

  154.     }

  156.     /** Replace the instance with a data transfer object for serialization.
  157.      * <p>
  158.      * This intermediate class serializes only the frame key.
  159.      * </p>
  160.      * @return data transfer object that will be serialized
  161.      */
  162.     private Object writeReplace() {
  163.         return new DataTransferObject(eopHistory);
  164.     }

  166.     /** Internal class used only for serialization. */
  167.     private static class DataTransferObject implements Serializable {

  169.         /** Serializable UID. */
  170.         private static final long serialVersionUID = 20131209L;

  172.         /** EOP history. */
  173.         private final EOPHistory eopHistory;

  175.         /** Simple constructor.
  176.          * @param eopHistory EOP history
  177.          */
  178.         DataTransferObject(final EOPHistory eopHistory) {
  179.             this.eopHistory = eopHistory;
  180.         }

  182.         /** Replace the deserialized data transfer object with a {@link CIRFProvider}.
  183.          * @return replacement {@link CIRFProvider}
  184.          */
  185.         private Object readResolve() {
  186.             try {
  187.                 // retrieve a managed frame
  188.                 return new CIRFProvider(eopHistory);
  189.             } catch (OrekitException oe) {
  190.                 throw new OrekitInternalError(oe);
  191.             }
  192.         }

  194.     }

  196. }
Created with JaCoCo 0.7.9.201702052155