oomph::BDF< NSTEPS > Class Template Reference

#include <timesteppers.h>

Inheritance diagram for oomph::BDF< NSTEPS >:

Public Types
typedef double(*	InitialConditionFctPt) (const double &t)

Public Member Functions
	BDF (const bool &adaptive=false)
	Constructor for the case when we allow adaptive timestepping. More...
	BDF (const BDF &)=delete
	Broken copy constructor. More...
void	operator= (const BDF &)=delete
	Broken assignment operator. More...
unsigned	order () const
	Return the actual order of the scheme. More...
void	assign_initial_values_impulsive (Data *const &data_pt)
void	assign_initial_positions_impulsive (Node *const &node_pt)
void	assign_initial_data_values (Data *const &data_pt, Vector< InitialConditionFctPt > initial_value_fct)
void	shift_time_values (Data *const &data_pt)
void	shift_time_positions (Node *const &node_pt)
void	set_weights ()
	Set the weights. More...
unsigned	nprev_values () const
	Number of previous values available. More...
unsigned	ndt () const
	Number of timestep increments that need to be stored by the scheme. More...
void	set_predictor_weights ()
	Function to set the predictor weights. More...
void	calculate_predicted_positions (Node *const &node_pt)
	Function to calculate predicted positions at a node. More...
void	calculate_predicted_values (Data *const &data_pt)
	Function to calculate predicted data values in a Data object. More...
void	set_error_weights ()
	Function to set the error weights. More...
double	temporal_error_in_position (Node *const &node_pt, const unsigned &i)
	Compute the error in the position i at a node. More...
double	temporal_error_in_value (Data *const &data_pt, const unsigned &i)
	Compute the error in the value i in a Data structure. More...
void	set_weights ()
	Assign the values of the weights. More...
void	set_predictor_weights ()
	Set the predictor weights (Gresho and Sani pg. 270) More...
void	calculate_predicted_values (Data *const &data_pt)
void	calculate_predicted_positions (Node *const &node_pt)
	Calculate predictions for the positions. More...
void	set_error_weights ()
	Set the error weights (Gresho and Sani pg. 270) More...
double	temporal_error_in_position (Node *const &node_pt, const unsigned &i)
	Function to compute the error in position i at node. More...
double	temporal_error_in_value (Data *const &data_pt, const unsigned &i)
	Function to calculate the error in the data value i. More...
void	set_weights ()
void	set_predictor_weights ()
void	calculate_predicted_values (Data *const &data_pt)
void	calculate_predicted_positions (Node *const &node_pt)
	Calculate predictions for the positions. More...
void	set_error_weights ()
	Function that sets the error weights. More...
double	temporal_error_in_position (Node *const &node_pt, const unsigned &i)
	Function to compute the error in position i at node. More...
double	temporal_error_in_value (Data *const &data_pt, const unsigned &i)
	Function to calculate the error in the data value i. More...
void	set_weights ()
	Assign the values of the weights; pass the value of the timestep. More...
void	set_predictor_weights ()
	Calculate the predictor weights. More...
void	calculate_predicted_values (Data *const &data_pt)
void	calculate_predicted_positions (Node *const &node_pt)
	Calculate predictions for the positions. More...
void	set_error_weights ()
	Function that sets the error weights. More...
double	temporal_error_in_position (Node *const &node_pt, const unsigned &i)
	Function to compute the error in position i at node. More...
double	temporal_error_in_value (Data *const &data_pt, const unsigned &i)
	Function to calculate the error in the data value i. More...
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...
virtual unsigned	nprev_values_for_value_at_evaluation_time () const
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)

Private Attributes
Vector< double >	Predictor_weight
	Private data for the predictor weights. More...
double	Error_weight
	Private data for the error weight. More...

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

template<unsigned NSTEPS>
class oomph::BDF< NSTEPS >

////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// Templated class for BDF-type time-steppers with fixed or variable timestep. 1st time derivative recovered directly from the previous function values. Template parameter represents the number of previous timesteps stored, so that BDF<1> is the classical first order backward Euler scheme. Need to reset weights after every change in timestep.

