oomph::SelfStartingBDF2 Class Reference

Self-starting BDF2 timestepper class. More...

#include <self_starting_BDF2_timestepper.h>

Inheritance diagram for oomph::SelfStartingBDF2:

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

Public Member Functions
	SelfStartingBDF2 (const bool &adaptive=false)
	SelfStartingBDF2 (const SelfStartingBDF2 &)
	Broken copy constructor. More...
void	operator= (const SelfStartingBDF2 &)
	Broken assignment operator. More...
unsigned	order () const
	Return the actual order of the scheme. More...
void	turn_on_bdf1_mode ()
bool	bdf1_mode ()
	Flag to indicate if the timestepper is working in BDF1 mode. More...
void	turn_off_bdf1_mode ()
void	undo_make_steady ()
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 ()
void	set_weights_bdf1 ()
	Set the weights to those corresponding to BDF1. More...
void	set_weights_bdf2 ()
	Set the weights to those corresponding to BDF2. 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_bdf1 ()
	Function to set the predictor weights corresponding to BDF1. More...
void	set_predictor_weights_bdf2 ()
	Function to set the predictor weights corresponding to BDF2. More...
void	calculate_predicted_positions_bdf1 (Node *const &node_pt)
	Function to calculate predicted positions at a node (BDF1) More...
void	calculate_predicted_positions_bdf2 (Node *const &node_pt)
	Function to calculate predicted positions at a node (BDF2) More...
void	calculate_predicted_values_bdf1 (Data *const &data_pt)
	Function to calculate predicted data values in a Data object (BDF1) More...
void	calculate_predicted_values_bdf2 (Data *const &data_pt)
	Function to calculate predicted data values in a Data object (BDF2) More...
void	set_error_weights_bdf1 ()
	Function to set the error weights corresponding to BDF1. More...
void	set_error_weights_bdf2 ()
	Function to set the error weights corresponding to BDF2. More...
double	temporal_error_in_position_bdf1 (Node *const &node_pt, const unsigned &i)
	Compute the error in the position i at a node (BDF1) More...
double	temporal_error_in_position_bdf2 (Node *const &node_pt, const unsigned &i)
	Compute the error in the position i at a node (BDF2) More...
double	temporal_error_in_value_bdf1 (Data *const &data_pt, const unsigned &i)
	Compute the error in the value i in a Data structure (BDF1) More...
double	temporal_error_in_value_bdf2 (Data *const &data_pt, const unsigned &i)
	Compute the error in the value i in a Data structure (BDF2) 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...
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	set_predictor_weights ()
virtual void	calculate_predicted_values (Data *const &data_pt)
virtual void	calculate_predicted_positions (Node *const &node_pt)
virtual void	set_error_weights ()
virtual double	temporal_error_in_position (Node *const &node_pt, const unsigned &i)
virtual double	temporal_error_in_value (Data *const &data_pt, const unsigned &i)
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...
bool	BDF1_mode

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

Self-starting BDF2 timestepper class.

Member Typedef Documentation

InitialConditionFctPt

typedef double(* oomph::SelfStartingBDF2::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

SelfStartingBDF2() [1/2]

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

inline

Constructor for the case when we allow adaptive timestepping. Set BDF1_mode flag to false (default is BDF2 mode)

                                               : TimeStepper(3,1), BDF1_mode(false)
   {
    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 BDF<2>, but may be wrong for others
      Predictor_weight.resize(4);
      
      // The order of the scheme is 1, i.e. Weights has two entries
      
      //Resize the weights to the appropriate size
      Weight.resize(2,5);
      
      // Initialise
      for(unsigned i=0;i<2;i++)
       {
        // Initialise each weight to zero
        for(unsigned j=0;j<5;j++)
         {
          Weight(i,j) = 0.0;
         }
       }
      // Set the weight for the zero-th derivative
      Weight(0,0) = 1.0;
     }
   }

References Global_Physical_Variables::adaptive, oomph::TimeStepper::Adaptive_Flag, i, j, Predictor_weight, oomph::DenseMatrix< T >::resize(), oomph::TimeStepper::Type, and oomph::TimeStepper::Weight.

