Class FieldEventState<T extends RealFieldElement<T>>

  • Type Parameters:
    T - the type of the field elements

    public class FieldEventState<T extends RealFieldElement<T>>
    extends java.lang.Object
    This class handles the state for one event handler during integration steps.

    Each time the integrator proposes a step, the event handler switching function should be checked. This class handles the state of one handler during one integration step, with references to the state at the end of the preceding step. This information is used to decide if the handler should trigger an event or not during the proposed step.

    Since:
    3.6
    • Field Detail

      • maxCheckInterval

        private final double maxCheckInterval
        Maximal time interval between events handler checks.
      • convergence

        private final T extends RealFieldElement<T> convergence
        Convergence threshold for event localization.
      • maxIterationCount

        private final int maxIterationCount
        Upper limit in the iteration count for event localization.
      • g0

        private T extends RealFieldElement<T> g0
        Value of the events handler at the beginning of the step.
      • g0Positive

        private boolean g0Positive
        Simulated sign of g0 (we cheat when crossing events).
      • pendingEvent

        private boolean pendingEvent
        Indicator of event expected during the step.
      • pendingEventTime

        private T extends RealFieldElement<T> pendingEventTime
        Occurrence time of the pending event.
      • previousEventTime

        private T extends RealFieldElement<T> previousEventTime
        Occurrence time of the previous event.
      • forward

        private boolean forward
        Integration direction.
      • increasing

        private boolean increasing
        Variation direction around pending event. (this is considered with respect to the integration direction)
      • nextAction

        private Action nextAction
        Next action indicator.
    • Constructor Detail

      • FieldEventState

        public FieldEventState​(FieldEventHandler<T> handler,
                               double maxCheckInterval,
                               T convergence,
                               int maxIterationCount,
                               BracketedRealFieldUnivariateSolver<T> solver)
        Simple constructor.
        Parameters:
        handler - event handler
        maxCheckInterval - maximal time interval between switching function checks (this interval prevents missing sign changes in case the integration steps becomes very large)
        convergence - convergence threshold in the event time search
        maxIterationCount - upper limit of the iteration count in the event time search
        solver - Root-finding algorithm to use to detect state events
    • Method Detail

      • getEventHandler

        public FieldEventHandler<T> getEventHandler()
        Get the underlying event handler.
        Returns:
        underlying event handler
      • getMaxCheckInterval

        public double getMaxCheckInterval()
        Get the maximal time interval between events handler checks.
        Returns:
        maximal time interval between events handler checks
      • getConvergence

        public T getConvergence()
        Get the convergence threshold for event localization.
        Returns:
        convergence threshold for event localization
      • getMaxIterationCount

        public int getMaxIterationCount()
        Get the upper limit in the iteration count for event localization.
        Returns:
        upper limit in the iteration count for event localization
      • getEventTime

        public T getEventTime()
        Get the occurrence time of the event triggered in the current step.
        Returns:
        occurrence time of the event triggered in the current step or infinity if no events are triggered
      • stepAccepted

        public void stepAccepted​(FieldODEStateAndDerivative<T> state)
        Acknowledge the fact the step has been accepted by the integrator.
        Parameters:
        state - state at the end of the step
      • stop

        public boolean stop()
        Check if the integration should be stopped at the end of the current step.
        Returns:
        true if the integration should be stopped
      • reset

        public FieldODEState<T> reset​(FieldODEStateAndDerivative<T> state)
        Let the event handler reset the state if it wants.
        Parameters:
        state - state at the beginning of the next step
        Returns:
        reset state (may by the same as initial state if only derivatives should be reset), or null if nothing is reset