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