SelfStartingBDF2() [2/2]

oomph::SelfStartingBDF2::SelfStartingBDF2 ( const SelfStartingBDF2 &  )

inline

Broken copy constructor.

    { 
     BrokenCopy::broken_copy("SelfStartingBDF2");
    } 

References oomph::BrokenCopy::broken_copy().

Member Function Documentation

assign_initial_data_values()

void oomph::SelfStartingBDF2::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
    const unsigned n_time_value = ntstorage();
    
    // Find number of values stored
    const 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 = 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));
       }
     }
   }

References j, oomph::TimeStepper::ntstorage(), oomph::Data::nvalue(), oomph::Data::set_value(), plotPSD::t, oomph::Time::time(), oomph::TimeStepper::time(), and oomph::TimeStepper::Time_pt.

assign_initial_positions_impulsive()

void oomph::SelfStartingBDF2::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
    const unsigned n_dim = node_pt->ndim();
    // Find the number of position types at the node
    const 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<=2;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(3,k,i) = 0.0;
            // Initial prediction is the value
            node_pt->x_gen(4,k,i) = node_pt->x_gen(k,i);
           }
         }
       }
     }
   }

References oomph::TimeStepper::adaptive_flag(), 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()

void oomph::SelfStartingBDF2::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
    const 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<=2;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(3,j,0.0);
          // Initial prediction is the value
          data_pt->set_value(4,j,data_pt->value(j));
         }
       }
     }
   }

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

bdf1_mode()

bool oomph::SelfStartingBDF2::bdf1_mode ( )

inline

Flag to indicate if the timestepper is working in BDF1 mode.

{ return BDF1_mode; }

References BDF1_mode.

calculate_predicted_positions_bdf1()

void oomph::SelfStartingBDF2::calculate_predicted_positions_bdf1

(

Node *const &

node_pt

)

Function to calculate predicted positions at a node (BDF1)

Calculate predictions for the positions (BDF1)

 {
  throw OomphLibError("Not implemented yet",
                      "SelfStartingBDF2::calculate_predicted_positions_bdf1()",
                      OOMPH_EXCEPTION_LOCATION);
 }

References OOMPH_EXCEPTION_LOCATION.

calculate_predicted_positions_bdf2()

void oomph::SelfStartingBDF2::calculate_predicted_positions_bdf2

(

Node *const &

node_pt

)

Function to calculate predicted positions at a node (BDF2)

Calculate predictions for the positions (BDF2)

 {
  //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
        //Note that predictor is stored as the FIFTH entry in this scheme
        node_pt->x(4,j) = predicted_value;
       }
     }
   }
 }

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

calculate_predicted_values_bdf1()

void oomph::SelfStartingBDF2::calculate_predicted_values_bdf1

(

Data *const &

data_pt

)

Function to calculate predicted data values in a Data object (BDF1)

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

 {
  throw OomphLibError("Not implemented yet",
                      "SelfStartingBDF2::calculate_predicted_weights_bdf1()",
                      OOMPH_EXCEPTION_LOCATION);
 }

References OOMPH_EXCEPTION_LOCATION.

calculate_predicted_values_bdf2()

void oomph::SelfStartingBDF2::calculate_predicted_values_bdf2

(

Data *const &

data_pt

)

Function to calculate predicted data values in a Data object (BDF2)

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

 {
  //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(4,j,predicted_value);
       }
     }
   }
 }

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

ndt()

unsigned oomph::SelfStartingBDF2::ndt ( ) const

inlinevirtual

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

Implements oomph::TimeStepper.

{ return 2; }

nprev_values()

unsigned oomph::SelfStartingBDF2::nprev_values ( ) const

inlinevirtual

Number of previous values available.

Implements oomph::TimeStepper.

{ return 2; }

operator=()

void oomph::SelfStartingBDF2::operator= ( const SelfStartingBDF2 &  )

inline

Broken assignment operator.

    {
     BrokenCopy::broken_assign("SelfStartingBDF2");
    }

References oomph::BrokenCopy::broken_assign().

order()

unsigned oomph::SelfStartingBDF2::order ( ) const

inlinevirtual

Return the actual order of the scheme.

