RadiationPressureModel.java

/* Copyright 2022-2025 Romain Serra
 * 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 org.hipparchus.CalculusFieldElement;
import org.hipparchus.Field;
import org.hipparchus.geometry.euclidean.threed.FieldVector3D;
import org.hipparchus.geometry.euclidean.threed.Vector3D;
import org.orekit.propagation.FieldSpacecraftState;
import org.orekit.propagation.SpacecraftState;
import org.orekit.propagation.events.EventDetector;
import org.orekit.propagation.events.FieldEventDetector;
import org.orekit.time.AbsoluteDate;
import org.orekit.time.FieldAbsoluteDate;
import org.orekit.utils.ParameterDriver;

import java.util.List;
import java.util.stream.Stream;

/**
 * Class representing a light-induced radiation pressure force, by leveraging on a given flux model.
 *
 * <p>
 *     This class should not be used in addition to {@link SolarRadiationPressure}, which is another way of
 *     representing the same orbital perturbation.
 * </p>
 *
 * @author Romain Serra
 * @see LightFluxModel
 * @see RadiationSensitive
 * @since 12.1
 */
public class RadiationPressureModel implements RadiationForceModel {

    /**
     * Light flux model (including eclipse conditions).
     */
    private final LightFluxModel lightFluxModel;

    /**
     * Object defining radiation properties defining the acceleration from the pressure.
     */
    private final RadiationSensitive radiationSensitive;

    /**
     * Constructor.
     * @param lightFluxModel model for light flux
     * @param radiationSensitive object defining radiation properties
     */
    public RadiationPressureModel(final LightFluxModel lightFluxModel,
                                  final RadiationSensitive radiationSensitive) {
        this.lightFluxModel = lightFluxModel;
        this.radiationSensitive = radiationSensitive;
    }

    /**
     * Getter for radiation sensitive object.
     * @return radiation sensitive object
     */
    public RadiationSensitive getRadiationSensitive() {
        return radiationSensitive;
    }

    /**
     * Getter for light flux model.
     * @return flux model
     */
    public LightFluxModel getLightFluxModel() {
        return lightFluxModel;
    }

    /** {@inheritDoc} */
    @Override
    public boolean dependsOnPositionOnly() {
        return radiationSensitive instanceof IsotropicRadiationClassicalConvention || radiationSensitive instanceof IsotropicRadiationCNES95Convention || radiationSensitive instanceof IsotropicRadiationSingleCoefficient;
    }

    /** {@inheritDoc} */
    @Override
    public void init(final SpacecraftState initialState, final AbsoluteDate target) {
        RadiationForceModel.super.init(initialState, target);
        lightFluxModel.init(initialState, target);
    }

    /** {@inheritDoc} */
    @Override
    public <T extends CalculusFieldElement<T>> void init(final FieldSpacecraftState<T> initialState,
                                                         final FieldAbsoluteDate<T> target) {
        RadiationForceModel.super.init(initialState, target);
        lightFluxModel.init(initialState, target);
    }

    /** {@inheritDoc} */
    @Override
    public Vector3D acceleration(final SpacecraftState s, final double[] parameters) {
        final Vector3D fluxVector = lightFluxModel.getLightFluxVector(s);
        return radiationSensitive.radiationPressureAcceleration(s, fluxVector, parameters);
    }

    /** {@inheritDoc} */
    @Override
    public <T extends CalculusFieldElement<T>> FieldVector3D<T> acceleration(final FieldSpacecraftState<T> s, final T[] parameters) {
        final FieldVector3D<T> fluxVector = lightFluxModel.getLightFluxVector(s);
        return radiationSensitive.radiationPressureAcceleration(s, fluxVector, parameters);
    }

    /** {@inheritDoc} */
    @Override
    public List<ParameterDriver> getParametersDrivers() {
        return radiationSensitive.getRadiationParametersDrivers();
    }

    /** {@inheritDoc} */
    @Override
    public Stream<EventDetector> getEventDetectors() {
        final List<EventDetector> eventDetectors = lightFluxModel.getEclipseConditionsDetector();
        return Stream.concat(RadiationForceModel.super.getEventDetectors(), eventDetectors.stream());
    }

    /** {@inheritDoc} */
    @Override
    public <T extends CalculusFieldElement<T>> Stream<FieldEventDetector<T>> getFieldEventDetectors(final Field<T> field) {
        final List<FieldEventDetector<T>> eventDetectors = lightFluxModel.getFieldEclipseConditionsDetector(field);
        return Stream.concat(RadiationForceModel.super.getFieldEventDetectors(field), eventDetectors.stream());
    }
}