Rythmos_IntegrationObserverBase.hpp

 
#ifndef RYTHMOS_INTEGRATION_OBSERVER_BASE_HPP
#define RYTHMOS_INTEGRATION_OBSERVER_BASE_HPP
 
#include "Rythmos_Types.hpp"
#include "Teuchos_Describable.hpp"
#include "Teuchos_VerboseObject.hpp"
 
namespace Rythmos {
 
 
// Forwards
template<class Scalar> class TimeRange;
template<class Scalar> class StepControlInfo;
template<class Scalar> class StepperBase;
 

template<class Scalar>
class IntegrationObserverBase
  : virtual public Teuchos::Describable,
    virtual public Teuchos::VerboseObject<IntegrationObserverBase<Scalar> >
{
public:

  virtual RCP<IntegrationObserverBase<Scalar> >
  cloneIntegrationObserver() const = 0;

  virtual void resetIntegrationObserver(
    const TimeRange<Scalar> &integrationTimeDomain
    // ToDo: Pass in the initial condition to the observer
    ) = 0;

  virtual void observeStartTimeIntegration(
    const StepperBase<Scalar> &stepper);

  virtual void observeEndTimeIntegration(
    const StepperBase<Scalar> &stepper);
 
  // ToDo: add observeStartTimeStep(stepper, ...)
  virtual void observeStartTimeStep(
    const StepperBase<Scalar> &stepper,
    const StepControlInfo<Scalar> &stepCtrlInfo,
    const int timeStepIter
    );

  virtual void observeCompletedTimeStep(
    const StepperBase<Scalar> &stepper,
    const StepControlInfo<Scalar> &stepCtrlInfo,
    const int timeStepIter
    ) = 0;

  virtual void observeFailedTimeStep(
    const StepperBase<Scalar> &stepper,
    const StepControlInfo<Scalar> &stepCtrlInfo,
    const int timeStepIter
    );
 
};
 

template<class Scalar>
bool isInitialTimeStep(
  const TimeRange<Scalar> &currentTimeRange,
  const TimeRange<Scalar> &fullTimeRange
  )
{
  typedef Teuchos::ScalarTraits<Scalar> ST;
  return compareTimeValues(currentTimeRange.lower(), fullTimeRange.lower()) == ST::zero();
}
 

template<class Scalar>
bool isFinalTimeStep(
  const TimeRange<Scalar> &currentTimeRange,
  const TimeRange<Scalar> &fullTimeRange
  )
{
  typedef Teuchos::ScalarTraits<Scalar> ST;
  return compareTimeValues(currentTimeRange.upper(), fullTimeRange.upper()) >= ST::zero();
}
 
 
// /////////////////////////////////////////////////////////////
/*  Default implementations for backwards compatibility
 
   Some of the observer methods were added after rythmos was released.
   Even though all methods should be pure virtual, we provide a
   default implementation here for the recently added methods to
   maintain backwards compatibility.  These should be removed in the
   future.
*/
 
template<class Scalar>
void IntegrationObserverBase<Scalar>::
observeStartTimeIntegration(const StepperBase<Scalar> &/* stepper */)
{
 
}    
 
template<class Scalar>
void IntegrationObserverBase<Scalar>::
observeEndTimeIntegration(const StepperBase<Scalar> &/* stepper */)
{
 
}    
 
template<class Scalar>
void IntegrationObserverBase<Scalar>::
observeStartTimeStep(
    const StepperBase<Scalar> &/* stepper */,
    const StepControlInfo<Scalar> &/* stepCtrlInfo */,
    const int /* timeStepIter */
    )
{
 
}    
 
template<class Scalar>
void IntegrationObserverBase<Scalar>::
observeFailedTimeStep(
    const StepperBase<Scalar> &/* stepper */,
    const StepControlInfo<Scalar> &/* stepCtrlInfo */,
    const int /* timeStepIter */
    )
{
 
}    
 
 
} // namespace Rythmos
 
 
#endif // RYTHMOS_INTEGRATION_OBSERVER_BASE_HPP