Member Typedef Documentation

InitialConditionFctPt

template<unsigned NSTEPS>

typedef double(* oomph::BDF< NSTEPS >::InitialConditionFctPt) (const double &t)

Typedef for function that returns the (scalar) initial value at a given value of the continuous time t.

Constructor & Destructor Documentation

BDF() [1/2]

template<unsigned NSTEPS>

oomph::BDF< NSTEPS >::BDF ( const bool &  adaptive = false )

inline

Constructor for the case when we allow adaptive timestepping.

                                      : TimeStepper(NSTEPS + 1, 1)
    {
      Type = "BDF";
 
      // If it's adaptive, we need to allocate additional space to
      // carry along a prediction and an acceleration
      if (adaptive)
      {
        // Set the adaptive flag to be true
        Adaptive_Flag = true;
 
        // Set the size of the Predictor_Weights Vector N.B. The size is
        // correct for BDF1 and 2, but may be wrong for others.
        Predictor_weight.resize(NSTEPS + 2);
 
        // Resize the weights to the appropriate size
        Weight.resize(2, NSTEPS + 3, 0.0);
 
        // Storing predicted values in slot after other information
        Predictor_storage_index = NSTEPS + 2;
      }
 
      // Set the weight for the zero-th derivative
      Weight(0, 0) = 1.0;
    }

References Global_Physical_Variables::adaptive, and ProblemParameters::Weight.

BDF() [2/2]

template<unsigned NSTEPS>

oomph::BDF< NSTEPS >::BDF ( const BDF< NSTEPS > &  )

delete

Broken copy constructor.

Member Function Documentation

assign_initial_data_values()

template<unsigned NSTEPS>

void oomph::BDF< NSTEPS >::assign_initial_data_values ( Data *const &  data_pt, Vector< InitialConditionFctPt >  initial_value_fct  )

inline

Initialise the time-history for the Data values, corresponding to given time history, specified by Vector of function pointers.

    {
      // The time history stores the previous function values
      unsigned n_time_value = ntstorage();
 
      // Find number of values stored
      unsigned n_value = data_pt->nvalue();
 
      // Loop over current and stored timesteps
      for (unsigned t = 0; t < n_time_value; t++)
      {
        // Get corresponding continous time
        double time_local = Time_pt->time(t);
 
        // Loop over values
        for (unsigned j = 0; j < n_value; j++)
        {
          data_pt->set_value(t, j, initial_value_fct[j](time_local));
        }
      }
    }

References j, oomph::Data::nvalue(), oomph::Data::set_value(), plotPSD::t, and Flag_definition::Time_pt.

assign_initial_positions_impulsive()

template<unsigned NSTEPS>

void oomph::BDF< NSTEPS >::assign_initial_positions_impulsive ( Node *const &  node_pt )

inlinevirtual

Initialise the time-history for the nodal positions corresponding to an impulsive start.

Implements oomph::TimeStepper.

    {
      // Find the dimension of the node
      unsigned n_dim = node_pt->ndim();
      // Find the number of position types at the node
      unsigned n_position_type = node_pt->nposition_type();
 
      // Loop over the position variables
      for (unsigned i = 0; i < n_dim; i++)
      {
        // If the position is not copied
        // We copy entire coordinates at once
        if (node_pt->position_is_a_copy(i) == false)
        {
          // Loop over the position types
          for (unsigned k = 0; k < n_position_type; k++)
          {
            // Set previous values to the initial value, if not a copy
            for (unsigned t = 1; t <= NSTEPS; t++)
            {
              node_pt->x_gen(t, k, i) = node_pt->x_gen(k, i);
            }
 
            // If it's adaptive
            if (adaptive_flag())
            {
              // Initial mesh velocity is zero
              node_pt->x_gen(NSTEPS + 1, k, i) = 0.0;
              // Initial prediction is the value
              node_pt->x_gen(NSTEPS + 2, k, i) = node_pt->x_gen(k, i);
            }
          }
        }
      }
    }

