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

  19. import java.util.ArrayList;
  20. import java.util.List;

  22. import org.hipparchus.CalculusFieldElement;
  23. import org.hipparchus.geometry.euclidean.threed.FieldVector3D;
  24. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  25. import org.orekit.bodies.BodyShape;
  26. import org.orekit.bodies.FieldGeodeticPoint;
  27. import org.orekit.bodies.GeodeticPoint;
  28. import org.orekit.frames.FieldStaticTransform;
  29. import org.orekit.frames.FieldTransform;
  30. import org.orekit.frames.Frame;
  31. import org.orekit.frames.StaticTransform;
  32. import org.orekit.frames.Transform;
  33. import org.orekit.time.AbsoluteDate;
  34. import org.orekit.time.FieldAbsoluteDate;
  35. import org.orekit.time.FieldTimeInterpolator;
  36. import org.orekit.time.TimeInterpolator;
  37. import org.orekit.utils.CartesianDerivativesFilter;
  38. import org.orekit.utils.FieldPVCoordinatesProvider;
  39. import org.orekit.utils.PVCoordinatesProvider;
  40. import org.orekit.utils.TimeStampedFieldPVCoordinates;
  41. import org.orekit.utils.TimeStampedFieldPVCoordinatesHermiteInterpolator;
  42. import org.orekit.utils.TimeStampedPVCoordinates;
  43. import org.orekit.utils.TimeStampedPVCoordinatesHermiteInterpolator;

  45. /**
  46.  * This class handles nadir pointing attitude provider.

  48.  * <p>
  49.  * This class represents the attitude provider where the satellite z axis is
  50.  * pointing to the vertical of the ground point under satellite.</p>
  51.  * <p>
  52.  * The object <code>NadirPointing</code> is guaranteed to be immutable.
  53.  * </p>
  54.  * @see     GroundPointing
  55.  * @author V&eacute;ronique Pommier-Maurussane
  56.  */
  57. public class NadirPointing extends GroundPointing {

  59.     /** Body shape.  */
  60.     private final BodyShape shape;

  62.     /** Creates new instance.
  63.      * @param inertialFrame frame in which orbital velocities are computed
  64.      * @param shape Body shape
  65.      * @since 7.1
  66.      */
  67.     public NadirPointing(final Frame inertialFrame, final BodyShape shape) {
  68.         // Call constructor of superclass
  69.         super(inertialFrame, shape.getBodyFrame());
  70.         this.shape = shape;
  71.     }

  73.     /** {@inheritDoc} */
  74.     public TimeStampedPVCoordinates getTargetPV(final PVCoordinatesProvider pvProv,
  75.                                                 final AbsoluteDate date, final Frame frame) {

  77.         // transform from specified reference frame to body frame
  78.         final Transform refToBody = frame.getTransformTo(shape.getBodyFrame(), date);

  80.         // sample intersection points in current date neighborhood
  81.         final double h  = 0.01;
  82.         final List<TimeStampedPVCoordinates> sample = new ArrayList<>();
  83.         sample.add(nadirRef(pvProv.getPVCoordinates(date.shiftedBy(-2 * h), frame), refToBody.staticShiftedBy(-2 * h)));
  84.         sample.add(nadirRef(pvProv.getPVCoordinates(date.shiftedBy(-h),     frame), refToBody.staticShiftedBy(-h)));
  85.         sample.add(nadirRef(pvProv.getPVCoordinates(date,                   frame), refToBody));
  86.         sample.add(nadirRef(pvProv.getPVCoordinates(date.shiftedBy(+h),     frame), refToBody.staticShiftedBy(+h)));
  87.         sample.add(nadirRef(pvProv.getPVCoordinates(date.shiftedBy(+2 * h), frame), refToBody.staticShiftedBy(+2 * h)));

  89.         // create interpolator
  90.         final TimeInterpolator<TimeStampedPVCoordinates> interpolator =
  91.                 new TimeStampedPVCoordinatesHermiteInterpolator(sample.size(), CartesianDerivativesFilter.USE_P);

  93.         // use interpolation to compute properly the time-derivatives
  94.         return interpolator.interpolate(date, sample);

  96.     }

  98.     /** {@inheritDoc} */
  99.     public <T extends CalculusFieldElement<T>> TimeStampedFieldPVCoordinates<T> getTargetPV(final FieldPVCoordinatesProvider<T> pvProv,
  100.                                                                                             final FieldAbsoluteDate<T> date,
  101.                                                                                             final Frame frame) {

  103.         // zero
  104.         final T zero = date.getField().getZero();

  106.         // transform from specified reference frame to body frame
  107.         final FieldTransform<T> refToBody = frame.getTransformTo(shape.getBodyFrame(), date);

  109.         // sample intersection points in current date neighborhood
  110.         final double h  = 0.01;
  111.         final List<TimeStampedFieldPVCoordinates<T>> sample = new ArrayList<>();
  112.         sample.add(nadirRef(pvProv.getPVCoordinates(date.shiftedBy(-2 * h), frame), refToBody.staticShiftedBy(zero.add(-2 * h))));
  113.         sample.add(nadirRef(pvProv.getPVCoordinates(date.shiftedBy(-h),     frame), refToBody.staticShiftedBy(zero.add(-h))));
  114.         sample.add(nadirRef(pvProv.getPVCoordinates(date,                   frame), refToBody));
  115.         sample.add(nadirRef(pvProv.getPVCoordinates(date.shiftedBy(+h),     frame), refToBody.staticShiftedBy(zero.add(+h))));
  116.         sample.add(nadirRef(pvProv.getPVCoordinates(date.shiftedBy(+2 * h), frame), refToBody.staticShiftedBy(zero.add(+2 * h))));

  118.         // create interpolator
  119.         final FieldTimeInterpolator<TimeStampedFieldPVCoordinates<T>, T> interpolator =
  120.                 new TimeStampedFieldPVCoordinatesHermiteInterpolator<>(sample.size(), CartesianDerivativesFilter.USE_P);

  122.         // use interpolation to compute properly the time-derivatives
  123.         return interpolator.interpolate(date, sample);

  125.     }

  127.     /** Compute ground point in nadir direction, in reference frame.
  128.      * @param scRef spacecraft coordinates in reference frame
  129.      * @param refToBody transform from reference frame to body frame
  130.      * @return intersection point in body frame (only the position is set!)
  131.      */
  132.     private TimeStampedPVCoordinates nadirRef(final TimeStampedPVCoordinates scRef,
  133.                                               final StaticTransform refToBody) {

  135.         final Vector3D satInBodyFrame = refToBody.transformPosition(scRef.getPosition());

  137.         // satellite position in geodetic coordinates
  138.         final GeodeticPoint gpSat = shape.transform(satInBodyFrame, getBodyFrame(), scRef.getDate());

  140.         // nadir position in geodetic coordinates
  141.         final GeodeticPoint gpNadir = new GeodeticPoint(gpSat.getLatitude(), gpSat.getLongitude(), 0.0);

  143.         // nadir point position in body frame
  144.         final Vector3D pNadirBody = shape.transform(gpNadir);

  146.         // nadir point position in reference frame
  147.         final Vector3D pNadirRef = refToBody.getInverse().transformPosition(pNadirBody);

  149.         return new TimeStampedPVCoordinates(scRef.getDate(), pNadirRef, Vector3D.ZERO, Vector3D.ZERO);

  151.     }

  153.     /** Compute ground point in nadir direction, in reference frame.
  154.      * @param scRef spacecraft coordinates in reference frame
  155.      * @param refToBody transform from reference frame to body frame
  156.      * @param <T> type of the field elements
  157.      * @return intersection point in body frame (only the position is set!)
  158.      * @since 9.0
  159.      */
  160.     private <T extends CalculusFieldElement<T>> TimeStampedFieldPVCoordinates<T> nadirRef(final TimeStampedFieldPVCoordinates<T> scRef,
  161.                                                                                           final FieldStaticTransform<T> refToBody) {

  163.         final FieldVector3D<T> satInBodyFrame = refToBody.transformPosition(scRef.getPosition());

  165.         // satellite position in geodetic coordinates
  166.         final FieldGeodeticPoint<T> gpSat = shape.transform(satInBodyFrame, getBodyFrame(), scRef.getDate());

  168.         // nadir position in geodetic coordinates
  169.         final FieldGeodeticPoint<T> gpNadir = new FieldGeodeticPoint<>(gpSat.getLatitude(), gpSat.getLongitude(),
  170.                                                                        gpSat.getAltitude().getField().getZero());

  172.         // nadir point position in body frame
  173.         final FieldVector3D<T> pNadirBody = shape.transform(gpNadir);

  175.         // nadir point position in reference frame
  176.         final FieldVector3D<T> pNadirRef = refToBody.getInverse().transformPosition(pNadirBody);

  178.         final FieldVector3D<T> zero = FieldVector3D.getZero(gpSat.getAltitude().getField());
  179.         return new TimeStampedFieldPVCoordinates<>(scRef.getDate(), pNadirRef, zero, zero);

  181.     }

  183. }
Created with JaCoCo 0.8.11.202310140853