AbstractRadiationForceModel.java
/* Copyright 2002-2022 CS GROUP
* Licensed to CS GROUP (CS) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* CS licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.orekit.forces.radiation;
import java.lang.reflect.Array;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Stream;
import org.hipparchus.Field;
import org.hipparchus.CalculusFieldElement;
import org.hipparchus.geometry.euclidean.threed.FieldVector3D;
import org.hipparchus.geometry.euclidean.threed.Vector3D;
import org.hipparchus.ode.events.Action;
import org.hipparchus.util.FastMath;
import org.hipparchus.util.MathArrays;
import org.orekit.errors.OrekitException;
import org.orekit.errors.OrekitMessages;
import org.orekit.forces.AbstractForceModel;
import org.orekit.propagation.FieldSpacecraftState;
import org.orekit.propagation.SpacecraftState;
import org.orekit.propagation.events.AbstractDetector;
import org.orekit.propagation.events.EventDetector;
import org.orekit.propagation.events.FieldAbstractDetector;
import org.orekit.propagation.events.FieldEventDetector;
import org.orekit.propagation.events.handlers.EventHandler;
import org.orekit.propagation.events.handlers.FieldEventHandler;
import org.orekit.utils.Constants;
import org.orekit.utils.ExtendedPVCoordinatesProvider;
/**
* Base class for radiation force models.
* @see SolarRadiationPressure
* @see ECOM2
* @since 10.2
*/
public abstract class AbstractRadiationForceModel extends AbstractForceModel {
/** Margin to force recompute lighting ratio derivatives when we are really inside penumbra. */
private static final double ANGULAR_MARGIN = 1.0e-10;
/** Central body model. */
private final double equatorialRadius;
/** Sun model. */
private final ExtendedPVCoordinatesProvider sun;
/** Other occulting bodies to consider. The Moon for instance. */
private final Map<ExtendedPVCoordinatesProvider, Double> otherOccultingBodies;
/**
* Default constructor.
* Only central body is considered.
* @param sun Sun model
* @param equatorialRadius central body spherical shape model (for umbra/penumbra computation)
*/
protected AbstractRadiationForceModel(final ExtendedPVCoordinatesProvider sun, final double equatorialRadius) {
this.sun = sun;
this.equatorialRadius = equatorialRadius;
this.otherOccultingBodies = new HashMap<>();
}
/** {@inheritDoc} */
@Override
public boolean dependsOnPositionOnly() {
return false;
}
/** {@inheritDoc} */
@Override
public Stream<EventDetector> getEventsDetectors() {
final EventDetector[] detectors = new EventDetector[2 + 2 * otherOccultingBodies.size()];
detectors[0] = new UmbraDetector();
detectors[1] = new PenumbraDetector();
int i = 2;
for (Map.Entry<ExtendedPVCoordinatesProvider, Double> entry : otherOccultingBodies.entrySet()) {
detectors[i] = new GeneralUmbraDetector(entry.getKey(), entry.getValue());
detectors[i + 1] = new GeneralPenumbraDetector(entry.getKey(), entry.getValue());
i = i + 2;
}
return Stream.of(detectors);
}
/** {@inheritDoc} */
@Override
public <T extends CalculusFieldElement<T>> Stream<FieldEventDetector<T>> getFieldEventsDetectors(final Field<T> field) {
final T zero = field.getZero();
@SuppressWarnings("unchecked")
final FieldEventDetector<T>[] detectors = (FieldEventDetector<T>[]) Array.newInstance(FieldEventDetector.class,
2 + 2 * otherOccultingBodies.size());
detectors[0] = new FieldUmbraDetector<>(field);
detectors[1] = new FieldPenumbraDetector<>(field);
int i = 2;
for (Map.Entry<ExtendedPVCoordinatesProvider, Double> entry : otherOccultingBodies.entrySet()) {
detectors[i] = new FieldGeneralUmbraDetector<>(field, entry.getKey(), zero.newInstance(entry.getValue()));
detectors[i + 1] = new FieldGeneralPenumbraDetector<>(field, entry.getKey(), zero.newInstance(entry.getValue()));
i = i + 2;
}
return Stream.of(detectors);
}
/**
* Get the useful angles for eclipse computation.
* @param sunPosition Sun position in the selected frame
* @param position the satellite's position in the selected frame
* @return the 3 angles {(satCentral, satSun), Central body apparent radius, Sun apparent radius}
*/
protected double[] getEclipseAngles(final Vector3D sunPosition, final Vector3D position) {
final double[] angle = new double[3];
final Vector3D satSunVector = sunPosition.subtract(position);
// Sat-Sun / Sat-CentralBody angle
angle[0] = Vector3D.angle(satSunVector, position.negate());
// Central body apparent radius
final double r = position.getNorm();
if (r <= equatorialRadius) {
throw new OrekitException(OrekitMessages.TRAJECTORY_INSIDE_BRILLOUIN_SPHERE, r);
}
angle[1] = FastMath.asin(equatorialRadius / r);
// Sun apparent radius
angle[2] = FastMath.asin(Constants.SUN_RADIUS / satSunVector.getNorm());
return angle;
}
/**
* Get the useful angles for eclipse computation.
* @param position the satellite's position in the selected frame
* @param occultingPosition Oculting body position in the selected frame
* @param occultingRadius Occulting body mean radius
* @param occultedPosition Occulted body position in the selected frame
* @param occultedRadius Occulted body mean radius
* @return the 3 angles {(satOcculting, satOcculted), Occulting body apparent radius, Occulted body apparent radius}
*/
protected double[] getGeneralEclipseAngles(final Vector3D position, final Vector3D occultingPosition, final double occultingRadius,
final Vector3D occultedPosition, final double occultedRadius) {
final double[] angle = new double[3];
final Vector3D satOccultedVector = occultedPosition.subtract(position);
final Vector3D satOccultingVector = occultingPosition.subtract(position);
// Sat-Occulted / Sat-Occulting angle
angle[0] = Vector3D.angle(satOccultedVector, satOccultingVector);
// Occulting body apparent radius
angle[1] = FastMath.asin(occultingRadius / satOccultingVector.getNorm());
// Occulted body apparent radius
angle[2] = FastMath.asin(occultedRadius / satOccultedVector.getNorm());
return angle;
}
/**
* Get the useful angles for eclipse computation.
* @param sunPosition Sun position in the selected frame
* @param position the satellite's position in the selected frame.
* @param <T> extends CalculusFieldElement
* @return the 3 angles {(satCentral, satSun), Central body apparent radius, Sun apparent radius}
*/
protected <T extends CalculusFieldElement<T>> T[] getEclipseAngles(final FieldVector3D<T> sunPosition, final FieldVector3D<T> position) {
final T[] angle = MathArrays.buildArray(position.getX().getField(), 3);
final FieldVector3D<T> mP = position.negate();
final FieldVector3D<T> satSunVector = mP.add(sunPosition);
// Sat-Sun / Sat-CentralBody angle
angle[0] = FieldVector3D.angle(satSunVector, mP);
// Central body apparent radius
final T r = position.getNorm();
if (r.getReal() <= equatorialRadius) {
throw new OrekitException(OrekitMessages.TRAJECTORY_INSIDE_BRILLOUIN_SPHERE, r);
}
angle[1] = r.reciprocal().multiply(equatorialRadius).asin();
// Sun apparent radius
angle[2] = satSunVector.getNorm().reciprocal().multiply(Constants.SUN_RADIUS).asin();
return angle;
}
/**
* Get the useful angles for eclipse computation.
* @param occultingPosition Oculting body position in the selected frame
* @param occultingRadius Occulting body mean radius
* @param occultedPosition Occulted body position in the selected frame
* @param occultedRadius Occulted body mean radius
* @param position the satellite's position in the selected frame
* @param <T> extends RealFieldElement
* @return the 3 angles {(satOcculting, satOcculted), Occulting body apparent radius, Occulted body apparent radius}
*/
protected <T extends CalculusFieldElement<T>> T[] getGeneralEclipseAngles(final FieldVector3D<T> position,
final FieldVector3D<T> occultingPosition, final T occultingRadius,
final FieldVector3D<T> occultedPosition, final T occultedRadius) {
final T[] angle = MathArrays.buildArray(position.getX().getField(), 3);
final FieldVector3D<T> satOccultedVector = occultedPosition.subtract(position);
final FieldVector3D<T> satOccultingVector = occultingPosition.subtract(position);
// Sat-Occulted / Sat-Occulting angle
angle[0] = FieldVector3D.angle(satOccultedVector, satOccultingVector);
// Occulting body apparent radius
angle[1] = occultingRadius.divide(satOccultingVector.getNorm()).asin();
// Occulted body apparent radius
angle[2] = occultedRadius.divide(satOccultedVector.getNorm()).asin();
return angle;
}
/**
* Add a new occulting body.
* Central body is already considered, it shall not be added this way.
* @param provider body PV provider
* @param radius body mean radius
*/
public void addOccultingBody(final ExtendedPVCoordinatesProvider provider, final double radius) {
otherOccultingBodies.put(provider, radius);
}
/**
* Getter for other occulting bodies to consider.
* @return the map of other occulting bodies and corresponding mean radiuses
*/
public Map<ExtendedPVCoordinatesProvider, Double> getOtherOccultingBodies() {
return otherOccultingBodies;
}
/**
* Getter for equatorial radius.
* @return central body equatorial radius
*/
public double getEquatorialRadius() {
return equatorialRadius;
}
/** This class defines the umbra entry/exit detector. */
private class UmbraDetector extends AbstractDetector<UmbraDetector> {
/** Build a new instance. */
UmbraDetector() {
super(60.0, 1.0e-3, DEFAULT_MAX_ITER, new EventHandler<UmbraDetector>() {
/** {@inheritDoc} */
public Action eventOccurred(final SpacecraftState s, final UmbraDetector detector,
final boolean increasing) {
return Action.RESET_DERIVATIVES;
}
});
}
/** Private constructor with full parameters.
* <p>
* This constructor is private as users are expected to use the builder
* API with the various {@code withXxx()} methods to set up the instance
* in a readable manner without using a huge amount of parameters.
* </p>
* @param maxCheck maximum checking interval (s)
* @param threshold convergence threshold (s)
* @param maxIter maximum number of iterations in the event time search
* @param handler event handler to call at event occurrences
* @since 6.1
*/
private UmbraDetector(final double maxCheck, final double threshold, final int maxIter,
final EventHandler<? super UmbraDetector> handler) {
super(maxCheck, threshold, maxIter, handler);
}
/** {@inheritDoc} */
@Override
protected UmbraDetector create(final double newMaxCheck, final double newThreshold, final int newMaxIter,
final EventHandler<? super UmbraDetector> newHandler) {
return new UmbraDetector(newMaxCheck, newThreshold, newMaxIter, newHandler);
}
/** The G-function is the difference between the Sun-Sat-Central-Body angle and
* the central body apparent radius.
* @param s the current state information : date, kinematics, attitude
* @return value of the g function
*/
public double g(final SpacecraftState s) {
final double[] angle = getEclipseAngles(sun.getPVCoordinates(s.getDate(), s.getFrame()).getPosition(),
s.getPVCoordinates().getPosition());
return angle[0] - angle[1] + angle[2] - ANGULAR_MARGIN;
}
}
/** This class defines the penumbra entry/exit detector. */
private class PenumbraDetector extends AbstractDetector<PenumbraDetector> {
/** Build a new instance. */
PenumbraDetector() {
super(60.0, 1.0e-3, DEFAULT_MAX_ITER, new EventHandler<PenumbraDetector>() {
/** {@inheritDoc} */
public Action eventOccurred(final SpacecraftState s, final PenumbraDetector detector,
final boolean increasing) {
return Action.RESET_DERIVATIVES;
}
});
}
/** Private constructor with full parameters.
* <p>
* This constructor is private as users are expected to use the builder
* API with the various {@code withXxx()} methods to set up the instance
* in a readable manner without using a huge amount of parameters.
* </p>
* @param maxCheck maximum checking interval (s)
* @param threshold convergence threshold (s)
* @param maxIter maximum number of iterations in the event time search
* @param handler event handler to call at event occurrences
* @since 6.1
*/
private PenumbraDetector(final double maxCheck, final double threshold, final int maxIter,
final EventHandler<? super PenumbraDetector> handler) {
super(maxCheck, threshold, maxIter, handler);
}
/** {@inheritDoc} */
@Override
protected PenumbraDetector create(final double newMaxCheck, final double newThreshold, final int newMaxIter,
final EventHandler<? super PenumbraDetector> newHandler) {
return new PenumbraDetector(newMaxCheck, newThreshold, newMaxIter, newHandler);
}
/** The G-function is the difference between the Sun-Sat-Central-Body angle and
* the sum of the central body and Sun's apparent radius.
* @param s the current state information : date, kinematics, attitude
* @return value of the g function
*/
public double g(final SpacecraftState s) {
final double[] angle = getEclipseAngles(sun.getPVCoordinates(s.getDate(), s.getFrame()).getPosition(),
s.getPVCoordinates().getPosition());
return angle[0] - angle[1] - angle[2] + ANGULAR_MARGIN;
}
}
/** This class defines the umbra entry/exit detector. */
private class FieldUmbraDetector<T extends CalculusFieldElement<T>>
extends FieldAbstractDetector<FieldUmbraDetector<T>, T> {
/** Build a new instance.
* @param field field to which elements belong
*/
FieldUmbraDetector(final Field<T> field) {
super(field.getZero().add(60.0), field.getZero().add(1.0e-3),
DEFAULT_MAX_ITER, new FieldEventHandler<FieldUmbraDetector<T>, T>() {
/** {@inheritDoc} */
public Action eventOccurred(final FieldSpacecraftState<T> s,
final FieldUmbraDetector<T> detector,
final boolean increasing) {
return Action.RESET_DERIVATIVES;
}
});
}
/** Private constructor with full parameters.
* <p>
* This constructor is private as users are expected to use the builder
* API with the various {@code withXxx()} methods to set up the instance
* in a readable manner without using a huge amount of parameters.
* </p>
* @param maxCheck maximum checking interval (s)
* @param threshold convergence threshold (s)
* @param maxIter maximum number of iterations in the event time search
* @param handler event handler to call at event occurrences
*/
private FieldUmbraDetector(final T maxCheck, final T threshold, final int maxIter,
final FieldEventHandler<? super FieldUmbraDetector<T>, T> handler) {
super(maxCheck, threshold, maxIter, handler);
}
/** {@inheritDoc} */
@Override
protected FieldUmbraDetector<T> create(final T newMaxCheck, final T newThreshold, final int newMaxIter,
final FieldEventHandler<? super FieldUmbraDetector<T>, T> newHandler) {
return new FieldUmbraDetector<>(newMaxCheck, newThreshold, newMaxIter, newHandler);
}
/** The G-function is the difference between the Sun-Sat-Central-Body angle and
* the central body apparent radius.
* @param s the current state information : date, kinematics, attitude
* @return value of the g function
*/
public T g(final FieldSpacecraftState<T> s) {
final T[] angle = getEclipseAngles(sun.getPVCoordinates(s.getDate(), s.getFrame()).getPosition(),
s.getPVCoordinates().getPosition());
return angle[0].subtract(angle[1]).add(angle[2]).subtract(ANGULAR_MARGIN);
}
}
/** This class defines the penumbra entry/exit detector. */
private class FieldPenumbraDetector<T extends CalculusFieldElement<T>>
extends FieldAbstractDetector<FieldPenumbraDetector<T>, T> {
/** Build a new instance.
* @param field field to which elements belong
*/
FieldPenumbraDetector(final Field<T> field) {
super(field.getZero().add(60.0), field.getZero().add(1.0e-3),
DEFAULT_MAX_ITER, new FieldEventHandler<FieldPenumbraDetector<T>, T>() {
/** {@inheritDoc} */
public Action eventOccurred(final FieldSpacecraftState<T> s,
final FieldPenumbraDetector<T> detector,
final boolean increasing) {
return Action.RESET_DERIVATIVES;
}
});
}
/** Private constructor with full parameters.
* <p>
* This constructor is private as users are expected to use the builder
* API with the various {@code withXxx()} methods to set up the instance
* in a readable manner without using a huge amount of parameters.
* </p>
* @param maxCheck maximum checking interval (s)
* @param threshold convergence threshold (s)
* @param maxIter maximum number of iterations in the event time search
* @param handler event handler to call at event occurrences
*/
private FieldPenumbraDetector(final T maxCheck, final T threshold, final int maxIter,
final FieldEventHandler<? super FieldPenumbraDetector<T>, T> handler) {
super(maxCheck, threshold, maxIter, handler);
}
/** {@inheritDoc} */
@Override
protected FieldPenumbraDetector<T> create(final T newMaxCheck, final T newThreshold, final int newMaxIter,
final FieldEventHandler<? super FieldPenumbraDetector<T>, T> newHandler) {
return new FieldPenumbraDetector<>(newMaxCheck, newThreshold, newMaxIter, newHandler);
}
/** The G-function is the difference between the Sun-Sat-Central-Body angle and
* the sum of the central body and Sun's apparent radius.
* @param s the current state information : date, kinematics, attitude
* @return value of the g function
*/
public T g(final FieldSpacecraftState<T> s) {
final T[] angle = getEclipseAngles(sun.getPVCoordinates(s.getDate(), s.getFrame()).getPosition(),
s.getPVCoordinates().getPosition());
return angle[0].subtract(angle[1]).subtract(angle[2]).add(ANGULAR_MARGIN);
}
}
/** This class defines the umbra entry/exit detector. */
private class GeneralUmbraDetector extends AbstractDetector<GeneralUmbraDetector> {
/** Occulting body PV provider. */
private ExtendedPVCoordinatesProvider provider;
/** Occulting body mean radius. */
private double radius;
/** Build a new instance.
* @param provider occulting body PV provider
* @param radius occulting body mean radius
*/
GeneralUmbraDetector(final ExtendedPVCoordinatesProvider provider, final double radius) {
super(60.0, 1.0e-3, DEFAULT_MAX_ITER, new EventHandler<GeneralUmbraDetector>() {
/** {@inheritDoc} */
public Action eventOccurred(final SpacecraftState s, final GeneralUmbraDetector detector,
final boolean increasing) {
return Action.RESET_DERIVATIVES;
}
});
this.provider = provider;
this.radius = radius;
}
/** Private constructor with full parameters.
* <p>
* This constructor is private as users are expected to use the builder
* API with the various {@code withXxx()} methods to set up the instance
* in a readable manner without using a huge amount of parameters.
* </p>
* @param maxCheck maximum checking interval (s)
* @param threshold convergence threshold (s)
* @param maxIter maximum number of iterations in the event time search
* @param handler event handler to call at event occurrences
* @since 6.1
*/
private GeneralUmbraDetector(final double maxCheck, final double threshold, final int maxIter,
final EventHandler<? super GeneralUmbraDetector> handler) {
super(maxCheck, threshold, maxIter, handler);
}
/** {@inheritDoc} */
@Override
protected GeneralUmbraDetector create(final double newMaxCheck, final double newThreshold, final int newMaxIter,
final EventHandler<? super GeneralUmbraDetector> newHandler) {
return new GeneralUmbraDetector(newMaxCheck, newThreshold, newMaxIter, newHandler);
}
/** The G-function is the difference between the Sun-Sat-Central-Body angle and
* the central body apparent radius.
* @param s the current state information : date, kinematics, attitude
* @return value of the g function
*/
public double g(final SpacecraftState s) {
final double[] angle = getGeneralEclipseAngles(s.getPVCoordinates().getPosition(),
provider.getPVCoordinates(s.getDate(), s.getFrame()).getPosition(),
radius, sun.getPVCoordinates(s.getDate(), s.getFrame()).getPosition(),
Constants.SUN_RADIUS);
return angle[0] - angle[1] + angle[2] - ANGULAR_MARGIN;
}
}
/** This class defines the umbra entry/exit detector. */
private class GeneralPenumbraDetector extends AbstractDetector<GeneralPenumbraDetector> {
/** Occulting body PV provider. */
private ExtendedPVCoordinatesProvider provider;
/** Occulting body mean radius. */
private double radius;
/** Build a new instance.
* @param provider occulting body PV provider
* @param radius occulting body mean radius
*/
GeneralPenumbraDetector(final ExtendedPVCoordinatesProvider provider, final double radius) {
super(60.0, 1.0e-3, DEFAULT_MAX_ITER, new EventHandler<GeneralPenumbraDetector>() {
/** {@inheritDoc} */
public Action eventOccurred(final SpacecraftState s, final GeneralPenumbraDetector detector,
final boolean increasing) {
return Action.RESET_DERIVATIVES;
}
});
this.provider = provider;
this.radius = radius;
}
/** Private constructor with full parameters.
* <p>
* This constructor is private as users are expected to use the builder
* API with the various {@code withXxx()} methods to set up the instance
* in a readable manner without using a huge amount of parameters.
* </p>
* @param maxCheck maximum checking interval (s)
* @param threshold convergence threshold (s)
* @param maxIter maximum number of iterations in the event time search
* @param handler event handler to call at event occurrences
* @since 6.1
*/
private GeneralPenumbraDetector(final double maxCheck, final double threshold, final int maxIter,
final EventHandler<? super GeneralPenumbraDetector> handler) {
super(maxCheck, threshold, maxIter, handler);
}
/** {@inheritDoc} */
@Override
protected GeneralPenumbraDetector create(final double newMaxCheck, final double newThreshold, final int newMaxIter,
final EventHandler<? super GeneralPenumbraDetector> newHandler) {
return new GeneralPenumbraDetector(newMaxCheck, newThreshold, newMaxIter, newHandler);
}
/** The G-function is the difference between the Sun-Sat-Central-Body angle and
* the central body apparent radius.
* @param s the current state information : date, kinematics, attitude
* @return value of the g function
*/
public double g(final SpacecraftState s) {
final double[] angle = getGeneralEclipseAngles(s.getPVCoordinates().getPosition(),
provider.getPVCoordinates(s.getDate(), s.getFrame()).getPosition(),
radius, sun.getPVCoordinates(s.getDate(), s.getFrame()).getPosition(),
Constants.SUN_RADIUS);
return angle[0] - angle[1] - angle[2] + ANGULAR_MARGIN;
}
}
/** This class defines the umbra entry/exit detector. */
private class FieldGeneralUmbraDetector<T extends CalculusFieldElement<T>>
extends FieldAbstractDetector<FieldGeneralUmbraDetector<T>, T> {
/** Occulting body PV provider. */
private ExtendedPVCoordinatesProvider provider;
/** Occulting body mean radius. */
private T radius;
/** Build a new instance.
* @param field field to which elements belong
* @param provider occulting body PV provider
* @param radius occulting body mean radius
*/
FieldGeneralUmbraDetector(final Field<T> field, final ExtendedPVCoordinatesProvider provider, final T radius) {
super(field.getZero().add(60.0), field.getZero().add(1.0e-3),
DEFAULT_MAX_ITER, new FieldEventHandler<FieldGeneralUmbraDetector<T>, T>() {
/** {@inheritDoc} */
public Action eventOccurred(final FieldSpacecraftState<T> s,
final FieldGeneralUmbraDetector<T> detector,
final boolean increasing) {
return Action.RESET_DERIVATIVES;
}
});
this.provider = provider;
this.radius = radius;
}
/** Private constructor with full parameters.
* <p>
* This constructor is private as users are expected to use the builder
* API with the various {@code withXxx()} methods to set up the instance
* in a readable manner without using a huge amount of parameters.
* </p>
* @param maxCheck maximum checking interval (s)
* @param threshold convergence threshold (s)
* @param maxIter maximum number of iterations in the event time search
* @param handler event handler to call at event occurrences
*/
private FieldGeneralUmbraDetector(final T maxCheck, final T threshold,
final int maxIter,
final FieldEventHandler<? super FieldGeneralUmbraDetector<T>, T> handler) {
super(maxCheck, threshold, maxIter, handler);
}
/** {@inheritDoc} */
@Override
protected FieldGeneralUmbraDetector<T> create(final T newMaxCheck, final T newThreshold, final int newMaxIter,
final FieldEventHandler<? super FieldGeneralUmbraDetector<T>, T> newHandler) {
return new FieldGeneralUmbraDetector<>(newMaxCheck, newThreshold, newMaxIter, newHandler);
}
/** The G-function is the difference between the Sun-Sat-Central-Body angle and
* the central body apparent radius.
* @param s the current state information : date, kinematics, attitude
* @return value of the g function
*/
public T g(final FieldSpacecraftState<T> s) {
final T[] angle = getGeneralEclipseAngles(s.getPVCoordinates().getPosition(),
provider.getPVCoordinates(s.getDate(), s.getFrame()).getPosition(),
radius, sun.getPVCoordinates(s.getDate(), s.getFrame()).getPosition(),
s.getA().getField().getZero().add(Constants.SUN_RADIUS));
return angle[0].subtract(angle[1]).add(angle[2]).subtract(ANGULAR_MARGIN);
}
}
/** This class defines the umbra entry/exit detector. */
private class FieldGeneralPenumbraDetector<T extends CalculusFieldElement<T>>
extends FieldAbstractDetector<FieldGeneralPenumbraDetector<T>, T> {
/** Occulting body PV provider. */
private ExtendedPVCoordinatesProvider provider;
/** Occulting body mean radius. */
private T radius;
/** Build a new instance.
* @param field field to which elements belong
* @param provider occulting body PV provider
* @param radius occulting body mean radius
*/
FieldGeneralPenumbraDetector(final Field<T> field, final ExtendedPVCoordinatesProvider provider, final T radius) {
super(field.getZero().add(60.0), field.getZero().add(1.0e-3),
DEFAULT_MAX_ITER, new FieldEventHandler<FieldGeneralPenumbraDetector<T>, T>() {
/** {@inheritDoc} */
public Action eventOccurred(final FieldSpacecraftState<T> s,
final FieldGeneralPenumbraDetector<T> detector,
final boolean increasing) {
return Action.RESET_DERIVATIVES;
}
});
this.provider = provider;
this.radius = radius;
}
/** Private constructor with full parameters.
* <p>
* This constructor is private as users are expected to use the builder
* API with the various {@code withXxx()} methods to set up the instance
* in a readable manner without using a huge amount of parameters.
* </p>
* @param maxCheck maximum checking interval (s)
* @param threshold convergence threshold (s)
* @param maxIter maximum number of iterations in the event time search
* @param handler event handler to call at event occurrences
*/
private FieldGeneralPenumbraDetector(final T maxCheck, final T threshold, final int maxIter,
final FieldEventHandler<? super FieldGeneralPenumbraDetector<T>, T> handler) {
super(maxCheck, threshold, maxIter, handler);
}
/** {@inheritDoc} */
@Override
protected FieldGeneralPenumbraDetector<T> create(final T newMaxCheck, final T newThreshold, final int newMaxIter,
final FieldEventHandler<? super FieldGeneralPenumbraDetector<T>, T> newHandler) {
return new FieldGeneralPenumbraDetector<>(newMaxCheck, newThreshold, newMaxIter, newHandler);
}
/** The G-function is the difference between the Sun-Sat-Central-Body angle and
* the central body apparent radius.
* @param s the current state information : date, kinematics, attitude
* @return value of the g function
*/
public T g(final FieldSpacecraftState<T> s) {
final T[] angle = getGeneralEclipseAngles(s.getPVCoordinates().getPosition(),
provider.getPVCoordinates(s.getDate(), s.getFrame()).getPosition(),
radius, sun.getPVCoordinates(s.getDate(), s.getFrame()).getPosition(),
s.getA().getField().getZero().add(Constants.SUN_RADIUS));
return angle[0].subtract(angle[1]).subtract(angle[2]).add(ANGULAR_MARGIN);
}
}
}