oomph::NewmarkBDF< NSTEPS > Class Template Reference

#include <timesteppers.h>

Inheritance diagram for oomph::NewmarkBDF< NSTEPS >:

Public Member Functions
	NewmarkBDF ()
	NewmarkBDF (const NewmarkBDF &)=delete
	Broken copy constructor. More...
void	operator= (const NewmarkBDF &)=delete
	Broken assignment operator. More...
void	set_weights ()
	Set weights. More...
void	shift_time_values (Data *const &data_pt)
void	shift_time_positions (Node *const &node_pt)
void	enable_degrade_first_derivatives_to_bdf1 ()
void	disable_degrade_first_derivatives_to_bdf1 ()
	Disable degradation to first order BDF. More...
void	set_weights ()
	Set weights. More...
void	set_weights ()
	Set weights. More...
void	set_weights ()
	Set weights. More...
Public Member Functions inherited from oomph::Newmark< NSTEPS >
	Newmark ()
	Newmark (const Newmark &)=delete
	Broken copy constructor. More...
void	operator= (const Newmark &)=delete
	Broken assignment operator. More...
unsigned	order () const
	The actual order (accuracy 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, Vector< InitialConditionFctPt > initial_veloc_fct, Vector< InitialConditionFctPt > initial_accel_fct)
void	assign_initial_data_values (Node *const &node_pt, Vector< NodeInitialConditionFctPt > initial_value_fct, Vector< NodeInitialConditionFctPt > initial_veloc_fct, Vector< NodeInitialConditionFctPt > initial_accel_fct)
void	assign_initial_data_values_stage1 (const unsigned t_deriv, Data *const &data_pt)
void	assign_initial_data_values_stage2 (Data *const &data_pt)
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...
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	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 Member Functions
void	set_newmark_veloc_weights (const double &dt)

Private Attributes
bool	Degrade_to_bdf1_for_first_derivs
Vector< double >	Newmark_veloc_weight

Additional Inherited Members
Public Types inherited from oomph::Newmark< NSTEPS >
typedef double(*	InitialConditionFctPt) (const double &t)
typedef double(*	NodeInitialConditionFctPt) (const double &t, const Vector< double > &x)
Protected Attributes inherited from oomph::Newmark< NSTEPS >
double	Beta1
	First Newmark parameter (usually 0.5) More...
double	Beta2
	Second Newmark parameter (usually 0.5) More...
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::NewmarkBDF< NSTEPS >

////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// Newmark scheme for second time deriv with first derivatives calculated using BDF. . Stored data represents

• t=0: value at at present time, Time_pt->time()
• t=1: value at previous time, Time_pt->time()-dt
• ...
• t=NSTEPS: value at previous time, Time_pt->time()-NSTEPS*dt
• t=NSTEPS+1: 1st time deriv (= "velocity") at previous time, Time_pt->time()-dt
• t=NSTEPS+2: 2nd time deriv (= "acceleration") at previous time, Time_pt->time()-dt

NSTEPS=1 gives normal Newmark.

Constructor & Destructor Documentation

NewmarkBDF() [1/2]

template<unsigned NSTEPS>

oomph::NewmarkBDF< NSTEPS >::NewmarkBDF ( )

inline

Constructor: Pass pointer to global time. We set up a timestepping scheme with NSTEPS+2 doubles to represent the history and the highest deriv is 2.

    {
      this->Type = "NewmarkBDF";
      Degrade_to_bdf1_for_first_derivs = false;
      Newmark_veloc_weight.resize(NSTEPS + 3);
    }

NewmarkBDF() [2/2]

template<unsigned NSTEPS>

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

delete

Broken copy constructor.

Member Function Documentation

disable_degrade_first_derivatives_to_bdf1()

template<unsigned NSTEPS>

void oomph::NewmarkBDF< NSTEPS >::disable_degrade_first_derivatives_to_bdf1 ( )

inline

Disable degradation to first order BDF.

    {
      Degrade_to_bdf1_for_first_derivs = false;
    }

enable_degrade_first_derivatives_to_bdf1()

template<unsigned NSTEPS>

void oomph::NewmarkBDF< NSTEPS >::enable_degrade_first_derivatives_to_bdf1 ( )

inline

Degrade scheme to first order BDF (for first derivs/veloc); usually for start-up.

    {
      Degrade_to_bdf1_for_first_derivs = true;
    }

operator=()

