InterSatDirectViewDetector.java

  1. /* Copyright 2002-2019 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.propagation.events;

  19. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  20. import org.hipparchus.util.FastMath;
  21. import org.orekit.bodies.OneAxisEllipsoid;
  22. import org.orekit.frames.Frame;
  23. import org.orekit.propagation.PropagatorsParallelizer;
  24. import org.orekit.propagation.SpacecraftState;
  25. import org.orekit.propagation.events.handlers.ContinueOnEvent;
  26. import org.orekit.propagation.events.handlers.EventHandler;
  27. import org.orekit.time.AbsoluteDate;
  28. import org.orekit.utils.PVCoordinatesProvider;


  31. /** Detector for inter-satellites direct view (i.e. no masking by central body limb).
  32.  * <p>
  33.  * As this detector needs two satellites, it embeds one {@link
  34.  * PVCoordinatesProvider coordinates provider} for the slave satellite
  35.  * and is registered as an event detector in the propagator of the master
  36.  * satellite. The slave satellite provider will therefore be driven by this
  37.  * detector (and hence by the propagator in which this detector is registered).
  38.  * </p>
  39.  * <p>
  40.  * In order to avoid infinite recursion, care must be taken to have the slave
  41.  * satellite provider being <em>completely independent</em> from anything else.
  42.  * In particular, if the provider is a propagator, it should <em>not</em> be run
  43.  * together in a {@link PropagatorsParallelizer propagators parallelizer} with
  44.  * the propagator this detector is registered in. It is fine however to configure
  45.  * two separate propagators PsA and PsB with similar settings for the slave satellite
  46.  * and one propagator Pm for the master satellite and then use Psa in this detector
  47.  * registered within Pm while Pm and Psb are run in the context of a {@link
  48.  * PropagatorsParallelizer propagators parallelizer}.
  49.  * </p>
  50.  * <p>
  51.  * For efficiency reason during the event search loop, it is recommended to have
  52.  * the slave provider be an analytical propagator or an ephemeris. A numerical propagator
  53.  * as a slave propagator works but is expected to be computationally costly.
  54.  * </p>
  55.  * <p>
  56.  * The {@code g} function of this detector is positive when satellites can see
  57.  * each other directly and negative when the central body limb is in between and
  58.  * blocks the direct view.
  59.  * </p>
  60.  * <p>
  61.  * This detector only checks masking by central body limb, it does not take into
  62.  * account satellites antenna patterns. If these patterns must be considered, then
  63.  * this detector can be {@link BooleanDetector#andCombine(EventDetector...) and combined}
  64.  * with  the {@link BooleanDetector#notCombine(EventDetector) logical not} of
  65.  * {@link FieldOfViewDetector field of view detectors}.
  66.  * </p>
  67.  * @author Luc Maisonobe
  68.  * @since 9.3
  69.  */
  70. public class InterSatDirectViewDetector extends AbstractDetector<InterSatDirectViewDetector> {

  72.     /** Serializable UID. */
  73.     private static final long serialVersionUID = 20181130L;

  75.     /** Central body. */
  76.     private final OneAxisEllipsoid body;

  78.     /** Equatorial radius squared. */
  79.     private final double ae2;

  81.     /** 1 minus flatness squared. */
  82.     private final double g2;

  84.     /** Coordinates provider for the slave satellite. */
  85.     private final transient PVCoordinatesProvider slave;

  87.     /** simple constructor.
  88.      *
  89.      * @param body central body
  90.      * @param slave provider for the slave satellite
  91.      */
  92.     public InterSatDirectViewDetector(final OneAxisEllipsoid body, final PVCoordinatesProvider slave) {
  93.         this(body, slave, DEFAULT_MAXCHECK, DEFAULT_THRESHOLD, DEFAULT_MAX_ITER,
  94.              new ContinueOnEvent<>());
  95.     }

  97.     /** Private constructor.
  98.      * @param body central body
  99.      * @param slave provider for the slave satellite
  100.      * @param maxCheck  maximum checking interval (s)
  101.      * @param threshold convergence threshold (s)
  102.      * @param maxIter   maximum number of iterations in the event time search
  103.      * @param handler   event handler to call at event occurrences
  104.      */
  105.     private InterSatDirectViewDetector(final OneAxisEllipsoid body,
  106.                                        final PVCoordinatesProvider slave,
  107.                                        final double maxCheck,
  108.                                        final double threshold,
  109.                                        final int maxIter,
  110.                                        final EventHandler<? super InterSatDirectViewDetector> handler) {
  111.         super(maxCheck, threshold, maxIter, handler);
  112.         this.body  = body;
  113.         this.ae2   = body.getEquatorialRadius() * body.getEquatorialRadius();
  114.         this.g2    = (1.0 - body.getFlattening()) * (1.0 - body.getFlattening());
  115.         this.slave = slave;
  116.     }

  118.     /** Get the central body.
  119.      * @return central body
  120.      */
  121.     public OneAxisEllipsoid getCentralBody() {
  122.         return body;
  123.     }

  125.     /** Get the provider for the slave satellite.
  126.      * @return provider for the slave satellite
  127.      */
  128.     public PVCoordinatesProvider getSlave() {
  129.         return slave;
  130.     }

  132.     /** {@inheritDoc} */
  133.     @Override
  134.     protected InterSatDirectViewDetector create(final double newMaxCheck,
  135.                                                 final double newThreshold,
  136.                                                 final int newMaxIter,
  137.                                                 final EventHandler<? super InterSatDirectViewDetector> newHandler) {
  138.         return new InterSatDirectViewDetector(body, slave, newMaxCheck, newThreshold, newMaxIter, newHandler);
  139.     }

  141.     /** {@inheritDoc}
  142.      * <p>
  143.      * The {@code g} function of this detector is positive when satellites can see
  144.      * each other directly and negative when the central body limb is in between and
  145.      * blocks the direct view.
  146.      * </p>
  147.      */
  148.     @Override
  149.     public double g(final SpacecraftState state) {

  151.         // get the line between master and slave in body frame
  152.         final AbsoluteDate date    = state.getDate();
  153.         final Frame        frame   = body.getBodyFrame();
  154.         final Vector3D     pMaster = state.getPVCoordinates(frame).getPosition();
  155.         final Vector3D     pSlave  = slave.getPVCoordinates(date, frame).getPosition();

  157.         // points along the master/slave lines are defined as
  158.         // xk = x + k * dx, yk = y + k * dy, zk = z + k * dz
  159.         // so k is 0 at master and 1 at slave
  160.         final double x  = pMaster.getX();
  161.         final double y  = pMaster.getY();
  162.         final double z  = pMaster.getZ();
  163.         final double dx = pSlave.getX() - x;
  164.         final double dy = pSlave.getY() - y;
  165.         final double dz = pSlave.getZ() - z;

  167.         // intersection between line and central body surface
  168.         // is a root of a 2nd degree polynomial :
  169.         // a k^2 - 2 b k + c = 0
  170.         final double a =   g2 * (dx * dx + dy * dy) + dz * dz;
  171.         final double b = -(g2 * (x * dx + y * dy) + z * dz);
  172.         final double c =   g2 * (x * x + y * y - ae2) + z * z;
  173.         final double s = b * b - a * c;
  174.         if (s < 0) {
  175.             // the quadratic has no solution, the line between master and slave
  176.             // doesn't crosses central body limb, direct view is possible
  177.             // return a positive value, preserving continuity across zero crossing
  178.             return -s;
  179.         }

  181.         // the quadratic has two solutions (degenerated to one if s = 0)
  182.         // direct view is blocked when one of these solutions is between 0 and 1
  183.         final double k1 = (b < 0) ? (b - FastMath.sqrt(s)) / a : c / (b + FastMath.sqrt(s));
  184.         final double k2 = c / (a * k1);
  185.         if (FastMath.max(k1, k2) < 0.0 || FastMath.min(k1, k2) > 1.0) {
  186.             // the intersections are either behind master or farther away than slave
  187.             // along the line, direct view is possible
  188.             // return a positive value, preserving continuity across zero crossing
  189.             return s;
  190.         } else {
  191.             // part of the central body is between master and slave
  192.             // this includes unrealistic cases where master, slave or both are inside the central body ;-)
  193.             // in all these cases, direct view is blocked
  194.             // return a negative value, preserving continuity across zero crossing
  195.             return -s;
  196.         }

  198.     }

  200. }
Created with JaCoCo 0.8.2.201808211720