References i, k, oomph::Node::ndim(), oomph::Node::nposition_type(), oomph::Node::position_is_a_copy(), plotPSD::t, and oomph::Node::x_gen().

assign_initial_values_impulsive()

template<unsigned NSTEPS>

void oomph::BDF< NSTEPS >::assign_initial_values_impulsive ( Data *const &  data_pt )

inlinevirtual

Initialise the time-history for the Data values, corresponding to an impulsive start.

Implements oomph::TimeStepper.

    {
      // Find number of values stored
      unsigned n_value = data_pt->nvalue();
      // Loop over values
      for (unsigned j = 0; j < n_value; j++)
      {
        // Set previous values to the initial value, if not a copy
        if (data_pt->is_a_copy(j) == false)
        {
          for (unsigned t = 1; t <= NSTEPS; t++)
          {
            data_pt->set_value(t, j, data_pt->value(j));
          }
 
          // If it's adaptive
          if (adaptive_flag())
          {
            // Initial velocity is zero
            data_pt->set_value(NSTEPS + 1, j, 0.0);
            // Initial prediction is the value
            data_pt->set_value(NSTEPS + 2, j, data_pt->value(j));
          }
        }
      }
    }

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

calculate_predicted_positions() [1/4]

void oomph::BDF< 1 >::calculate_predicted_positions ( Node *const &  node_pt )

virtual

Calculate predictions for the positions.

Reimplemented from oomph::TimeStepper.

  {
    // Only do this if adaptive
    if (adaptive_flag())
    {
      // Find number of dimensions of the problem
      unsigned n_dim = node_pt->ndim();
      // Loop over the dimensions
      for (unsigned j = 0; j < n_dim; j++)
      {
        // If the node is not copied
        if (node_pt->position_is_a_copy(j) == false)
        {
          // Initialise the predictor to zero
          double predicted_value = 0.0;
          // Now loop over all the stored data and add appropriate values
          // to the predictor
          for (unsigned i = 1; i < 3; i++)
          {
            predicted_value += node_pt->x(i, j) * Predictor_weight[i];
          }
          // Store the predicted value
          node_pt->x(Predictor_storage_index, j) = predicted_value;
        }
      }
    }
  }

References i, j, oomph::Node::ndim(), oomph::Node::position_is_a_copy(), and oomph::Node::x().

calculate_predicted_positions() [2/4]

void oomph::BDF< 2 >::calculate_predicted_positions ( Node *const &  node_pt )

virtual

Calculate predictions for the positions.

Reimplemented from oomph::TimeStepper.

  {
    // Only do this if adaptive
    if (adaptive_flag())
    {
      // Find number of dimensions of the problem
      unsigned n_dim = node_pt->ndim();
      // Loop over the dimensions
      for (unsigned j = 0; j < n_dim; j++)
      {
        // If the node is not copied
        if (node_pt->position_is_a_copy(j) == false)
        {
          // Initialise the predictor to zero
          double predicted_value = 0.0;
          // Now loop over all the stored data and add appropriate values
          // to the predictor
          for (unsigned i = 1; i < 4; i++)
          {
            predicted_value += node_pt->x(i, j) * Predictor_weight[i];
          }
          // Store the predicted value
          node_pt->x(Predictor_storage_index, j) = predicted_value;
        }
      }
    }
  }

References i, j, oomph::Node::ndim(), oomph::Node::position_is_a_copy(), and oomph::Node::x().

calculate_predicted_positions() [3/4]

void oomph::BDF< 4 >::calculate_predicted_positions ( Node *const &  node_pt )

virtual

Calculate predictions for the positions.