Reimplemented from oomph::TimeStepper.

{ return 2; }

set_error_weights_bdf1()

void oomph::SelfStartingBDF2::set_error_weights_bdf1

(

)

Function to set the error weights corresponding to BDF1.

Function that sets the error weights (BDF1)

 {
  throw OomphLibError("Not implemented yet",
                      "SelfStartingBDF2::set_error_weights_bdf1()",
                      OOMPH_EXCEPTION_LOCATION);
 }

References OOMPH_EXCEPTION_LOCATION.

set_error_weights_bdf2()

void oomph::SelfStartingBDF2::set_error_weights_bdf2

(

)

Function to set the error weights corresponding to BDF2.

Function that sets the error weights (BDF2)

 {
  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 oomph::TimeStepper::adaptive_flag(), oomph::Time::dt(), Error_weight, Eigen::bfloat16_impl::pow(), and oomph::TimeStepper::Time_pt.

set_predictor_weights_bdf1()

void oomph::SelfStartingBDF2::set_predictor_weights_bdf1

(

)

Function to set the predictor weights corresponding to BDF1.

Calculate the predictor weights (BDF1)

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

References OOMPH_EXCEPTION_LOCATION.

set_predictor_weights_bdf2()

void oomph::SelfStartingBDF2::set_predictor_weights_bdf2

(

)

Function to set the predictor weights corresponding to BDF2.

Calculate the predictor weights (BDF2)

 {
  //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 oomph::TimeStepper::adaptive_flag(), oomph::Time::dt(), Predictor_weight, and oomph::TimeStepper::Time_pt.

set_weights()

void oomph::SelfStartingBDF2::set_weights ( )

inlinevirtual

Implementation of pure virtual function in base class. Set weights corresponding to either a BDF1 scheme or a BDF2 scheme, depending on the flag.

Implements oomph::TimeStepper.

   {
    if(BDF1_mode) { set_weights_bdf1(); }
    else { set_weights_bdf2(); }
   }

References BDF1_mode, set_weights_bdf1(), and set_weights_bdf2().

set_weights_bdf1()

void oomph::SelfStartingBDF2::set_weights_bdf1

(

)

Set the weights to those corresponding to BDF1.

Assign the values of the weights (BDF1)

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

 {
  // Set BDF1 weights as normal
  double dt=Time_pt->dt(0);
  Weight(1,0) = 1.0/dt;
  Weight(1,1) = -1.0/dt;
  
  // Set weight associated with history value 2 to zero so that it has
  // no effect on the dudt calculation
  Weight(1,2) = 0.0;
 }

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

Referenced by set_weights(), turn_on_bdf1_mode(), and undo_make_steady().

set_weights_bdf2()

void oomph::SelfStartingBDF2::set_weights_bdf2

(

)

Set the weights to those corresponding to BDF2.

Assign the values of the weights; pass the value of the timestep (BDF2)

 {
  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 oomph::TimeStepper::adaptive_flag(), oomph::Time::dt(), oomph::TimeStepper::Time_pt, and oomph::TimeStepper::Weight.

Referenced by set_weights(), turn_off_bdf1_mode(), and undo_make_steady().

shift_time_positions()

void oomph::SelfStartingBDF2::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
    const unsigned n_dim = node_pt->ndim();
    // Find the number of position types
    const unsigned n_position_type = node_pt->nposition_type();
    
    // Find number of stored timesteps
    const 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=2;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(3,k,i) = velocity[k][i];
           }
         }
       }
     }
   }

References oomph::TimeStepper::adaptive_flag(), i, k, oomph::Node::ndim(), 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::SelfStartingBDF2::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
    const unsigned n_value = data_pt->nvalue();
    // Storage for velocity need to be here to be in scope
    Vector<double> velocity(n_value);
    
    // 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=2;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(3,j,velocity[j]);
         }
       } 
     }
   }

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

temporal_error_in_position_bdf1()

double oomph::SelfStartingBDF2::temporal_error_in_position_bdf1	(	Node *const &	node_pt,
		const unsigned &	i
	)

Compute the error in the position i at a node (BDF1)

