oomph::IMRBase Class Reference

Implicit midpoint rule base class for the two implementations. More...

#include <implicit_midpoint_rule.h>

Inheritance diagram for oomph::IMRBase:

Public Member Functions
	IMRBase (const bool &adaptive=false)
	Constructor with initialisation. More...
virtual	~IMRBase ()
	Destructor. More...
virtual void	set_weights ()=0
	Setup weights for time derivative calculations. More...
virtual unsigned	nprev_values_for_value_at_evaluation_time () const =0
unsigned	order () const
	Actual order (accuracy) of the scheme. More...
unsigned	ndt () const
	Number of timestep increments that are required by the scheme. More...
unsigned	nprev_values () const
	??ds More...
void	shift_time_values (Data *const &data_pt)
void	shift_time_positions (Node *const &node_pt)
void	set_error_weights ()
void	set_predictor_weights ()
void	assign_initial_values_impulsive (Data *const &data_pt)
	not implemented (??ds TODO) More...
void	assign_initial_positions_impulsive (Node *const &node_pt)
void	calculate_predicted_positions (Node *const &node_pt)
double	temporal_error_in_position (Node *const &node_pt, const unsigned &i)
void	calculate_predicted_values (Data *const &data_pt)
double	temporal_error_in_value (Data *const &data_pt, const unsigned &i)
Public Member Functions inherited from oomph::TimeStepper
	TimeStepper (const unsigned &tstorage, const unsigned &max_deriv)
	TimeStepper ()
	Broken empty constructor. More...
	TimeStepper (const TimeStepper &)=delete
	Broken copy constructor. More...
void	operator= (const TimeStepper &)=delete
	Broken assignment operator. More...
virtual	~TimeStepper ()
	virtual destructor More...
unsigned	highest_derivative () const
	Highest order derivative that the scheme can compute. More...
double &	time ()
	Return current value of continous time. More...
double	time () const
	Return current value of continous time. More...
void	make_steady ()
bool	is_steady () const
bool	predict_by_explicit_step () const
ExplicitTimeStepper *	explicit_predictor_pt ()
void	set_predictor_pt (ExplicitTimeStepper *_pred_pt)
void	update_predicted_time (const double &new_time)
void	check_predicted_values_up_to_date () const
	Check that the predicted values are the ones we want. More...
unsigned	predictor_storage_index () const
void	enable_warning_in_assign_initial_data_values ()
void	disable_warning_in_assign_initial_data_values ()
const DenseMatrix< double > *	weights_pt () const
	Get a (const) pointer to the weights. More...
virtual void	undo_make_steady ()
std::string	type () const
void	time_derivative (const unsigned &i, Data *const &data_pt, Vector< double > &deriv)
double	time_derivative (const unsigned &i, Data *const &data_pt, const unsigned &j)
	Evaluate i-th derivative of j-th value in Data. More...
void	time_derivative (const unsigned &i, Node *const &node_pt, Vector< double > &deriv)
double	time_derivative (const unsigned &i, Node *const &node_pt, const unsigned &j)
Time *const &	time_pt () const
	Access function for the pointer to time (const version) More...
Time *&	time_pt ()
virtual double	weight (const unsigned &i, const unsigned &j) const
	Access function for j-th weight for the i-th derivative. More...
unsigned	ntstorage () const
bool	adaptive_flag () const
	Function to indicate whether the scheme is adaptive (false by default) More...
virtual void	actions_before_timestep (Problem *problem_pt)
virtual void	actions_after_timestep (Problem *problem_pt)

Additional Inherited Members
Protected Attributes inherited from oomph::TimeStepper
Time *	Time_pt
	Pointer to discrete time storage scheme. More...
DenseMatrix< double >	Weight
	Storage for the weights associated with the timestepper. More...
std::string	Type
bool	Adaptive_Flag
bool	Is_steady
bool	Shut_up_in_assign_initial_data_values
bool	Predict_by_explicit_step
ExplicitTimeStepper *	Explicit_predictor_pt
double	Predicted_time
int	Predictor_storage_index

Detailed Description

Implicit midpoint rule base class for the two implementations.

Constructor & Destructor Documentation

IMRBase()

oomph::IMRBase::IMRBase ( const bool &  adaptive = false )

inline