Reimplemented from oomph::TimeStepper.

  {
    throw OomphLibError(
      "Not implemented yet", OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
  }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

calculate_predicted_positions() [4/4]

template<unsigned NSTEPS>

void oomph::BDF< NSTEPS >::calculate_predicted_positions ( Node *const &  node_pt )

virtual

Function to calculate predicted positions at a node.

Reimplemented from oomph::TimeStepper.

calculate_predicted_values() [1/4]

void oomph::BDF< 1 >::calculate_predicted_values ( Data *const &  data_pt )

virtual

Calculate the predicted values and store them at the appropriate location in the data structure This function must be called after the time-values have been shifted!

Reimplemented from oomph::TimeStepper.

  {
    // If it's adaptive calculate the values
    if (adaptive_flag())
    {
      // Find number of values
      unsigned n_value = data_pt->nvalue();
      // Loop over the values
      for (unsigned j = 0; j < n_value; j++)
      {
        // If the value is not copied
        if (data_pt->is_a_copy(j) == false)
        {
          // Now Initialise the predictor to zero
          double predicted_value = 0.0;
          // Now loop over all the stored data and add appropriate values
          // to the predictor
          for (unsigned i = 1; i < 3; i++)
          {
            predicted_value += data_pt->value(i, j) * Predictor_weight[i];
          }
          // Store the predicted value
          data_pt->set_value(Predictor_storage_index, j, predicted_value);
        }
      }
    }
  }

References i, oomph::Data::is_a_copy(), j, oomph::Data::nvalue(), oomph::Data::set_value(), and oomph::Data::value().

calculate_predicted_values() [2/4]

void oomph::BDF< 2 >::calculate_predicted_values ( Data *const &  data_pt )

virtual

Calculate the predicted values and store them at the appropriate location in the data structure This function must be called after the time-values have been shifted!

Reimplemented from oomph::TimeStepper.

  {
    // If it's adaptive calculate the values
    if (adaptive_flag())
    {
      // Find number of values
      unsigned n_value = data_pt->nvalue();
      // Loop over the values
      for (unsigned j = 0; j < n_value; j++)
      {
        // If the value is not copied
        if (data_pt->is_a_copy(j) == false)
        {
          // Now Initialise the predictor to zero
          double predicted_value = 0.0;
          // Now loop over all the stored data and add appropriate values
          // to the predictor
          for (unsigned i = 1; i < 4; i++)
          {
            predicted_value += data_pt->value(i, j) * Predictor_weight[i];
          }
          // Store the predicted value
          // Note that predictor is stored as the FIFTH entry in this scheme
          data_pt->set_value(Predictor_storage_index, j, predicted_value);
        }
      }
    }
  }

References i, oomph::Data::is_a_copy(), j, oomph::Data::nvalue(), oomph::Data::set_value(), and oomph::Data::value().

calculate_predicted_values() [3/4]

void oomph::BDF< 4 >::calculate_predicted_values ( Data *const &  data_pt )

virtual

Calculate the predicted values and store them at the appropriate location in the data structure This function must be called after the time-values have been shifted!

Reimplemented from oomph::TimeStepper.

  {
    throw OomphLibError(
      "Not implemented yet", OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
  }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

calculate_predicted_values() [4/4]

template<unsigned NSTEPS>

void oomph::BDF< NSTEPS >::calculate_predicted_values ( Data *const &  data_pt )

virtual

Function to calculate predicted data values in a Data object.

Reimplemented from oomph::TimeStepper.

ndt()

template<unsigned NSTEPS>

unsigned oomph::BDF< NSTEPS >::ndt ( ) const

inlinevirtual

Number of timestep increments that need to be stored by the scheme.

Implements oomph::TimeStepper.

    {
      return NSTEPS;
    }

nprev_values()

template<unsigned NSTEPS>

unsigned oomph::BDF< NSTEPS >::nprev_values ( ) const

inlinevirtual

Number of previous values available.

Implements oomph::TimeStepper.

    {
      return NSTEPS;
    }

operator=()

template<unsigned NSTEPS>

void oomph::BDF< NSTEPS >::operator= ( const BDF< NSTEPS > &  )

delete

Broken assignment operator.

order()

template<unsigned NSTEPS>

unsigned oomph::BDF< NSTEPS >::order ( ) const

inlinevirtual

Return the actual order of the scheme.

Reimplemented from oomph::TimeStepper.

    {
      return NSTEPS;
    }

set_error_weights() [1/4]

void oomph::BDF< 1 >::set_error_weights ( )

virtual

Set the error weights (Gresho and Sani pg. 270)

Reimplemented from oomph::TimeStepper.

  {
    Error_weight = 0.5;
  }

set_error_weights() [2/4]

void oomph::BDF< 2 >::set_error_weights ( )

virtual

Function that sets the error weights.

Reimplemented from oomph::TimeStepper.

  {
    if (adaptive_flag())
    {
      double dt = Time_pt->dt(0);
      double dtprev = Time_pt->dt(1);
      // Calculate the error weight
      Error_weight =
        pow((1.0 + dtprev / dt), 2.0) /
        (1.0 + 3.0 * (dtprev / dt) + 4.0 * pow((dtprev / dt), 2.0) +
         2.0 * pow((dtprev / dt), 3.0));
    }
  }

References Eigen::ArrayBase< Derived >::pow(), and Flag_definition::Time_pt.

set_error_weights() [3/4]

void oomph::BDF< 4 >::set_error_weights ( )

virtual

Function that sets the error weights.

Reimplemented from oomph::TimeStepper.

  {
    throw OomphLibError(
      "Not implemented yet", OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
  }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

set_error_weights() [4/4]

template<unsigned NSTEPS>

void oomph::BDF< NSTEPS >::set_error_weights ( )

virtual

Function to set the error weights.

Reimplemented from oomph::TimeStepper.

set_predictor_weights() [1/4]

void oomph::BDF< 1 >::set_predictor_weights ( )

virtual

Set the predictor weights (Gresho and Sani pg. 270)

Reimplemented from oomph::TimeStepper.

  {
    // If it's adaptive set the predictor weights
    if (adaptive_flag())
    {
      double dt = Time_pt->dt(0);
 
      // Set the predictor weights
      Predictor_weight[0] = 0.0;
      Predictor_weight[1] = 1.0;
 
      // Velocity weight
      Predictor_weight[2] = dt;
    }
  }

References oomph::Time::dt(), and Flag_definition::Time_pt.

set_predictor_weights() [2/4]

void oomph::BDF< 2 >::set_predictor_weights ( )

virtual

Calculate the predictor weights. The scheme used is from Gresho & Sani, Incompressible Flow and the Finite Element Method (advection-diffusion and isothermal laminar flow), 1998, pg. 715.

Reimplemented from oomph::TimeStepper.

  {
    // If it's adaptive set the predictor weights
    if (adaptive_flag())
    {
      // Read the value of the previous timesteps
      double dt = Time_pt->dt(0);
      double dtprev = Time_pt->dt(1);
 
      // Set the predictor weights
      Predictor_weight[0] = 0.0;
      Predictor_weight[1] = 1.0 - (dt * dt) / (dtprev * dtprev);
      Predictor_weight[2] = (dt * dt) / (dtprev * dtprev);
      // Acceleration term
      Predictor_weight[3] = (1.0 + dt / dtprev) * dt;
    }
  }

References Flag_definition::Time_pt.

set_predictor_weights() [3/4]

void oomph::BDF< 4 >::set_predictor_weights ( )

virtual

Calculate the predictor weights.

Reimplemented from oomph::TimeStepper.

  {
    // Read the value of the previous timesteps
    // double dt=Time_pt->dt(0);
    // double dtprev=Time_pt->dt(1);
 
    throw OomphLibError(
      "Not implemented yet", OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
  }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

set_predictor_weights() [4/4]

template<unsigned NSTEPS>

void oomph::BDF< NSTEPS >::set_predictor_weights ( )

virtual

Function to set the predictor weights.

Reimplemented from oomph::TimeStepper.

set_weights() [1/4]

void oomph::BDF< 1 >::set_weights ( )

virtual

Assign the values of the weights.

///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////

Implements oomph::TimeStepper.

  {
    double dt = Time_pt->dt(0);
    Weight(1, 0) = 1.0 / dt;
    Weight(1, 1) = -1.0 / dt;
  }

References oomph::Time::dt(), Flag_definition::Time_pt, and ProblemParameters::Weight.

set_weights() [2/4]

void oomph::BDF< 2 >::set_weights ( )

virtual

Assign the values of the weights. The scheme used is from Gresho & Sani, Incompressible Flow and the Finite Element Method (advection-diffusion and isothermal laminar flow), 1998, pg. 715 (with some algebraic rearrangement).

Implements oomph::TimeStepper.

  {
    double dt = Time_pt->dt(0);
    double dtprev = Time_pt->dt(1);
    Weight(1, 0) = 1.0 / dt + 1.0 / (dt + dtprev);
    Weight(1, 1) = -(dt + dtprev) / (dt * dtprev);
    Weight(1, 2) = dt / ((dt + dtprev) * dtprev);
 
    if (adaptive_flag())
    {
      Weight(1, 3) = 0.0;
      Weight(1, 4) = 0.0;
    }
  }

References Flag_definition::Time_pt, and ProblemParameters::Weight.

set_weights() [3/4]

void oomph::BDF< 4 >::set_weights ( )

virtual

Assign the values of the weights; pass the value of the timestep.

Implements oomph::TimeStepper.

  {
#ifdef PARANOID
    double dt0 = Time_pt->dt(0);
    for (unsigned i = 0; i < Time_pt->ndt(); i++)
    {
      if (dt0 != Time_pt->dt(i))
      {
        throw OomphLibError("BDF4 currently only works for fixed timesteps \n",
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
    }
#endif
    double dt = Time_pt->dt(0);
    Weight(1, 0) = 25.0 / 12.0 / dt;
    Weight(1, 1) = -48.0 / 12.0 / dt;
    Weight(1, 2) = 36.0 / 12.0 / dt;
    Weight(1, 3) = -16.0 / 12.0 / dt;
    Weight(1, 4) = 3.0 / 12.0 / dt;
  }

References i, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Flag_definition::Time_pt, and ProblemParameters::Weight.

set_weights() [4/4]

template<unsigned NSTEPS>

void oomph::BDF< NSTEPS >::set_weights ( )

virtual

Set the weights.

Implements oomph::TimeStepper.

shift_time_positions()

template<unsigned NSTEPS>

void oomph::BDF< NSTEPS >::shift_time_positions ( Node *const &  node_pt )

inlinevirtual

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

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 = NSTEPS; t > 0; t--)
            {
              node_pt->x_gen(t, k, i) = node_pt->x_gen(t - 1, k, i);
            }
 
            // If we are using the adaptive scheme, set the velocity
            if (adaptive_flag())
            {
              node_pt->x_gen(NSTEPS + 1, k, i) = velocity[k][i];
            }
          }
        }
      }
    }

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

shift_time_values()

template<unsigned NSTEPS>

void oomph::BDF< NSTEPS >::shift_time_values ( Data *const &  data_pt )

inlinevirtual

This function updates the Data's time history so that we can advance to the next timestep. For BDF schemes, we simply push the values backwards...

Implements oomph::TimeStepper.

    {
      // Find number of values stored
      unsigned n_value = data_pt->nvalue();
      // Storage for velocity need to be here to be in scope
      Vector<double> velocity(n_value);
 
      // Find the number of history values that are stored
      const unsigned nt_value = nprev_values();
 
      // If adaptive, find the velocities
      if (adaptive_flag())
      {
        time_derivative(1, data_pt, velocity);
      }
 
      // Loop over the values
      for (unsigned j = 0; j < n_value; j++)
      {
        // Set previous values to the previous value, if not a copy
        if (data_pt->is_a_copy(j) == false)
        {
          // Loop over times, in reverse order
          for (unsigned t = nt_value; t > 0; t--)
          {
            data_pt->set_value(t, j, data_pt->value(t - 1, j));
          }
 
          // If we are using the adaptive scheme
          if (adaptive_flag())
          {
            // Set the velocity
            data_pt->set_value(nt_value + 1, j, velocity[j]);
          }
        }
      }
    }

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

temporal_error_in_position() [1/4]

double oomph::BDF< 1 >::temporal_error_in_position ( Node *const &  node_pt, const unsigned &  i  )

virtual

Function to compute the error in position i at node.

Reimplemented from oomph::TimeStepper.

  {
    if (adaptive_flag())
    {
      // Just return the error
      return Error_weight *
             (node_pt->x(i) - node_pt->x(Predictor_storage_index, i));
    }
    else
    {
      return 0.0;
    }
  }

References i, and oomph::Node::x().

temporal_error_in_position() [2/4]

double oomph::BDF< 2 >::temporal_error_in_position ( Node *const &  node_pt, const unsigned &  i  )

virtual

Function to compute the error in position i at node.

Reimplemented from oomph::TimeStepper.

  {
    if (adaptive_flag())
    {
      // Just return the error
      return Error_weight *
             (node_pt->x(i) - node_pt->x(Predictor_storage_index, i));
    }
    else
    {
      return 0.0;
    }
  }

References i, and oomph::Node::x().

temporal_error_in_position() [3/4]

double oomph::BDF< 4 >::temporal_error_in_position ( Node *const &  node_pt, const unsigned &  i  )

virtual

Function to compute the error in position i at node.

Reimplemented from oomph::TimeStepper.

  {
    throw OomphLibError(
      "Not implemented yet", OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    return 0.0;
  }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

temporal_error_in_position() [4/4]

template<unsigned NSTEPS>

double oomph::BDF< NSTEPS >::temporal_error_in_position ( Node *const &  node_pt, const unsigned &  i  )

virtual

Compute the error in the position i at a node.

Reimplemented from oomph::TimeStepper.

temporal_error_in_value() [1/4]

double oomph::BDF< 1 >::temporal_error_in_value ( Data *const &  data_pt, const unsigned &  i  )

virtual

Function to calculate the error in the data value i.

Reimplemented from oomph::TimeStepper.

  {
    if (adaptive_flag())
    {
      // Just return the error
      return Error_weight *
             (data_pt->value(i) - data_pt->value(Predictor_storage_index, i));
    }
    else
    {
      return 0.0;
    }
  }

References i, and oomph::Data::value().

temporal_error_in_value() [2/4]

double oomph::BDF< 2 >::temporal_error_in_value ( Data *const &  data_pt, const unsigned &  i  )

virtual

Function to calculate the error in the data value i.

Reimplemented from oomph::TimeStepper.

  {
    if (adaptive_flag())
    {
      // Just return the error
      return Error_weight *
             (data_pt->value(i) - data_pt->value(Predictor_storage_index, i));
    }
    else
    {
      return 0.0;
    }
  }

References i, and oomph::Data::value().

temporal_error_in_value() [3/4]

double oomph::BDF< 4 >::temporal_error_in_value ( Data *const &  data_pt, const unsigned &  i  )

virtual

Function to calculate the error in the data value i.

Reimplemented from oomph::TimeStepper.

  {
    throw OomphLibError(
      "Not implemented yet", OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    return 0.0;
  }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

temporal_error_in_value() [4/4]

template<unsigned NSTEPS>

double oomph::BDF< NSTEPS >::temporal_error_in_value ( Data *const &  data_pt, const unsigned &  i  )

virtual

Compute the error in the value i in a Data structure.

Reimplemented from oomph::TimeStepper.

Member Data Documentation

Error_weight

template<unsigned NSTEPS>

double oomph::BDF< NSTEPS >::Error_weight

private

Private data for the error weight.

Predictor_weight

template<unsigned NSTEPS>

Vector<double> oomph::BDF< NSTEPS >::Predictor_weight

private

Private data for the predictor weights.

---

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

• timesteppers.h