diff options
Diffstat (limited to 'src/main/java/org/apache/commons/math/ode/events/CombinedEventsManager.java')
| -rw-r--r-- | src/main/java/org/apache/commons/math/ode/events/CombinedEventsManager.java | 249 |
1 files changed, 249 insertions, 0 deletions
diff --git a/src/main/java/org/apache/commons/math/ode/events/CombinedEventsManager.java b/src/main/java/org/apache/commons/math/ode/events/CombinedEventsManager.java new file mode 100644 index 0000000..1886702 --- /dev/null +++ b/src/main/java/org/apache/commons/math/ode/events/CombinedEventsManager.java @@ -0,0 +1,249 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF 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.apache.commons.math.ode.events; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; + +import org.apache.commons.math.ConvergenceException; +import org.apache.commons.math.ode.DerivativeException; +import org.apache.commons.math.ode.IntegratorException; +import org.apache.commons.math.ode.sampling.StepInterpolator; + +/** This class manages several {@link EventHandler event handlers} during integration. + * + * @see EventHandler + * @see EventState + * @version $Revision: 1073158 $ $Date: 2011-02-21 22:46:52 +0100 (lun. 21 févr. 2011) $ + * @since 1.2 + * @deprecated as of 2.2, this class is not used anymore + */ +@Deprecated +public class CombinedEventsManager { + + /** Events states. */ + private final List<EventState> states; + + /** First active event. */ + private EventState first; + + /** Initialization indicator. */ + private boolean initialized; + + /** Simple constructor. + * Create an empty manager + */ + public CombinedEventsManager() { + states = new ArrayList<EventState>(); + first = null; + initialized = false; + } + + /** Add an events handler. + * @param handler event handler + * @param maxCheckInterval maximal time interval between events + * checks (this interval prevents missing sign changes in + * case the integration steps becomes very large) + * @param convergence convergence threshold in the event time search + * @param maxIterationCount upper limit of the iteration count in + * the event time search + * @see #getEventsHandlers() + * @see #clearEventsHandlers() + */ + public void addEventHandler(final EventHandler handler, final double maxCheckInterval, + final double convergence, final int maxIterationCount) { + states.add(new EventState(handler, maxCheckInterval, + convergence, maxIterationCount)); + } + + /** Get all the events handlers that have been added to the manager. + * @return an unmodifiable collection of the added event handlers + * @see #addEventHandler(EventHandler, double, double, int) + * @see #clearEventsHandlers() + * @see #getEventsStates() + */ + public Collection<EventHandler> getEventsHandlers() { + final List<EventHandler> list = new ArrayList<EventHandler>(); + for (EventState state : states) { + list.add(state.getEventHandler()); + } + return Collections.unmodifiableCollection(list); + } + + /** Remove all the events handlers that have been added to the manager. + * @see #addEventHandler(EventHandler, double, double, int) + * @see #getEventsHandlers() + */ + public void clearEventsHandlers() { + states.clear(); + } + + /** Get all the events state wrapping the handlers that have been added to the manager. + * @return a collection of the events states + * @see #getEventsHandlers() + */ + public Collection<EventState> getEventsStates() { + return states; + } + + /** Check if the manager does not manage any event handlers. + * @return true if manager is empty + */ + public boolean isEmpty() { + return states.isEmpty(); + } + + /** Evaluate the impact of the proposed step on all managed + * event handlers. + * @param interpolator step interpolator for the proposed step + * @return true if at least one event handler triggers an event + * before the end of the proposed step (this implies the step should + * be rejected) + * @exception DerivativeException if the interpolator fails to + * compute the function somewhere within the step + * @exception IntegratorException if an event cannot be located + */ + public boolean evaluateStep(final StepInterpolator interpolator) + throws DerivativeException, IntegratorException { + + try { + + first = null; + if (states.isEmpty()) { + // there is nothing to do, return now to avoid setting the + // interpolator time (and hence avoid unneeded calls to the + // user function due to interpolator finalization) + return false; + } + + if (! initialized) { + + // initialize the events states + for (EventState state : states) { + state.reinitializeBegin(interpolator); + } + + initialized = true; + + } + + // check events occurrence + for (EventState state : states) { + + if (state.evaluateStep(interpolator)) { + if (first == null) { + first = state; + } else { + if (interpolator.isForward()) { + if (state.getEventTime() < first.getEventTime()) { + first = state; + } + } else { + if (state.getEventTime() > first.getEventTime()) { + first = state; + } + } + } + } + + } + + return first != null; + + } catch (EventException se) { + final Throwable cause = se.getCause(); + if ((cause != null) && (cause instanceof DerivativeException)) { + throw (DerivativeException) cause; + } + throw new IntegratorException(se); + } catch (ConvergenceException ce) { + throw new IntegratorException(ce); + } + + } + + /** Get the occurrence time of the first event triggered in the + * last evaluated step. + * @return occurrence time of the first event triggered in the last + * evaluated step, or </code>Double.NaN</code> if no event is + * triggered + */ + public double getEventTime() { + return (first == null) ? Double.NaN : first.getEventTime(); + } + + /** Inform the event handlers that the step has been accepted + * by the integrator. + * @param t value of the independent <i>time</i> variable at the + * end of the step + * @param y array containing the current value of the state vector + * at the end of the step + * @exception IntegratorException if the value of one of the + * events states cannot be evaluated + */ + public void stepAccepted(final double t, final double[] y) + throws IntegratorException { + try { + for (EventState state : states) { + state.stepAccepted(t, y); + } + } catch (EventException se) { + throw new IntegratorException(se); + } + } + + /** Check if the integration should be stopped at the end of the + * current step. + * @return true if the integration should be stopped + */ + public boolean stop() { + for (EventState state : states) { + if (state.stop()) { + return true; + } + } + return false; + } + + /** Let the event handlers reset the state if they want. + * @param t value of the independent <i>time</i> variable at the + * beginning of the next step + * @param y array were to put the desired state vector at the beginning + * of the next step + * @return true if the integrator should reset the derivatives too + * @exception IntegratorException if one of the events states + * that should reset the state fails to do it + */ + public boolean reset(final double t, final double[] y) + throws IntegratorException { + try { + boolean resetDerivatives = false; + for (EventState state : states) { + if (state.reset(t, y)) { + resetDerivatives = true; + } + } + return resetDerivatives; + } catch (EventException se) { + throw new IntegratorException(se); + } + } + +} |