Constructor with initialisation.

      : TimeStepper(2, 1) // initialise weights later
    {
      Adaptive_Flag = adaptive;
      Is_steady = false;
      Type = "Midpoint method";
      Predict_by_explicit_step = true;
 
      // If adaptive then we are storing predicted values in slot
      // 4. Otherwise we aren't storing them so leave it as -1.
      if (adaptive)
      {
        Predictor_storage_index = 4;
      }
 
 
      // Storage for weights needs to be 2x(2 + 0/2) (the +2 is extra history
      // for ebdf3 predictor if adaptive). This means we provide ways to
      // calculate the zeroth and first derivatives and in calculations we
      // use 2 + 0/2 time values.
 
      // But actually (for some reason...) the amount of data storage
      // allocated for the timestepper in each node is determined by the
      // size of weight. So we need to store an extra dummy entry in order
      // to have storage space for the predicted value at t_{n+1}.
 
      // Just leave space for predictor values anyway, it's not expensive.
      Weight.resize(2, 5, 0.0);
 
      // Assume that set_weights() or make_steady() is called before use to
      // set up the values stored in Weight.
    }

References Global_Physical_Variables::adaptive, oomph::TimeStepper::Adaptive_Flag, oomph::TimeStepper::Is_steady, oomph::TimeStepper::Predict_by_explicit_step, oomph::TimeStepper::Predictor_storage_index, oomph::DenseMatrix< T >::resize(), oomph::TimeStepper::Type, and oomph::TimeStepper::Weight.

~IMRBase()

virtual oomph::IMRBase::~IMRBase ( )

inlinevirtual

Destructor.

{}

Member Function Documentation

assign_initial_positions_impulsive()

void oomph::IMRBase::assign_initial_positions_impulsive ( Node *const &  node_pt )

inlinevirtual

Initialiset the positions for the node corresponding to an impulsive start