Function to compute the error in position i at node (BDF1)

 {
  throw OomphLibError("Not implemented yet",
                      "SelfStartingBDF2::temporal_error_in_position_bdf1()",
                      OOMPH_EXCEPTION_LOCATION);
  return 0.0;
 }

References OOMPH_EXCEPTION_LOCATION.

temporal_error_in_position_bdf2()

double oomph::SelfStartingBDF2::temporal_error_in_position_bdf2	(	Node *const &	node_pt,
		const unsigned &	i
	)

Compute the error in the position i at a node (BDF2)

Function to compute the error in position i at node (BDF2)

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

References oomph::TimeStepper::adaptive_flag(), Error_weight, i, and oomph::Node::x().

temporal_error_in_value_bdf1()

double oomph::SelfStartingBDF2::temporal_error_in_value_bdf1	(	Data *const &	data_pt,
		const unsigned &	i
	)

Compute the error in the value i in a Data structure (BDF1)

Function to calculate the error in the data value i (BDF1)

 {
  throw OomphLibError("Not implemented yet",
                      "SelfStartingBDF2::temporal_error_in_value_bdf1()",
                      OOMPH_EXCEPTION_LOCATION);
  return 0.0;
 }

References OOMPH_EXCEPTION_LOCATION.

temporal_error_in_value_bdf2()

double oomph::SelfStartingBDF2::temporal_error_in_value_bdf2	(	Data *const &	data_pt,
		const unsigned &	i
	)

Compute the error in the value i in a Data structure (BDF2)

Function to calculate the error in the data value i (BDF2)

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

References oomph::TimeStepper::adaptive_flag(), Error_weight, i, and oomph::Data::value().

turn_off_bdf1_mode()

void oomph::SelfStartingBDF2::turn_off_bdf1_mode ( )

inline

Reset the timestepper to BDF2: Set the "BDF1_mode" flag to false and re-compute the weights

   {
    // Update flag
    BDF1_mode = false;
    
    // Reset_weights
    set_weights_bdf2();
   }

References BDF1_mode, and set_weights_bdf2().

turn_on_bdf1_mode()

void oomph::SelfStartingBDF2::turn_on_bdf1_mode ( )

inline

Function to make the time stepper temporarily work as if it is BDF1. This is trivially achieved by resetting the weights to those of BDF1, before setting the weight corresponding to history value 2 to zero.

   {
    // Update flag
    BDF1_mode = true;
    
    // Reset weights
    set_weights_bdf1();
   }

References BDF1_mode, and set_weights_bdf1().

undo_make_steady()

void oomph::SelfStartingBDF2::undo_make_steady ( )

inlinevirtual

Reset the is_steady status to its default (false) and re-compute the weights

Reimplemented from oomph::TimeStepper.

   {
    // Update flag
    Is_steady = false;
    
    // Reset weights
    if(BDF1_mode)
     {
      set_weights_bdf1();
     }
    else
     {
      set_weights_bdf2();
     }
   }

References BDF1_mode, oomph::TimeStepper::Is_steady, set_weights_bdf1(), and set_weights_bdf2().

Member Data Documentation

BDF1_mode

bool oomph::SelfStartingBDF2::BDF1_mode

private

Bool to indicate if the timestepper is in ‘BDF1’ mode i.e. it behaves just as if it were a BDF1 timestepper. This status may be achieved temporarily by calling turn_on_bdf1_mode(). It's reset to the default BDF2 behaviour by calling turn_off_bdf1_mode().

Referenced by bdf1_mode(), set_weights(), turn_off_bdf1_mode(), turn_on_bdf1_mode(), and undo_make_steady().

Error_weight

double oomph::SelfStartingBDF2::Error_weight

private

Private data for the error weight.

Referenced by set_error_weights_bdf2(), temporal_error_in_position_bdf2(), and temporal_error_in_value_bdf2().

Predictor_weight

Vector<double> oomph::SelfStartingBDF2::Predictor_weight

private

Private data for the predictor weights.

Referenced by calculate_predicted_positions_bdf2(), calculate_predicted_values_bdf2(), SelfStartingBDF2(), and set_predictor_weights_bdf2().

---

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

• self_starting_BDF2_timestepper.h