template<unsigned NSTEPS>

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

delete

Broken assignment operator.

set_newmark_veloc_weights()

template<unsigned NSTEPS>

void oomph::NewmarkBDF< NSTEPS >::set_newmark_veloc_weights ( const double &  dt )

inlineprivate

Set original Newmark weights for velocities (needed when shifting history values – they're used when updating the previous accelerations and doing this with bdf can make the scheme unstable...

    {
      Newmark_veloc_weight[0] = this->Beta1 * dt * this->Weight(2, 0);
      Newmark_veloc_weight[1] = this->Beta1 * dt * this->Weight(2, 1);
      for (unsigned t = 2; t <= NSTEPS; t++)
      {
        Newmark_veloc_weight[t] = 0.0;
      }
      Newmark_veloc_weight[NSTEPS + 1] =
        1.0 + this->Beta1 * dt * this->Weight(2, NSTEPS + 1);
      Newmark_veloc_weight[NSTEPS + 2] =
        dt * (1.0 - this->Beta1) +
        this->Beta1 * dt * this->Weight(2, NSTEPS + 2);
    }

References GlobalParameters::Beta1, oomph::Time::dt(), plotPSD::t, and ProblemParameters::Weight.

set_weights() [1/4]

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

virtual

Set weights.

Reimplemented from oomph::Newmark< NSTEPS >.

  {
    // Set Newmark weights for second derivatives
    double dt = Time_pt->dt(0);
    Weight(2, 0) = 2.0 / (Beta2 * dt * dt);
    Weight(2, 1) = -2.0 / (Beta2 * dt * dt);
    Weight(2, 2) = -2.0 / (dt * Beta2);
    Weight(2, 3) = (Beta2 - 1.0) / Beta2;
 
    // Set BDF weights for first derivatives
    Weight(1, 0) = 1.0 / dt;
    Weight(1, 1) = -1.0 / dt;
    Weight(1, 2) = 0.0;
    Weight(1, 3) = 0.0;
 
    // Orig Newmark weights for first derivs.
    set_newmark_veloc_weights(dt);
  }

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

set_weights() [2/4]

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

virtual

Set weights.

Reimplemented from oomph::Newmark< NSTEPS >.

  {
    // Set Newmark weights for second derivatives
    double dt = Time_pt->dt(0);
    Weight(2, 0) = 2.0 / (Beta2 * dt * dt);
    Weight(2, 1) = -2.0 / (Beta2 * dt * dt);
    Weight(2, 2) = 0.0;
    Weight(2, 3) = -2.0 / (dt * Beta2);
    Weight(2, 4) = (Beta2 - 1.0) / Beta2;
 
    // Set BDF weights for first derivatives
    if (Degrade_to_bdf1_for_first_derivs)
    {
      this->Weight(1, 0) = 1.0 / dt;
      this->Weight(1, 1) = -1.0 / dt;
      unsigned nweights = this->Weight.ncol();
      for (unsigned i = 2; i < nweights; i++)
      {
        this->Weight(1, i) = 0.0;
      }
    }
    else
    {
      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);
      Weight(1, 3) = 0.0;
      Weight(1, 4) = 0.0;
    }
 
    // Orig Newmark weights for first derivs.
    set_newmark_veloc_weights(dt);
  }

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

set_weights() [3/4]

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

virtual

Set weights.

