BodyCenterPointing.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.attitudes;

  19. import org.hipparchus.RealFieldElement;
  20. import org.hipparchus.geometry.euclidean.threed.FieldVector3D;
  21. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  22. import org.hipparchus.util.FastMath;
  23. import org.hipparchus.util.MathArrays;
  24. import org.orekit.bodies.Ellipsoid;
  25. import org.orekit.errors.OrekitException;
  26. import org.orekit.frames.Frame;
  27. import org.orekit.time.AbsoluteDate;
  28. import org.orekit.time.FieldAbsoluteDate;
  29. import org.orekit.utils.FieldPVCoordinatesProvider;
  30. import org.orekit.utils.PVCoordinatesProvider;
  31. import org.orekit.utils.TimeStampedFieldPVCoordinates;
  32. import org.orekit.utils.TimeStampedPVCoordinates;

  34. /**
  35.  * This class handles body center pointing attitude provider.

  37.  * <p>
  38.  * This class represents the attitude provider where the satellite z axis is
  39.  * pointing to the body frame center.</p>
  40.  * <p>
  41.  * The object <code>BodyCenterPointing</code> is guaranteed to be immutable.
  42.  * </p>
  43.  * @see     GroundPointing
  44.  * @author V&eacute;ronique Pommier-Maurussane
  45.  */
  46. public class BodyCenterPointing extends GroundPointing {

  48.     /** Serializable UID. */
  49.     private static final long serialVersionUID = 20150529L;

  51.     /** Body ellipsoid.  */
  52.     private final Ellipsoid ellipsoid;

  54.     /** Creates new instance.
  55.      * @param inertialFrame frame in which orbital velocities are computed
  56.      * @param shape Body shape
  57.      * @exception OrekitException if the frame specified is not a pseudo-inertial frame
  58.      * @since 7.1
  59.      */
  60.     public BodyCenterPointing(final Frame inertialFrame, final Ellipsoid shape)
  61.         throws OrekitException {
  62.         super(inertialFrame, shape.getFrame());
  63.         this.ellipsoid = shape;
  64.     }

  66.     /** {@inheritDoc} */
  67.     @Override
  68.     public TimeStampedPVCoordinates getTargetPV(final PVCoordinatesProvider pvProv,
  69.                                                 final AbsoluteDate date, final Frame frame)
  70.         throws OrekitException {

  72.         // spacecraft coordinates in body frame
  73.         final TimeStampedPVCoordinates scInBodyFrame = pvProv.getPVCoordinates(date, getBodyFrame());

  75.         // central projection to ground (NOT the classical nadir point)
  76.         final double u     = scInBodyFrame.getPosition().getX() / ellipsoid.getA();
  77.         final double v     = scInBodyFrame.getPosition().getY() / ellipsoid.getB();
  78.         final double w     = scInBodyFrame.getPosition().getZ() / ellipsoid.getC();
  79.         final double d2    = u * u + v * v + w * w;
  80.         final double d     = FastMath.sqrt(d2);
  81.         final double ratio = 1.0 / d;
  82.         final Vector3D projectedP = new Vector3D(ratio, scInBodyFrame.getPosition());

  84.         // velocity
  85.         final double uDot     = scInBodyFrame.getVelocity().getX() / ellipsoid.getA();
  86.         final double vDot     = scInBodyFrame.getVelocity().getY() / ellipsoid.getB();
  87.         final double wDot     = scInBodyFrame.getVelocity().getZ() / ellipsoid.getC();
  88.         final double dDot     = MathArrays.linearCombination(u, uDot, v, vDot, w, wDot) / d;
  89.         final double ratioDot = -dDot / d2;
  90.         final Vector3D projectedV = new Vector3D(ratio,    scInBodyFrame.getVelocity(),
  91.                                                  ratioDot, scInBodyFrame.getPosition());

  93.         // acceleration
  94.         final double uDotDot      = scInBodyFrame.getAcceleration().getX() / ellipsoid.getA();
  95.         final double vDotDot      = scInBodyFrame.getAcceleration().getY() / ellipsoid.getB();
  96.         final double wDotDot      = scInBodyFrame.getAcceleration().getZ() / ellipsoid.getC();
  97.         final double dDotDot      = (MathArrays.linearCombination(u, uDotDot, v, vDotDot, w, wDotDot) +
  98.                                      uDot * uDot + vDot * vDot + wDot * wDot - dDot * dDot) / d;
  99.         final double ratioDotDot  = (2 * dDot * dDot - d * dDotDot) / (d * d2);
  100.         final Vector3D projectedA = new Vector3D(ratio,        scInBodyFrame.getAcceleration(),
  101.                                                  2 * ratioDot, scInBodyFrame.getVelocity(),
  102.                                                  ratioDotDot,  scInBodyFrame.getPosition());

  104.         final TimeStampedPVCoordinates projected =
  105.                 new TimeStampedPVCoordinates(date, projectedP, projectedV, projectedA);
  106.         return getBodyFrame().getTransformTo(frame, date).transformPVCoordinates(projected);

  108.     }

  110.     /** {@inheritDoc} */
  111.     public <T extends RealFieldElement<T>> TimeStampedFieldPVCoordinates<T> getTargetPV(final FieldPVCoordinatesProvider<T> pvProv,
  112.                                                                                         final FieldAbsoluteDate<T> date, final Frame frame)
  113.         throws OrekitException {

  115.         // spacecraft coordinates in body frame
  116.         final TimeStampedFieldPVCoordinates<T> scInBodyFrame = pvProv.getPVCoordinates(date, getBodyFrame());

  118.         // central projection to ground (NOT the classical nadir point)
  119.         final T u     = scInBodyFrame.getPosition().getX().divide(ellipsoid.getA());
  120.         final T v     = scInBodyFrame.getPosition().getY().divide(ellipsoid.getB());
  121.         final T w     = scInBodyFrame.getPosition().getZ().divide(ellipsoid.getC());
  122.         final T d2    = u.pow(2).add(v.pow(2)).add(w.pow(2));
  123.         final T d     = d2.sqrt();
  124.         final T ratio = d.reciprocal();
  125.         final FieldVector3D<T> projectedP = new FieldVector3D<>(ratio, scInBodyFrame.getPosition());

  127.         // velocity
  128.         final T uDot     = scInBodyFrame.getVelocity().getX().divide(ellipsoid.getA());
  129.         final T vDot     = scInBodyFrame.getVelocity().getY().divide(ellipsoid.getB());
  130.         final T wDot     = scInBodyFrame.getVelocity().getZ().divide(ellipsoid.getC());
  131.         //we aren't using the linearCombination in the library
  132.         final T dDot     = (u.multiply(uDot).add(v.multiply(vDot)).add(w.multiply(wDot))).divide(d);
  133.         final T ratioDot = dDot.multiply(-1).divide(d2);
  134.         final FieldVector3D<T> projectedV = new FieldVector3D<>(ratio,    scInBodyFrame.getVelocity(),
  135.                                                                 ratioDot, scInBodyFrame.getPosition());

  137.         // acceleration
  138.         final T uDotDot      = scInBodyFrame.getAcceleration().getX().divide(ellipsoid.getA());
  139.         final T vDotDot      = scInBodyFrame.getAcceleration().getY().divide(ellipsoid.getB());
  140.         final T wDotDot      = scInBodyFrame.getAcceleration().getZ().divide(ellipsoid.getC());
  141.         final T dDotDot      = u.multiply(uDotDot).add(v.multiply(vDotDot)).add(w.multiply( wDotDot)
  142.                                          .add(uDot.pow(2).add(vDot.pow(2)).add(wDot.pow(2)).subtract(dDot.pow(2))))
  143.                                          .divide(d);
  144.         final T ratioDotDot  = (dDot.pow(2).multiply(2).subtract(d.multiply(dDotDot))).divide(d.multiply(d2));
  145.         final FieldVector3D<T> projectedA = new FieldVector3D<>(ratio,                scInBodyFrame.getAcceleration(),
  146.                                                                 ratioDot.multiply(2), scInBodyFrame.getVelocity(),
  147.                                                                 ratioDotDot,          scInBodyFrame.getPosition());
  148.         final TimeStampedFieldPVCoordinates<T> projected =
  149.                 new TimeStampedFieldPVCoordinates<>(date, projectedP, projectedV, projectedA);
  150.         return getBodyFrame().getTransformTo(frame, date.toAbsoluteDate()).transformPVCoordinates(projected);

  152.     }

  154. }
Created with JaCoCo 0.7.9.201702052155