/** {@inheritDoc} */
@Override
public double[] computeDerivatives(final SpacecraftState state) throws OrekitException {
// compute common auxiliary elements
final AuxiliaryElements aux = new AuxiliaryElements(state.getOrbit(), I);
// initialize all perturbing forces
for (final DSSTForceModel force : mapper.getForceModels()) {
force.initializeStep(aux);
}
Arrays.fill(yDot, 0.0);
// compute the contributions of all perturbing forces
for (final DSSTForceModel forceModel : mapper.getForceModels()) {
final double[] daidt = forceModel.getMeanElementRate(state);
for (int i = 0; i < daidt.length; i++) {
yDot[i] += daidt[i];
}
}
// finalize derivatives by adding the Kepler contribution
final EquinoctialOrbit orbit =
(EquinoctialOrbit) OrbitType.EQUINOCTIAL.convertType(state.getOrbit());
orbit.addKeplerContribution(PositionAngle.MEAN, getMu(), yDot);
return yDot.clone();
}
private double[] stateToArray(
SpacecraftState state, OrbitType orbitType, PositionAngle angleType, boolean withMass) {
double[] array = new double[withMass ? 7 : 6];
switch (orbitType) {
case CARTESIAN:
{
CartesianOrbit cart = (CartesianOrbit) orbitType.convertType(state.getOrbit());
array[0] = cart.getPVCoordinates().getPosition().getX();
array[1] = cart.getPVCoordinates().getPosition().getY();
array[2] = cart.getPVCoordinates().getPosition().getZ();
array[3] = cart.getPVCoordinates().getVelocity().getX();
array[4] = cart.getPVCoordinates().getVelocity().getY();
array[5] = cart.getPVCoordinates().getVelocity().getZ();
}
break;
case CIRCULAR:
{
CircularOrbit circ = (CircularOrbit) orbitType.convertType(state.getOrbit());
array[0] = circ.getA();
array[1] = circ.getCircularEx();
array[2] = circ.getCircularEy();
array[3] = circ.getI();
array[4] = circ.getRightAscensionOfAscendingNode();
array[5] = circ.getAlpha(angleType);
}
break;
case EQUINOCTIAL:
{
EquinoctialOrbit equ = (EquinoctialOrbit) orbitType.convertType(state.getOrbit());
array[0] = equ.getA();
array[1] = equ.getEquinoctialEx();
array[2] = equ.getEquinoctialEy();
array[3] = equ.getHx();
array[4] = equ.getHy();
array[5] = equ.getL(angleType);
}
break;
case KEPLERIAN:
{
KeplerianOrbit kep = (KeplerianOrbit) orbitType.convertType(state.getOrbit());
array[0] = kep.getA();
array[1] = kep.getE();
array[2] = kep.getI();
array[3] = kep.getPerigeeArgument();
array[4] = kep.getRightAscensionOfAscendingNode();
array[5] = kep.getAnomaly(angleType);
}
break;
}
if (withMass) {
array[6] = state.getMass();
}
return array;
}
/**
* Method called just before integration.
*
* <p>The default implementation does nothing, it may be specialized in subclasses.
*
* @param initialState initial state
* @param tEnd target date at which state should be propagated
* @exception OrekitException if hook cannot be run
*/
@Override
protected void beforeIntegration(final SpacecraftState initialState, final AbsoluteDate tEnd)
throws OrekitException {
// compute common auxiliary elements
final AuxiliaryElements aux = new AuxiliaryElements(initialState.getOrbit(), I);
// check if only mean elements must be used
final boolean meanOnly = isMeanOrbit();
// initialize all perturbing forces
for (final DSSTForceModel force : mapper.getForceModels()) {
force.initialize(aux, meanOnly);
}
// if required, insert the special short periodics step handler
if (!meanOnly) {
final InterpolationGrid grid =
new VariableStepInterpolationGrid(INTERPOLATION_POINTS_PER_STEP);
final ShortPeriodicsHandler spHandler = new ShortPeriodicsHandler(grid);
final Collection<StepHandler> stepHandlers = new ArrayList<StepHandler>();
stepHandlers.add(spHandler);
final AbstractIntegrator integrator = getIntegrator();
final Collection<StepHandler> existing = integrator.getStepHandlers();
stepHandlers.addAll(existing);
integrator.clearStepHandlers();
// add back the existing handlers after the short periodics one
for (final StepHandler sp : stepHandlers) {
integrator.addStepHandler(sp);
}
}
}
/**
* Conversion from osculating to mean, orbit.
*
* <p>Compute osculating state <b>in a DSST sense</b>, corresponding to the mean SpacecraftState
* in input, and according to the Force models taken into account.
*
* <p>Since the osculating state is obtained with the computation of short-periodic variation of
* each force model, the resulting output will depend on the force models parametrized in input.
*
* <p>The computing is done through a fixed-point iteration process.
*
* @param osculating Osculating state to convert
* @param forces Forces to take into account
* @return mean state in a DSST sense
* @throws OrekitException if computation of short periodics fails or iteration algorithm does not
* converge
*/
public static SpacecraftState computeMeanState(
final SpacecraftState osculating, final Collection<DSSTForceModel> forces)
throws OrekitException {
// Creation of a DSSTPropagator instance
final AbstractIntegrator integrator = new ClassicalRungeKuttaIntegrator(43200.);
final DSSTPropagator dsst = new DSSTPropagator(integrator, false);
// Create the auxiliary object
final AuxiliaryElements aux = new AuxiliaryElements(osculating.getOrbit(), I);
// Set the force models
for (final DSSTForceModel force : forces) {
force.initialize(aux, false);
dsst.addForceModel(force);
}
dsst.setInitialState(osculating, true);
final Orbit meanOrbit = dsst.mapper.computeMeanOrbit(osculating);
return new SpacecraftState(
meanOrbit,
osculating.getAttitude(),
osculating.getMass(),
osculating.getAdditionalStates());
}
/**
* Launch the computation of short periodics coefficients.
*
* @param state input state
* @throws OrekitException if the computation of a short periodic coefficient fails
* @see {@link DSSTForceModel#computeShortPeriodicsCoefficients(AuxiliaryElements)}
*/
private void computeShortPeriodicsCoefficients(final SpacecraftState state)
throws OrekitException {
final AuxiliaryElements aux = new AuxiliaryElements(state.getOrbit(), I);
for (final DSSTForceModel forceModel : forceModels) {
forceModel.initializeStep(aux);
forceModel.computeShortPeriodicsCoefficients(state);
}
}
/* (non-Javadoc)
* @see org.orekit.propagation.sampling.OrekitFixedStepHandler#handleStep(org.orekit.propagation.SpacecraftState, boolean)
*/
public void handleStep(SpacecraftState currentState, boolean isLast) throws PropagationException {
/** Create position vector. */
D3Vector position =
new D3Vector(
"",
"Position",
"Position",
"The orbital position of the satellite at the given time.",
currentState.getOrbit().getPVCoordinates().getPosition().getX(),
currentState.getOrbit().getPVCoordinates().getPosition().getY(),
currentState.getOrbit().getPVCoordinates().getPosition().getZ());
/** Create velocity vector. */
D3Vector velocity =
new D3Vector(
"",
"Velocity",
"Velocity",
"The orbital velocity of the satellite at the given time",
currentState.getOrbit().getPVCoordinates().getVelocity().getX(),
currentState.getOrbit().getPVCoordinates().getVelocity().getY(),
currentState.getOrbit().getPVCoordinates().getVelocity().getZ());
try {
/** Create orbital state. */
OrbitalState state =
new OrbitalState(
predictor.name,
orbitalStateName,
orbitalStateDescription,
currentState.getDate().toDate(TimeScalesFactory.getUTC()).getTime(),
datasetidentifier,
satellite,
position,
velocity);
/** Send the orbital state on the response stream. */
predictor.addResult(state);
} catch (OrekitException e) {
e.printStackTrace();
}
}
/** {@inheritDoc} */
public SpacecraftState apply(final SpacecraftState state1) {
if (state1.getDate().compareTo(referenceDate) <= 0 && !applyBefore) {
// the orbit change has not occurred yet, don't change anything
return state1;
}
return new SpacecraftState(
updateOrbit(state1.getOrbit()), state1.getAttitude(), state1.getMass());
}
/**
* Compute mean state from osculating state.
*
* <p>Compute in a DSST sense the mean state corresponding to the input osculating state.
*
* <p>The computing is done through a fixed-point iteration process.
*
* @param osculating initial osculating state
* @return mean state
* @throws OrekitException if the underlying computation of short periodic variation fails
*/
private Orbit computeMeanOrbit(final SpacecraftState osculating) throws OrekitException {
// rough initialization of the mean parameters
EquinoctialOrbit meanOrbit = new EquinoctialOrbit(osculating.getOrbit());
// threshold for each parameter
final double epsilon = 1.0e-13;
final double thresholdA = epsilon * (1 + FastMath.abs(meanOrbit.getA()));
final double thresholdE = epsilon * (1 + meanOrbit.getE());
final double thresholdAngles = epsilon * FastMath.PI;
int i = 0;
while (i++ < 200) {
final SpacecraftState meanState =
new SpacecraftState(meanOrbit, osculating.getAttitude(), osculating.getMass());
// recompute the osculating parameters from the current mean parameters
final EquinoctialOrbit rebuilt = (EquinoctialOrbit) computeOsculatingOrbit(meanState);
// adapted parameters residuals
final double deltaA = osculating.getA() - rebuilt.getA();
final double deltaEx = osculating.getEquinoctialEx() - rebuilt.getEquinoctialEx();
final double deltaEy = osculating.getEquinoctialEy() - rebuilt.getEquinoctialEy();
final double deltaHx = osculating.getHx() - rebuilt.getHx();
final double deltaHy = osculating.getHy() - rebuilt.getHy();
final double deltaLm = MathUtils.normalizeAngle(osculating.getLM() - rebuilt.getLM(), 0.0);
// check convergence
if ((FastMath.abs(deltaA) < thresholdA)
&& (FastMath.abs(deltaEx) < thresholdE)
&& (FastMath.abs(deltaEy) < thresholdE)
&& (FastMath.abs(deltaLm) < thresholdAngles)) {
return meanOrbit;
}
// update mean parameters
meanOrbit =
new EquinoctialOrbit(
meanOrbit.getA() + deltaA,
meanOrbit.getEquinoctialEx() + deltaEx,
meanOrbit.getEquinoctialEy() + deltaEy,
meanOrbit.getHx() + deltaHx,
meanOrbit.getHy() + deltaHy,
meanOrbit.getLM() + deltaLm,
PositionAngle.MEAN,
meanOrbit.getFrame(),
meanOrbit.getDate(),
meanOrbit.getMu());
}
throw new PropagationException(OrekitMessages.UNABLE_TO_COMPUTE_DSST_MEAN_PARAMETERS, i);
}
/**
* Simple constructor.
*
* <p>The {@code applyBefore} parameter is mainly used when the differential effect is associated
* with a maneuver. In this case, the parameter must be set to {@code false}.
*
* @param original original state at reference date
* @param directEffect direct effect changing the orbit
* @param applyBefore if true, effect is applied both before and after reference date, if false it
* is only applied after reference date
* @param referenceRadius reference radius of the Earth for the potential model (m)
* @param mu central attraction coefficient (m³/s²)
* @param j2 un-normalized zonal coefficient (about +1.08e-3 for Earth)
* @exception OrekitException if direct effect cannot be applied
*/
public J2DifferentialEffect(
final SpacecraftState original,
final AdapterPropagator.DifferentialEffect directEffect,
final boolean applyBefore,
final double referenceRadius,
final double mu,
final double j2)
throws OrekitException {
this(
original.getOrbit(),
directEffect.apply(original.shiftedBy(0.001)).getOrbit().shiftedBy(-0.001),
applyBefore,
referenceRadius,
mu,
j2);
}
/** {@inheritDoc} */
@Override
public void mapStateToArray(final SpacecraftState state, final double[] y)
throws OrekitException {
final Orbit meanOrbit;
if (!initialIsOsculating) {
// the state is considered to be already a mean state
meanOrbit = state.getOrbit();
} else {
// the state is considered to be an osculating state
meanOrbit = computeMeanState(state, forceModels).getOrbit();
}
OrbitType.EQUINOCTIAL.mapOrbitToArray(meanOrbit, PositionAngle.MEAN, y);
y[6] = state.getMass();
}
/**
* Compute osculating state from mean state.
*
* <p>Compute and add the short periodic variation to the mean {@link SpacecraftState}.
*
* @param meanState initial mean state
* @return osculating state
* @throws OrekitException if the computation of the short-periodic variation fails
*/
private Orbit computeOsculatingOrbit(final SpacecraftState meanState) throws OrekitException {
resetShortPeriodicsCoefficients();
computeShortPeriodicsCoefficients(meanState);
final double[] mean = new double[6];
OrbitType.EQUINOCTIAL.mapOrbitToArray(meanState.getOrbit(), PositionAngle.MEAN, mean);
final double[] y = mean.clone();
for (final DSSTForceModel forceModel : this.forceModels) {
final double[] shortPeriodic =
forceModel.getShortPeriodicVariations(meanState.getDate(), mean);
for (int i = 0; i < shortPeriodic.length; i++) {
y[i] += shortPeriodic[i];
}
}
return OrbitType.EQUINOCTIAL.mapArrayToOrbit(
y, PositionAngle.MEAN, meanState.getDate(), meanState.getMu(), meanState.getFrame());
}
private PVCoordinates propagateInType(
SpacecraftState state, double dP, OrbitType type, PositionAngle angle)
throws PropagationException {
final double dt = 3200;
final double minStep = 0.001;
final double maxStep = 1000;
double[][] tol = NumericalPropagator.tolerances(dP, state.getOrbit(), type);
AdaptiveStepsizeIntegrator integrator =
new DormandPrince853Integrator(minStep, maxStep, tol[0], tol[1]);
NumericalPropagator newPropagator = new NumericalPropagator(integrator);
newPropagator.setOrbitType(type);
newPropagator.setPositionAngleType(angle);
newPropagator.setInitialState(state);
for (ForceModel force : propagator.getForceModels()) {
newPropagator.addForceModel(force);
}
return newPropagator.propagate(state.getDate().shiftedBy(dt)).getPVCoordinates();
}