Implements oomph::TimeStepper.

    {
      std::string err = "Not implemented";
      throw OomphLibError(
        err, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }

References OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::Global_string_for_annotation::string().

assign_initial_values_impulsive()

void oomph::IMRBase::assign_initial_values_impulsive ( Data *const &  data_pt )

inlinevirtual

not implemented (??ds TODO)

Implements oomph::TimeStepper.

    {
      std::string err = "Not implemented";
      throw OomphLibError(
        err, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }

References OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::Global_string_for_annotation::string().

calculate_predicted_positions()

void oomph::IMRBase::calculate_predicted_positions ( Node *const &  node_pt )

inlinevirtual

Do the predictor step for the positions at a node (currently empty — overwrite for a specific scheme)

Reimplemented from oomph::TimeStepper.

    {
      std::string err = "Not implemented";
      throw OomphLibError(
        err, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }

References OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::Global_string_for_annotation::string().

calculate_predicted_values()

void oomph::IMRBase::calculate_predicted_values ( Data *const &  data_pt )

virtual

Dummy - just check that the values that problem::calculate_predicted_values() has been called right.

Reimplemented from oomph::TimeStepper.

  {
    if (adaptive_flag())
    {
      // Can't do it here, but we can check that the predicted values have
      // been updated.
      check_predicted_values_up_to_date();
    }
  }

References oomph::TimeStepper::adaptive_flag(), and oomph::TimeStepper::check_predicted_values_up_to_date().

ndt()

unsigned oomph::IMRBase::ndt ( ) const

inlinevirtual

Number of timestep increments that are required by the scheme.

Implements oomph::TimeStepper.

    {
      return nprev_values();
    }

References nprev_values().

Referenced by shift_time_positions(), and shift_time_values().

nprev_values()

unsigned oomph::IMRBase::nprev_values ( ) const

inlinevirtual

??ds

Implements oomph::TimeStepper.

    {
      return 4;
    }

Referenced by ndt().

nprev_values_for_value_at_evaluation_time()

virtual unsigned oomph::IMRBase::nprev_values_for_value_at_evaluation_time ( ) const

pure virtual

Number of history values to interpolate over to get the "current" value.

Reimplemented from oomph::TimeStepper.

Implemented in oomph::IMRByBDF, and oomph::IMR.

order()

unsigned oomph::IMRBase::order ( ) const

inlinevirtual

Actual order (accuracy) of the scheme.

Reimplemented from oomph::TimeStepper.

    {
      return 2;
    }

set_error_weights()

void oomph::IMRBase::set_error_weights ( )

inlinevirtual

Set the weights for the error computation. This is not used by midpoint rule.

Reimplemented from oomph::TimeStepper.

{}

set_predictor_weights()

void oomph::IMRBase::set_predictor_weights ( )

inlinevirtual

Set the weights for the predictor previous timestep. This is not used by midpint rule.

Reimplemented from oomph::TimeStepper.

{}

set_weights()

virtual void oomph::IMRBase::set_weights ( )

pure virtual

Setup weights for time derivative calculations.

Implements oomph::TimeStepper.

Implemented in oomph::IMRByBDF, and oomph::IMR.

shift_time_positions()

void oomph::IMRBase::shift_time_positions ( Node *const &  node_pt )

virtual

This function advances the time history of the positions at a node.

This function advances the time history of the positions at a node. ??ds Untested: I have no problems with moving nodes.

Implements oomph::TimeStepper.

  {
    // Find the number of coordinates
    unsigned n_dim = node_pt->ndim();
    // Find the number of position types
    unsigned n_position_type = node_pt->nposition_type();
 
    // Find number of stored timesteps
    unsigned n_tstorage = ntstorage();
 
    // Storage for the velocity
    double velocity[n_position_type][n_dim];
 
    // If adaptive, find the velocities
    if (adaptive_flag())
    {
      // Loop over the variables
      for (unsigned i = 0; i < n_dim; i++)
      {
        for (unsigned k = 0; k < n_position_type; k++)
        {
          // Initialise velocity to zero
          velocity[k][i] = 0.0;
          // Loop over all history data
          for (unsigned t = 0; t < n_tstorage; t++)
          {
            velocity[k][i] += Weight(1, t) * node_pt->x_gen(t, k, i);
          }
        }
      }
    }
 
    // Loop over the positions
    for (unsigned i = 0; i < n_dim; i++)
    {
      // If the position is not a copy
      if (node_pt->position_is_a_copy(i) == false)
      {
        // Loop over the position types
        for (unsigned k = 0; k < n_position_type; k++)
        {
          // Loop over stored times, and set values to previous values
          for (unsigned t = ndt(); t > 0; t--)
          {
            node_pt->x_gen(t, k, i) = node_pt->x_gen(t - 1, k, i);
          }
        }
      }
    }
  }

References oomph::TimeStepper::adaptive_flag(), i, k, oomph::Node::ndim(), ndt(), oomph::Node::nposition_type(), oomph::TimeStepper::ntstorage(), oomph::Node::position_is_a_copy(), plotPSD::t, Jeffery_Solution::velocity(), oomph::TimeStepper::Weight, and oomph::Node::x_gen().

shift_time_values()

void oomph::IMRBase::shift_time_values ( Data *const &  data_pt )

virtual

This function advances the Data's time history so that we can move on to the next timestep

Implements oomph::TimeStepper.

  {
    // Loop over the values, set previous values to the previous value, if
    // not a copy.
    for (unsigned j = 0, nj = data_pt->nvalue(); j < nj; j++)
    {
      if (!data_pt->is_a_copy(j))
      {
        for (unsigned t = ndt(); t > 0; t--)
        {
          data_pt->set_value(t, j, data_pt->value(t - 1, j));
        }
      }
    }
  }

References oomph::Data::is_a_copy(), j, ndt(), oomph::Data::nvalue(), oomph::Data::set_value(), plotPSD::t, and oomph::Data::value().

temporal_error_in_position()

double oomph::IMRBase::temporal_error_in_position ( Node *const &  node_pt, const unsigned &  i  )

inlinevirtual

Compute the error in the position i at a node zero here – overwrite for specific scheme.

Reimplemented from oomph::TimeStepper.

    {
      std::string err = "Not implemented";
      throw OomphLibError(
        err, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }

References OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::Global_string_for_annotation::string().

temporal_error_in_value()

double oomph::IMRBase::temporal_error_in_value ( Data *const &  data_pt, const unsigned &  i  )

virtual

Compute the error in the value i in a Data structure zero here – overwrite for specific scheme.

Reimplemented from oomph::TimeStepper.

  {
    if (adaptive_flag())
    {
      // predicted value is more accurate so just compare with that
      return data_pt->value(i) - data_pt->value(Predictor_storage_index, i);
    }
    else
    {
      std::string err("Tried to get the temporal error from a non-adaptive");
      err += " time stepper.";
      throw OomphLibError(
        err, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
  }

References oomph::TimeStepper::adaptive_flag(), i, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::TimeStepper::Predictor_storage_index, oomph::Global_string_for_annotation::string(), and oomph::Data::value().

---

The documentation for this class was generated from the following files:

• implicit_midpoint_rule.h
• implicit_midpoint_rule.cc