All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.apache.commons.math3.ode.sampling.AbstractFieldStepInterpolator Maven / Gradle / Ivy

There is a newer version: 2.12.15
Show newest version
/*
 * 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.math3.ode.sampling;

import org.apache.commons.math3.RealFieldElement;
import org.apache.commons.math3.exception.MaxCountExceededException;
import org.apache.commons.math3.ode.FieldEquationsMapper;
import org.apache.commons.math3.ode.FieldODEStateAndDerivative;

/** This abstract class represents an interpolator over the last step
 * during an ODE integration.
 *
 * 

The various ODE integrators provide objects extending this class * to the step handlers. The handlers can use these objects to * retrieve the state vector at intermediate times between the * previous and the current grid points (dense output).

* * @see org.apache.commons.math3.ode.FirstOrderFieldIntegrator * @see StepHandler * * @param the type of the field elements * @since 3.6 */ public abstract class AbstractFieldStepInterpolator> implements FieldStepInterpolator { /** Global previous state. */ private final FieldODEStateAndDerivative globalPreviousState; /** Global current state. */ private final FieldODEStateAndDerivative globalCurrentState; /** Soft previous state. */ private final FieldODEStateAndDerivative softPreviousState; /** Soft current state. */ private final FieldODEStateAndDerivative softCurrentState; /** integration direction. */ private final boolean forward; /** Mapper for ODE equations primary and secondary components. */ private FieldEquationsMapper mapper; /** Simple constructor. * @param isForward integration direction indicator * @param globalPreviousState start of the global step * @param globalCurrentState end of the global step * @param softPreviousState start of the restricted step * @param softCurrentState end of the restricted step * @param equationsMapper mapper for ODE equations primary and secondary components */ protected AbstractFieldStepInterpolator(final boolean isForward, final FieldODEStateAndDerivative globalPreviousState, final FieldODEStateAndDerivative globalCurrentState, final FieldODEStateAndDerivative softPreviousState, final FieldODEStateAndDerivative softCurrentState, final FieldEquationsMapper equationsMapper) { this.forward = isForward; this.globalPreviousState = globalPreviousState; this.globalCurrentState = globalCurrentState; this.softPreviousState = softPreviousState; this.softCurrentState = softCurrentState; this.mapper = equationsMapper; } /** Create a new restricted version of the instance. *

* The instance is not changed at all. *

* @param previousState start of the restricted step * @param currentState end of the restricted step * @return restricted version of the instance * @see #getPreviousState() * @see #getCurrentState() */ public AbstractFieldStepInterpolator restrictStep(final FieldODEStateAndDerivative previousState, final FieldODEStateAndDerivative currentState) { return create(forward, globalPreviousState, globalCurrentState, previousState, currentState, mapper); } /** Create a new instance. * @param newForward integration direction indicator * @param newGlobalPreviousState start of the global step * @param newGlobalCurrentState end of the global step * @param newSoftPreviousState start of the restricted step * @param newSoftCurrentState end of the restricted step * @param newMapper equations mapper for the all equations * @return a new instance */ protected abstract AbstractFieldStepInterpolator create(boolean newForward, FieldODEStateAndDerivative newGlobalPreviousState, FieldODEStateAndDerivative newGlobalCurrentState, FieldODEStateAndDerivative newSoftPreviousState, FieldODEStateAndDerivative newSoftCurrentState, FieldEquationsMapper newMapper); /** * Get the previous global grid point state. * @return previous global grid point state */ public FieldODEStateAndDerivative getGlobalPreviousState() { return globalPreviousState; } /** * Get the current global grid point state. * @return current global grid point state */ public FieldODEStateAndDerivative getGlobalCurrentState() { return globalCurrentState; } /** {@inheritDoc} */ public FieldODEStateAndDerivative getPreviousState() { return softPreviousState; } /** {@inheritDoc} */ public FieldODEStateAndDerivative getCurrentState() { return softCurrentState; } /** {@inheritDoc} */ public FieldODEStateAndDerivative getInterpolatedState(final T time) { final T thetaH = time.subtract(globalPreviousState.getTime()); final T oneMinusThetaH = globalCurrentState.getTime().subtract(time); final T theta = thetaH.divide(globalCurrentState.getTime().subtract(globalPreviousState.getTime())); return computeInterpolatedStateAndDerivatives(mapper, time, theta, thetaH, oneMinusThetaH); } /** {@inheritDoc} */ public boolean isForward() { return forward; } /** Compute the state and derivatives at the interpolated time. * This is the main processing method that should be implemented by * the derived classes to perform the interpolation. * @param equationsMapper mapper for ODE equations primary and secondary components * @param time interpolation time * @param theta normalized interpolation abscissa within the step * (theta is zero at the previous time step and one at the current time step) * @param thetaH time gap between the previous time and the interpolated time * @param oneMinusThetaH time gap between the interpolated time and * the current time * @return interpolated state and derivatives * @exception MaxCountExceededException if the number of functions evaluations is exceeded */ protected abstract FieldODEStateAndDerivative computeInterpolatedStateAndDerivatives(FieldEquationsMapper equationsMapper, T time, T theta, T thetaH, T oneMinusThetaH) throws MaxCountExceededException; }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy