CartesianOrbit.java

  1. /* Copyright 2002-2016 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.orbits;

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

  24. import org.apache.commons.math3.exception.ConvergenceException;
  25. import org.apache.commons.math3.geometry.euclidean.threed.Rotation;
  26. import org.apache.commons.math3.geometry.euclidean.threed.RotationConvention;
  27. import org.apache.commons.math3.geometry.euclidean.threed.Vector3D;
  28. import org.apache.commons.math3.util.FastMath;
  29. import org.orekit.errors.OrekitMessages;
  30. import org.orekit.frames.Frame;
  31. import org.orekit.time.AbsoluteDate;
  32. import org.orekit.utils.CartesianDerivativesFilter;
  33. import org.orekit.utils.PVCoordinates;
  34. import org.orekit.utils.TimeStampedPVCoordinates;


  37. /** This class holds cartesian orbital parameters.

  39.  * <p>
  40.  * The parameters used internally are the cartesian coordinates:
  41.  *   <ul>
  42.  *     <li>x</li>
  43.  *     <li>y</li>
  44.  *     <li>z</li>
  45.  *     <li>xDot</li>
  46.  *     <li>yDot</li>
  47.  *     <li>zDot</li>
  48.  *   </ul>
  49.  * contained in {@link PVCoordinates}.
  50.  * </p>

  52.  * <p>
  53.  * Note that the implementation of this class delegates all non-cartesian related
  54.  * computations ({@link #getA()}, {@link #getEquinoctialEx()}, ...) to an underlying
  55.  * instance of the {@link EquinoctialOrbit} class. This implies that using this class
  56.  * only for analytical computations which are always based on non-cartesian
  57.  * parameters is perfectly possible but somewhat sub-optimal.
  58.  * </p>
  59.  * <p>
  60.  * The instance <code>CartesianOrbit</code> is guaranteed to be immutable.
  61.  * </p>
  62.  * @see    Orbit
  63.  * @see    KeplerianOrbit
  64.  * @see    CircularOrbit
  65.  * @see    EquinoctialOrbit
  66.  * @author Luc Maisonobe
  67.  * @author Guylaine Prat
  68.  * @author Fabien Maussion
  69.  * @author V&eacute;ronique Pommier-Maurussane
  70.  */
  71. public class CartesianOrbit extends Orbit {

  73.     /** Serializable UID. */
  74.     private static final long serialVersionUID = 20140723L;

  76.     /** Underlying equinoctial orbit to which high-level methods are delegated. */
  77.     private transient EquinoctialOrbit equinoctial;

  79.     /** Constructor from Cartesian parameters.
  80.      *
  81.      * <p> The acceleration provided in {@code pvCoordinates} is accessible using
  82.      * {@link #getPVCoordinates()} and {@link #getPVCoordinates(Frame)}. All other methods
  83.      * use {@code mu} and the position to compute the acceleration, including
  84.      * {@link #shiftedBy(double)} and {@link #getPVCoordinates(AbsoluteDate, Frame)}.
  85.      *
  86.      * @param pvaCoordinates the position, velocity and acceleration of the satellite.
  87.      * @param frame the frame in which the {@link PVCoordinates} are defined
  88.      * (<em>must</em> be a {@link Frame#isPseudoInertial pseudo-inertial frame})
  89.      * @param mu central attraction coefficient (m³/s²)
  90.      * @exception IllegalArgumentException if frame is not a {@link
  91.      * Frame#isPseudoInertial pseudo-inertial frame}
  92.      */
  93.     public CartesianOrbit(final TimeStampedPVCoordinates pvaCoordinates,
  94.                           final Frame frame, final double mu)
  95.         throws IllegalArgumentException {
  96.         super(pvaCoordinates, frame, mu);
  97.         equinoctial = null;
  98.     }

  100.     /** Constructor from Cartesian parameters.
  101.      *
  102.      * <p> The acceleration provided in {@code pvCoordinates} is accessible using
  103.      * {@link #getPVCoordinates()} and {@link #getPVCoordinates(Frame)}. All other methods
  104.      * use {@code mu} and the position to compute the acceleration, including
  105.      * {@link #shiftedBy(double)} and {@link #getPVCoordinates(AbsoluteDate, Frame)}.
  106.      *
  107.      * @param pvaCoordinates the position and velocity of the satellite.
  108.      * @param frame the frame in which the {@link PVCoordinates} are defined
  109.      * (<em>must</em> be a {@link Frame#isPseudoInertial pseudo-inertial frame})
  110.      * @param date date of the orbital parameters
  111.      * @param mu central attraction coefficient (m³/s²)
  112.      * @exception IllegalArgumentException if frame is not a {@link
  113.      * Frame#isPseudoInertial pseudo-inertial frame}
  114.      */
  115.     public CartesianOrbit(final PVCoordinates pvaCoordinates, final Frame frame,
  116.                           final AbsoluteDate date, final double mu)
  117.         throws IllegalArgumentException {
  118.         this(new TimeStampedPVCoordinates(date, pvaCoordinates), frame, mu);
  119.     }

  121.     /** Constructor from any kind of orbital parameters.
  122.      * @param op orbital parameters to copy
  123.      */
  124.     public CartesianOrbit(final Orbit op) {
  125.         super(op.getPVCoordinates(), op.getFrame(), op.getMu());
  126.         if (op instanceof EquinoctialOrbit) {
  127.             equinoctial = (EquinoctialOrbit) op;
  128.         } else if (op instanceof CartesianOrbit) {
  129.             equinoctial = ((CartesianOrbit) op).equinoctial;
  130.         } else {
  131.             equinoctial = null;
  132.         }
  133.     }

  135.     /** {@inheritDoc} */
  136.     public OrbitType getType() {
  137.         return OrbitType.CARTESIAN;
  138.     }

  140.     /** Lazy evaluation of equinoctial parameters. */
  141.     private void initEquinoctial() {
  142.         if (equinoctial == null) {
  143.             equinoctial = new EquinoctialOrbit(getPVCoordinates(), getFrame(), getDate(), getMu());
  144.         }
  145.     }

  147.     /** {@inheritDoc} */
  148.     public double getA() {
  149.         // lazy evaluation of semi-major axis
  150.         final double r  = getPVCoordinates().getPosition().getNorm();
  151.         final double V2 = getPVCoordinates().getVelocity().getNormSq();
  152.         return r / (2 - r * V2 / getMu());
  153.     }

  155.     /** {@inheritDoc} */
  156.     public double getE() {
  157.         final Vector3D pvP   = getPVCoordinates().getPosition();
  158.         final Vector3D pvV   = getPVCoordinates().getVelocity();
  159.         final double rV2OnMu = pvP.getNorm() * pvV.getNormSq() / getMu();
  160.         final double eSE     = Vector3D.dotProduct(pvP, pvV) / FastMath.sqrt(getMu() * getA());
  161.         final double eCE     = rV2OnMu - 1;
  162.         return FastMath.sqrt(eCE * eCE + eSE * eSE);
  163.     }

  165.     /** {@inheritDoc} */
  166.     public double getI() {
  167.         return Vector3D.angle(Vector3D.PLUS_K, getPVCoordinates().getMomentum());
  168.     }

  170.     /** {@inheritDoc} */
  171.     public double getEquinoctialEx() {
  172.         initEquinoctial();
  173.         return equinoctial.getEquinoctialEx();
  174.     }

  176.     /** {@inheritDoc} */
  177.     public double getEquinoctialEy() {
  178.         initEquinoctial();
  179.         return equinoctial.getEquinoctialEy();
  180.     }

  182.     /** {@inheritDoc} */
  183.     public double getHx() {
  184.         final Vector3D w = getPVCoordinates().getMomentum().normalize();
  185.         // Check for equatorial retrograde orbit
  186.         if (((w.getX() * w.getX() + w.getY() * w.getY()) == 0) && w.getZ() < 0) {
  187.             return Double.NaN;
  188.         }
  189.         return -w.getY() / (1 + w.getZ());
  190.     }

  192.     /** {@inheritDoc} */
  193.     public double getHy() {
  194.         final Vector3D w = getPVCoordinates().getMomentum().normalize();
  195.         // Check for equatorial retrograde orbit
  196.         if (((w.getX() * w.getX() + w.getY() * w.getY()) == 0) && w.getZ() < 0) {
  197.             return Double.NaN;
  198.         }
  199.         return  w.getX() / (1 + w.getZ());
  200.     }

  202.     /** {@inheritDoc} */
  203.     public double getLv() {
  204.         initEquinoctial();
  205.         return equinoctial.getLv();
  206.     }

  208.     /** {@inheritDoc} */
  209.     public double getLE() {
  210.         initEquinoctial();
  211.         return equinoctial.getLE();
  212.     }

  214.     /** {@inheritDoc} */
  215.     public double getLM() {
  216.         initEquinoctial();
  217.         return equinoctial.getLM();
  218.     }

  220.     /** {@inheritDoc} */
  221.     protected TimeStampedPVCoordinates initPVCoordinates() {
  222.         // nothing to do here, as the canonical elements are already the cartesian ones
  223.         return getPVCoordinates();
  224.     }

  226.     /** {@inheritDoc} */
  227.     public CartesianOrbit shiftedBy(final double dt) {
  228.         final PVCoordinates shiftedPV = (getA() < 0) ? shiftPVHyperbolic(dt) : shiftPVElliptic(dt);
  229.         return new CartesianOrbit(shiftedPV, getFrame(), getDate().shiftedBy(dt), getMu());
  230.     }

  232.     /** {@inheritDoc}
  233.      * <p>
  234.      * The interpolated instance is created by polynomial Hermite interpolation
  235.      * ensuring velocity remains the exact derivative of position.
  236.      * </p>
  237.      * <p>
  238.      * As this implementation of interpolation is polynomial, it should be used only
  239.      * with small samples (about 10-20 points) in order to avoid <a
  240.      * href="http://en.wikipedia.org/wiki/Runge%27s_phenomenon">Runge's phenomenon</a>
  241.      * and numerical problems (including NaN appearing).
  242.      * </p>
  243.      * <p>
  244.      * If orbit interpolation on large samples is needed, using the {@link
  245.      * org.orekit.propagation.analytical.Ephemeris} class is a better way than using this
  246.      * low-level interpolation. The Ephemeris class automatically handles selection of
  247.      * a neighboring sub-sample with a predefined number of point from a large global sample
  248.      * in a thread-safe way.
  249.      * </p>
  250.      */
  251.     public CartesianOrbit interpolate(final AbsoluteDate date, final Collection<Orbit> sample) {
  252.         final List<TimeStampedPVCoordinates> datedPV = new ArrayList<TimeStampedPVCoordinates>(sample.size());
  253.         for (final Orbit o : sample) {
  254.             datedPV.add(new TimeStampedPVCoordinates(o.getDate(),
  255.                                                      o.getPVCoordinates().getPosition(),
  256.                                                      o.getPVCoordinates().getVelocity(),
  257.                                                      o.getPVCoordinates().getAcceleration()));
  258.         }
  259.         final TimeStampedPVCoordinates interpolated =
  260.                 TimeStampedPVCoordinates.interpolate(date, CartesianDerivativesFilter.USE_PVA, datedPV);
  261.         return new CartesianOrbit(interpolated, getFrame(), date, getMu());
  262.     }

  264.     /** Compute shifted position and velocity in elliptic case.
  265.      * @param dt time shift
  266.      * @return shifted position and velocity
  267.      */
  268.     private PVCoordinates shiftPVElliptic(final double dt) {

  270.         // preliminary computation
  271.         final Vector3D pvP   = getPVCoordinates().getPosition();
  272.         final Vector3D pvV   = getPVCoordinates().getVelocity();
  273.         final double r       = pvP.getNorm();
  274.         final double rV2OnMu = r * pvV.getNormSq() / getMu();
  275.         final double a       = getA();
  276.         final double eSE     = Vector3D.dotProduct(pvP, pvV) / FastMath.sqrt(getMu() * a);
  277.         final double eCE     = rV2OnMu - 1;
  278.         final double e2      = eCE * eCE + eSE * eSE;

  280.         // we can use any arbitrary reference 2D frame in the orbital plane
  281.         // in order to simplify some equations below, we use the current position as the u axis
  282.         final Vector3D u     = pvP.normalize();
  283.         final Vector3D v     = Vector3D.crossProduct(getPVCoordinates().getMomentum(), u).normalize();

  285.         // the following equations rely on the specific choice of u explained above,
  286.         // some coefficients that vanish to 0 in this case have already been removed here
  287.         final double ex      = (eCE - e2) * a / r;
  288.         final double ey      = -FastMath.sqrt(1 - e2) * eSE * a / r;
  289.         final double beta    = 1 / (1 + FastMath.sqrt(1 - e2));
  290.         final double thetaE0 = FastMath.atan2(ey + eSE * beta * ex, r / a + ex - eSE * beta * ey);
  291.         final double thetaM0 = thetaE0 - ex * FastMath.sin(thetaE0) + ey * FastMath.cos(thetaE0);

  293.         // compute in-plane shifted eccentric argument
  294.         final double thetaM1 = thetaM0 + getKeplerianMeanMotion() * dt;
  295.         final double thetaE1 = meanToEccentric(thetaM1, ex, ey);
  296.         final double cTE     = FastMath.cos(thetaE1);
  297.         final double sTE     = FastMath.sin(thetaE1);

  299.         // compute shifted in-plane cartesian coordinates
  300.         final double exey   = ex * ey;
  301.         final double exCeyS = ex * cTE + ey * sTE;
  302.         final double x      = a * ((1 - beta * ey * ey) * cTE + beta * exey * sTE - ex);
  303.         final double y      = a * ((1 - beta * ex * ex) * sTE + beta * exey * cTE - ey);
  304.         final double factor = FastMath.sqrt(getMu() / a) / (1 - exCeyS);
  305.         final double xDot   = factor * (-sTE + beta * ey * exCeyS);
  306.         final double yDot   = factor * ( cTE - beta * ex * exCeyS);

  308.         final Vector3D shiftedP = new Vector3D(x, u, y, v);
  309.         final double   r2       = x * x + y * y;
  310.         final Vector3D shiftedV = new Vector3D(xDot, u, yDot, v);
  311.         final Vector3D shiftedA = new Vector3D(-getMu() / (r2 * FastMath.sqrt(r2)), shiftedP);
  312.         return new PVCoordinates(shiftedP, shiftedV, shiftedA);

  314.     }

  316.     /** Compute shifted position and velocity in hyperbolic case.
  317.      * @param dt time shift
  318.      * @return shifted position and velocity
  319.      */
  320.     private PVCoordinates shiftPVHyperbolic(final double dt) {

  322.         final PVCoordinates pv = getPVCoordinates();
  323.         final Vector3D pvP   = pv.getPosition();
  324.         final Vector3D pvV   = pv.getVelocity();
  325.         final Vector3D pvM   = pv.getMomentum();
  326.         final double r       = pvP.getNorm();
  327.         final double rV2OnMu = r * pvV.getNormSq() / getMu();
  328.         final double a       = getA();
  329.         final double muA     = getMu() * a;
  330.         final double e       = FastMath.sqrt(1 - Vector3D.dotProduct(pvM, pvM) / muA);
  331.         final double sqrt    = FastMath.sqrt((e + 1) / (e - 1));

  333.         // compute mean anomaly
  334.         final double eSH     = Vector3D.dotProduct(pvP, pvV) / FastMath.sqrt(-muA);
  335.         final double eCH     = rV2OnMu - 1;
  336.         final double H0      = FastMath.log((eCH + eSH) / (eCH - eSH)) / 2;
  337.         final double M0      = e * FastMath.sinh(H0) - H0;

  339.         // find canonical 2D frame with p pointing to perigee
  340.         final double v0      = 2 * FastMath.atan(sqrt * FastMath.tanh(H0 / 2));
  341.         final Vector3D p     = new Rotation(pvM, v0, RotationConvention.FRAME_TRANSFORM).applyTo(pvP).normalize();
  342.         final Vector3D q     = Vector3D.crossProduct(pvM, p).normalize();

  344.         // compute shifted eccentric anomaly
  345.         final double M1      = M0 + getKeplerianMeanMotion() * dt;
  346.         final double H1      = meanToHyperbolicEccentric(M1, e);

  348.         // compute shifted in-plane cartesian coordinates
  349.         final double cH     = FastMath.cosh(H1);
  350.         final double sH     = FastMath.sinh(H1);
  351.         final double sE2m1  = FastMath.sqrt((e - 1) * (e + 1));

  353.         // coordinates of position and velocity in the orbital plane
  354.         final double x      = a * (cH - e);
  355.         final double y      = -a * sE2m1 * sH;
  356.         final double factor = FastMath.sqrt(getMu() / -a) / (e * cH - 1);
  357.         final double xDot   = -factor * sH;
  358.         final double yDot   =  factor * sE2m1 * cH;

  360.         final Vector3D shiftedP = new Vector3D(x, p, y, q);
  361.         final double   r2       = x * x + y * y;
  362.         final Vector3D shiftedV = new Vector3D(xDot, p, yDot, q);
  363.         final Vector3D shiftedA = new Vector3D(-getMu() / (r2 * FastMath.sqrt(r2)), shiftedP);
  364.         return new PVCoordinates(shiftedP, shiftedV, shiftedA);

  366.     }

  368.     /** Computes the eccentric in-plane argument from the mean in-plane argument.
  369.      * @param thetaM = mean in-plane argument (rad)
  370.      * @param ex first component of eccentricity vector
  371.      * @param ey second component of eccentricity vector
  372.      * @return the eccentric in-plane argument.
  373.      */
  374.     private double meanToEccentric(final double thetaM, final double ex, final double ey) {
  375.         // Generalization of Kepler equation to in-plane parameters
  376.         // with thetaE = eta + E and
  377.         //      thetaM = eta + M = thetaE - ex.sin(thetaE) + ey.cos(thetaE)
  378.         // and eta being counted from an arbitrary reference in the orbital plane
  379.         double thetaE        = thetaM;
  380.         double thetaEMthetaM = 0.0;
  381.         int    iter          = 0;
  382.         do {
  383.             final double cosThetaE = FastMath.cos(thetaE);
  384.             final double sinThetaE = FastMath.sin(thetaE);

  386.             final double f2 = ex * sinThetaE - ey * cosThetaE;
  387.             final double f1 = 1.0 - ex * cosThetaE - ey * sinThetaE;
  388.             final double f0 = thetaEMthetaM - f2;

  390.             final double f12 = 2.0 * f1;
  391.             final double shift = f0 * f12 / (f1 * f12 - f0 * f2);

  393.             thetaEMthetaM -= shift;
  394.             thetaE         = thetaM + thetaEMthetaM;

  396.             if (FastMath.abs(shift) <= 1.0e-12) {
  397.                 return thetaE;
  398.             }

  400.         } while (++iter < 50);

  402.         throw new ConvergenceException();

  404.     }

  406.     /** Computes the hyperbolic eccentric anomaly from the mean anomaly.
  407.      * <p>
  408.      * The algorithm used here for solving hyperbolic Kepler equation is
  409.      * Danby's iterative method (3rd order) with Vallado's initial guess.
  410.      * </p>
  411.      * @param M mean anomaly (rad)
  412.      * @param ecc eccentricity
  413.      * @return the hyperbolic eccentric anomaly
  414.      */
  415.     private double meanToHyperbolicEccentric(final double M, final double ecc) {

  417.         // Resolution of hyperbolic Kepler equation for keplerian parameters

  419.         // Initial guess
  420.         double H;
  421.         if (ecc < 1.6) {
  422.             if ((-FastMath.PI < M && M < 0.) || M > FastMath.PI) {
  423.                 H = M - ecc;
  424.             } else {
  425.                 H = M + ecc;
  426.             }
  427.         } else {
  428.             if (ecc < 3.6 && FastMath.abs(M) > FastMath.PI) {
  429.                 H = M - FastMath.copySign(ecc, M);
  430.             } else {
  431.                 H = M / (ecc - 1.);
  432.             }
  433.         }

  435.         // Iterative computation
  436.         int iter = 0;
  437.         do {
  438.             final double f3  = ecc * FastMath.cosh(H);
  439.             final double f2  = ecc * FastMath.sinh(H);
  440.             final double f1  = f3 - 1.;
  441.             final double f0  = f2 - H - M;
  442.             final double f12 = 2. * f1;
  443.             final double d   = f0 / f12;
  444.             final double fdf = f1 - d * f2;
  445.             final double ds  = f0 / fdf;

  447.             final double shift = f0 / (fdf + ds * ds * f3 / 6.);

  449.             H -= shift;

  451.             if (FastMath.abs(shift) <= 1.0e-12) {
  452.                 return H;
  453.             }

  455.         } while (++iter < 50);

  457.         throw new ConvergenceException(OrekitMessages.UNABLE_TO_COMPUTE_HYPERBOLIC_ECCENTRIC_ANOMALY,
  458.                                        iter);
  459.     }

  461.     @Override
  462.     public void getJacobianWrtCartesian(final PositionAngle type, final double[][] jacobian) {
  463.         // this is the fastest way to set the 6x6 identity matrix
  464.         for (int i = 0; i < 6; i++) {
  465.             for (int j = 0; j < 6; j++) {
  466.                 jacobian[i][j] = 0;
  467.             }
  468.             jacobian[i][i] = 1;
  469.         }
  470.     }

  472.     @Override
  473.     protected double[][] computeJacobianMeanWrtCartesian() {
  474.         // not used
  475.         return null;
  476.     }
  477.     @Override
  478.     protected double[][] computeJacobianEccentricWrtCartesian() {
  479.         // not used
  480.         return null;
  481.     }

  483.     @Override
  484.     protected double[][] computeJacobianTrueWrtCartesian() {
  485.         // not used
  486.         return null;
  487.     }

  489.     /** {@inheritDoc} */
  490.     public void addKeplerContribution(final PositionAngle type, final double gm,
  491.                                       final double[] pDot) {

  493.         final PVCoordinates pv = getPVCoordinates();

  495.         // position derivative is velocity
  496.         final Vector3D velocity = pv.getVelocity();
  497.         pDot[0] += velocity.getX();
  498.         pDot[1] += velocity.getY();
  499.         pDot[2] += velocity.getZ();

  501.         // velocity derivative is Newtonian acceleration
  502.         final Vector3D position = pv.getPosition();
  503.         final double r2         = position.getNormSq();
  504.         final double coeff      = -gm / (r2 * FastMath.sqrt(r2));
  505.         pDot[3] += coeff * position.getX();
  506.         pDot[4] += coeff * position.getY();
  507.         pDot[5] += coeff * position.getZ();

  509.     }

  511.     /**  Returns a string representation of this Orbit object.
  512.      * @return a string representation of this object
  513.      */
  514.     public String toString() {
  515.         return "cartesian parameters: " + getPVCoordinates().toString();
  516.     }

  518.     /** Replace the instance with a data transfer object for serialization.
  519.      * <p>
  520.      * This intermediate class serializes all needed parameters,
  521.      * including position-velocity which are <em>not</em> serialized by parent
  522.      * {@link Orbit} class.
  523.      * </p>
  524.      * @return data transfer object that will be serialized
  525.      */
  526.     private Object writeReplace() {
  527.         return new DTO(this);
  528.     }

  530.     /** Internal class used only for serialization. */
  531.     private static class DTO implements Serializable {

  533.         /** Serializable UID. */
  534.         private static final long serialVersionUID = 20140723L;

  536.         /** Double values. */
  537.         private double[] d;

  539.         /** Frame in which are defined the orbital parameters. */
  540.         private final Frame frame;

  542.         /** Simple constructor.
  543.          * @param orbit instance to serialize
  544.          */
  545.         private DTO(final CartesianOrbit orbit) {

  547.             final TimeStampedPVCoordinates pv = orbit.getPVCoordinates();

  549.             // decompose date
  550.             final double epoch  = FastMath.floor(pv.getDate().durationFrom(AbsoluteDate.J2000_EPOCH));
  551.             final double offset = pv.getDate().durationFrom(AbsoluteDate.J2000_EPOCH.shiftedBy(epoch));

  553.             this.d = new double[] {
  554.                 epoch, offset, orbit.getMu(),
  555.                 pv.getPosition().getX(),     pv.getPosition().getY(),     pv.getPosition().getZ(),
  556.                 pv.getVelocity().getX(),     pv.getVelocity().getY(),     pv.getVelocity().getZ(),
  557.                 pv.getAcceleration().getX(), pv.getAcceleration().getY(), pv.getAcceleration().getZ(),
  558.             };

  560.             this.frame = orbit.getFrame();

  562.         }

  564.         /** Replace the deserialized data transfer object with a {@link CartesianOrbit}.
  565.          * @return replacement {@link CartesianOrbit}
  566.          */
  567.         private Object readResolve() {
  568.             return new CartesianOrbit(new TimeStampedPVCoordinates(AbsoluteDate.J2000_EPOCH.shiftedBy(d[0]).shiftedBy(d[1]),
  569.                                                                    new Vector3D(d[3], d[ 4], d[ 5]),
  570.                                                                    new Vector3D(d[6], d[ 7], d[ 8]),
  571.                                                                    new Vector3D(d[9], d[10], d[11])),
  572.                                       frame, d[2]);
  573.         }

  575.     }

  577. }
Created with JaCoCo 0.7.4.201502262128