Reimplemented from oomph::Newmark< NSTEPS >.

  {
    // Set Newmark weights for second derivatives
    double dt = Time_pt->dt(0);
    Weight(2, 0) = 2.0 / (Beta2 * dt * dt);
    Weight(2, 1) = -2.0 / (Beta2 * dt * dt);
    Weight(2, 2) = 0.0;
    Weight(2, 3) = 0.0;
    Weight(2, 4) = 0.0;
    Weight(2, 5) = -2.0 / (dt * Beta2);
    Weight(2, 6) = (Beta2 - 1.0) / Beta2;
 
    // Set BDF weights for first derivatives
#ifdef PARANOID
    for (unsigned i = 0; i < Time_pt->ndt(); i++)
    {
      if (dt != Time_pt->dt(i))
      {
        throw OomphLibError("BDF4 currently only works for fixed timesteps \n",
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
    }
#endif
 
    // Set BDF weights for first derivatives
    if (Degrade_to_bdf1_for_first_derivs)
    {
      this->Weight(1, 0) = 1.0 / dt;
      this->Weight(1, 1) = -1.0 / dt;
      unsigned nweights = this->Weight.ncol();
      for (unsigned i = 2; i < nweights; i++)
      {
        this->Weight(1, i) = 0.0;
      }
    }
    else
    {
      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;
      Weight(1, 5) = 0.0;
      Weight(1, 6) = 0.0;
    }
 
    // Orig Newmark weights for first derivs.
    set_newmark_veloc_weights(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::NewmarkBDF< NSTEPS >::set_weights ( )

virtual

Set weights.

Reimplemented from oomph::Newmark< NSTEPS >.

shift_time_positions()

template<unsigned NSTEPS>

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

virtual

This function updates a nodal time history so that we can advance to the next timestep.

Reimplemented from oomph::Newmark< NSTEPS >.

  {
    // 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();
 
    // Storage for the velocity and acceleration
    double veloc[n_position_type][n_dim];
    double accel[n_position_type][n_dim];
 
    // Find number of stored time values
    unsigned n_tstorage = this->ntstorage();
 
    // Loop over the variables
    for (unsigned i = 0; i < n_dim; i++)
    {
      for (unsigned k = 0; k < n_position_type; k++)
      {
        veloc[k][i] = accel[k][i] = 0.0;
        // Loop over all the history data
        for (unsigned t = 0; t < n_tstorage; t++)
        {
          veloc[k][i] += Newmark_veloc_weight[t] * node_pt->x_gen(t, k, i);
          accel[k][i] += this->weight(2, t) * node_pt->x_gen(t, k, i);
        }
      }
    }
 
    // Loop over the position variables
    for (unsigned i = 0; i < n_dim; i++)
    {
      // If not a copy
      if (node_pt->position_is_a_copy(i) == false)
      {
        // Loop over position types
        for (unsigned k = 0; k < n_position_type; k++)
        {
          // Set previous values/veloc/accel to present values/veloc/accel,
          // if not a copy
          for (unsigned t = NSTEPS; t > 0; t--)
          {
            node_pt->x_gen(t, k, i) = node_pt->x_gen(t - 1, k, i);
          }
 
          node_pt->x_gen(NSTEPS + 1, k, i) = veloc[k][i];
          node_pt->x_gen(NSTEPS + 2, k, i) = accel[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().

shift_time_values()

template<unsigned NSTEPS>

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

virtual

This function updates the Data's time history so that we can advance to the next timestep.

Reimplemented from oomph::Newmark< NSTEPS >.

  {
    // Find number of values stored
    unsigned n_value = data_pt->nvalue();
 
    // Storage for the velocity and acceleration
    Vector<double> veloc(n_value, 0.0);
    Vector<double> accel(n_value, 0.0);
 
    // Find number of stored time values
    unsigned n_tstorage = this->ntstorage();
 
    // Loop over the variables
    for (unsigned i = 0; i < n_value; i++)
    {
      // Loop over all the history data
      for (unsigned t = 0; t < n_tstorage; t++)
      {
        veloc[i] += Newmark_veloc_weight[t] * data_pt->value(t, i);
        accel[i] += this->weight(2, t) * data_pt->value(t, i);
      }
    }
 
 
    // Loop over values
    for (unsigned j = 0; j < n_value; j++)
    {
      // Set previous values/veloc/accel to present values/veloc/accel,
      // if not a copy
      if (data_pt->is_a_copy(j) == false)
      {
        for (unsigned t = NSTEPS; t > 0; t--)
        {
          data_pt->set_value(t, j, data_pt->value(t - 1, j));
        }
        data_pt->set_value(NSTEPS + 1, j, veloc[j]);
        data_pt->set_value(NSTEPS + 2, j, accel[j]);
      }
    }
  }

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

Member Data Documentation

Degrade_to_bdf1_for_first_derivs

template<unsigned NSTEPS>

bool oomph::NewmarkBDF< NSTEPS >::Degrade_to_bdf1_for_first_derivs

private

Boolean flag to indicate degradation of scheme to first order BDF (for first derivs/veloc); usually for start-up.

Newmark_veloc_weight

template<unsigned NSTEPS>

Vector<double> oomph::NewmarkBDF< NSTEPS >::Newmark_veloc_weight

private

Original Newmark weights for velocities (needed when shifting history values – they're used when updating the previous accelerations and doing this with bdf can make the scheme unstable...

---

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

• timesteppers.h
• timesteppers.cc