oomph::Newmark< NSTEPS > Class Template Reference

#include <timesteppers.h>

Inheritance diagram for oomph::Newmark< NSTEPS >:

Public Types
typedef double(*	InitialConditionFctPt) (const double &t)
typedef double(*	NodeInitialConditionFctPt) (const double &t, const Vector< double > &x)

Public Member Functions
	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)
void	shift_time_values (Data *const &data_pt)
void	shift_time_positions (Node *const &node_pt)
void	set_weights ()
	Set 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...
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)

Protected Attributes
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::Newmark< NSTEPS >

////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// Newmark scheme for second time deriv. 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.

Member Typedef Documentation

InitialConditionFctPt

template<unsigned NSTEPS>

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

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

NodeInitialConditionFctPt

template<unsigned NSTEPS>

typedef double(* oomph::Newmark< NSTEPS >::NodeInitialConditionFctPt) (const double &t, const Vector< double > &x)

Typedef for function that returns the (scalar) initial value at a given value of the continuous time t and the spatial coordinate – appropriate for assignement of initial conditions for nodes

Constructor & Destructor Documentation

Newmark() [1/2]

template<unsigned NSTEPS>

oomph::Newmark< NSTEPS >::Newmark ( )

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.

              : TimeStepper(NSTEPS + 3, 2)
    {
      Type = "Newmark";
 
      // Standard Newmark parameters
      Beta1 = 0.5;
      Beta2 = 0.5;
    }

References GlobalParameters::Beta1.

Newmark() [2/2]

template<unsigned NSTEPS>

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

delete

Broken copy constructor.

Member Function Documentation

assign_initial_data_values() [1/2]

template<unsigned NSTEPS>

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

Initialise the time-history for the Data values, so that the Newmark representations for current veloc and acceleration are exact.

  {
    // Set weights
    set_weights();
 
#ifdef PARANOID
    // Check if the 3 vectors of functions have the same size
    if (initial_value_fct.size() != initial_veloc_fct.size() ||
        initial_value_fct.size() != initial_accel_fct.size())
    {
      throw OomphLibError("The Vectors of fcts for values, velocities and "
                          "acceleration must be the same size",
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    // The number of functions in each vector (they should be the same)
    unsigned n_fcts = initial_value_fct.size();
 
#ifdef PARANOID
 
    // If there are more data values at the node than functions, issue a warning
    unsigned n_value = data_pt->nvalue();
    if (n_value > n_fcts && !Shut_up_in_assign_initial_data_values)
    {
      std::stringstream message;
      message << "There are more data values than initial value fcts.\n";
      message << "Only the first " << n_fcts << " data values will be set\n";
      OomphLibWarning(
        message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    // Loop over elements of the function vectors
    for (unsigned j = 0; j < n_fcts; j++)
    {
      if (initial_value_fct[j] == 0)
      {
#ifdef PARANOID
        if (!Shut_up_in_assign_initial_data_values)
        {
          std::stringstream message;
          message << "Ignoring value " << j << " in assignment of ic.\n";
          OomphLibWarning(message.str(),
                          "Newmark<NSTEPS>::assign_initial_data_values",
                          OOMPH_EXCEPTION_LOCATION);
        }
#endif
      }
      else
      {
        // Value itself at current and previous times
        for (unsigned t = 0; t <= NSTEPS; t++)
        {
          double time_local = Time_pt->time(t);
          data_pt->set_value(t, j, initial_value_fct[j](time_local));
        }
 
        // Now, rather than assigning the values for veloc and accel
        // in the Newmark scheme directly, we solve a linear system
        // to determine the values required to make the Newmark
        // representations of the  veloc and accel at the current (!)
        // time are exact.
 
        // Initial time: The value itself
        double time_ = Time_pt->time();
        double U = initial_value_fct[j](time_);
 
        // Value itself at previous time
        time_ = Time_pt->time(1);
        double U0 = initial_value_fct[j](time_);
 
        // Veloc (time deriv) at present time -- this is what the
        // Newmark scheme should return!
        time_ = Time_pt->time(0);
        double Udot = initial_veloc_fct[j](time_);
 
        // Acccel (2nd time deriv) at present time -- this is what the
        // Newmark scheme should return!
        time_ = Time_pt->time(0);
        double Udotdot = initial_accel_fct[j](time_);
 
        Vector<double> vect(2);
        vect[0] = Udotdot - Weight(2, 0) * U - Weight(2, 1) * U0;
        vect[1] = Udot - Weight(1, 0) * U - Weight(1, 1) * U0;
 
        DenseDoubleMatrix matrix(2, 2);
        matrix(0, 0) = Weight(2, NSTEPS + 1);
        matrix(0, 1) = Weight(2, NSTEPS + 2);
        matrix(1, 0) = Weight(1, NSTEPS + 1);
        matrix(1, 1) = Weight(1, NSTEPS + 2);
 
        matrix.solve(vect);
 
        // Discrete veloc (time deriv) at previous time , to be entered into the
        // Newmark scheme  so that its prediction for the *current* veloc
        // and accel is correct.
        data_pt->set_value(NSTEPS + 1, j, vect[0]);
 
        // Discrete veloc (2nd time deriv) at previous time, to be entered into
        // the Newmark scheme  so that its prediction for the *current* veloc
        // and accel is correct.
        data_pt->set_value(NSTEPS + 2, j, vect[1]);
      }
    }
  }

References j, matrix(), oomph::Data::nvalue(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Data::set_value(), plotPSD::t, Flag_definition::Time_pt, RachelsAdvectionDiffusion::U, ExactSolution::U0, and ProblemParameters::Weight.

assign_initial_data_values() [2/2]

template<unsigned NSTEPS>

void oomph::Newmark< NSTEPS >::assign_initial_data_values	(	Node *const &	node_pt,
		Vector< NodeInitialConditionFctPt >	initial_value_fct,
		Vector< NodeInitialConditionFctPt >	initial_veloc_fct,
		Vector< NodeInitialConditionFctPt >	initial_accel_fct
	)

Initialise the time-history for the nodal values, so that the Newmark representations for current veloc and acceleration are exact.

Initialise the time-history for the Data values, so that the Newmark representations for current veloc and acceleration are exact.

  {
    // Set weights
    set_weights();
 
 
#ifdef PARANOID
    // Check if the 3 vectors of functions have the same size
    if (initial_value_fct.size() != initial_veloc_fct.size() ||
        initial_value_fct.size() != initial_accel_fct.size())
    {
      throw OomphLibError("The Vectors of fcts for values, velocities and "
                          "acceleration must be the same size",
                          "Newmark<NSTEPS>::assign_initial_data_values",
                          OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    // The number of functions in each vector (they should be the same)
    unsigned n_fcts = initial_value_fct.size();
 
#ifdef PARANOID
 
    // If there are more data values at the node than functions, issue a warning
    unsigned n_value = node_pt->nvalue();
    if (n_value > n_fcts && !Shut_up_in_assign_initial_data_values)
    {
      std::stringstream message;
      message << "There are more nodal values than initial value fcts.\n";
      message << "Only the first " << n_fcts << " nodal values will be set\n";
      OomphLibWarning(
        message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    // Get current nodal coordinates
    unsigned n_dim = node_pt->ndim();
    Vector<double> x(n_dim);
    for (unsigned i = 0; i < n_dim; i++) x[i] = node_pt->x(i);
 
    // Loop over values
    for (unsigned j = 0; j < n_fcts; j++)
    {
      if (initial_value_fct[j] == 0)
      {
#ifdef PARANOID
        if (!Shut_up_in_assign_initial_data_values)
        {
          std::stringstream message;
          message << "Ignoring value " << j << " in assignment of ic.\n";
          OomphLibWarning(
            message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
        }
#endif
      }
      else
      {
        // Value itself at current and previous times
        for (unsigned t = 0; t <= NSTEPS; t++)
        {
          double time_local = Time_pt->time(t);
          node_pt->set_value(t, j, initial_value_fct[j](time_local, x));
        }
 
        // Now, rather than assigning the values for veloc and accel
        // in the Newmark scheme directly, we solve a linear system
        // to determine the values required to make the Newmark
        // representations of the  veloc and accel at the current (!)
        // time are exact.
 
        // Initial time: The value itself
        double time_ = Time_pt->time();
        double U = initial_value_fct[j](time_, x);
 
        // Value itself at previous time
        time_ = Time_pt->time(1);
        double U0 = initial_value_fct[j](time_, x);
 
        // Veloc (time deriv) at present time -- this is what the
        // Newmark scheme should return!
        time_ = Time_pt->time(0);
        double Udot = initial_veloc_fct[j](time_, x);
 
        // Acccel (2nd time deriv) at present time -- this is what the
        // Newmark scheme should return!
        time_ = Time_pt->time(0);
        double Udotdot = initial_accel_fct[j](time_, x);
 
        Vector<double> vect(2);
        vect[0] = Udotdot - Weight(2, 0) * U - Weight(2, 1) * U0;
        vect[1] = Udot - Weight(1, 0) * U - Weight(1, 1) * U0;
 
        DenseDoubleMatrix matrix(2, 2);
        matrix(0, 0) = Weight(2, NSTEPS + 1);
        matrix(0, 1) = Weight(2, NSTEPS + 2);
        matrix(1, 0) = Weight(1, NSTEPS + 1);
        matrix(1, 1) = Weight(1, NSTEPS + 2);
 
        matrix.solve(vect);
 
        // Discrete veloc (time deriv) at previous time , to be entered into the
        // Newmark scheme  so that its prediction for the *current* veloc
        // and accel is correct.
        node_pt->set_value(NSTEPS + 1, j, vect[0]);
 
        // Discrete veloc (2nd time deriv) at previous time, to be entered into
        // the Newmark scheme  so that its prediction for the *current* veloc
        // and accel is correct.
        node_pt->set_value(NSTEPS + 2, j, vect[1]);
      }
    }
  }

References i, j, matrix(), oomph::Node::ndim(), oomph::Data::nvalue(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Data::set_value(), plotPSD::t, Flag_definition::Time_pt, RachelsAdvectionDiffusion::U, ExactSolution::U0, ProblemParameters::Weight, plotDoE::x, and oomph::Node::x().

assign_initial_data_values_stage1()

template<unsigned NSTEPS>

void oomph::Newmark< NSTEPS >::assign_initial_data_values_stage1	(	const unsigned	t_deriv,
		Data *const &	data_pt
	)

First step in a two-stage procedure to assign the history values for the Newmark scheme so that the veloc and accel that are computed by the scheme are correct at the current time.

Call this function for t_deriv=0,1,2,3. When calling with

• t_deriv=0 : data_pt(0,*) should contain the values at the previous timestep
• t_deriv=1 : data_pt(0,*) should contain the current values; they get stored (temporarily) in data_pt(1,*).
• t_deriv=2 : data_pt(0,*) should contain the current velocities (first time derivs); they get stored (temporarily) in data_pt(NSTEPS+1,*).
• t_deriv=3 : data_pt(0,*) should contain the current accelerations (second time derivs); they get stored (temporarily) in data_pt(NSTEPS+2,*).

Follow this by calls to

assign_initial_data_values_stage2(...)

  {
    // Find number of values stored
    unsigned n_value = data_pt->nvalue();
 
    // Loop over values
    for (unsigned j = 0; j < n_value; j++)
    {
      // Which deriv are we dealing with?
      switch (t_deriv)
      {
          // 0-th deriv: the value itself at present time
        case 0:
 
          data_pt->set_value(1, j, data_pt->value(j));
          break;
 
          // 1st deriv: the veloc at present time
        case 1:
 
          data_pt->set_value(NSTEPS + 1, j, data_pt->value(j));
          break;
 
          // 2nd deriv: the accel at present time
        case 2:
 
          data_pt->set_value(NSTEPS + 2, j, data_pt->value(j));
          break;
 
 
          // None other are possible!
        default:
 
          std::ostringstream error_message_stream;
          error_message_stream << "t_deriv " << t_deriv
                               << " is not possible with a Newmark scheme "
                               << std::endl;
 
          throw OomphLibError(error_message_stream.str(),
                              OOMPH_CURRENT_FUNCTION,
                              OOMPH_EXCEPTION_LOCATION);
      }
    }
  }

References j, oomph::Data::nvalue(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Data::set_value(), and oomph::Data::value().

assign_initial_data_values_stage2()

template<unsigned NSTEPS>

void oomph::Newmark< NSTEPS >::assign_initial_data_values_stage2

(

Data *const &

data_pt

)

Second step in a two-stage procedure to assign the history values for the Newmark scheme so that the veloc and accel that are computed by the scheme are correct at the current time.

This assigns appropriate values for the "previous velocities and accelerations" so that their current values, which were defined in assign_initial_data_values_stage1(...), are represented exactly by the Newmark scheme.

  {
    // Find number of values stored
    unsigned n_value = data_pt->nvalue();
 
    // Loop over values
    for (unsigned j = 0; j < n_value; j++)
    {
      // Rather than assigning the previous veloc and accel
      // directly, solve linear system to determine their values
      // so that the Newmark representations are exact.
 
      // The exact value at present time (stored in stage 1)
      double U = data_pt->value(1, j);
 
      // Exact value at previous time
      double U0 = data_pt->value(0, j);
 
      // Veloc (1st time deriv) at present time (stored in stage 1)
      double Udot = data_pt->value(NSTEPS + 1, j);
 
      // Acccel (2nd time deriv) at present time (stored in stage 1)
      double Udotdot = data_pt->value(NSTEPS + 2, j);
 
      Vector<double> vect(2);
      vect[0] = Udotdot - Weight(2, 0) * U - Weight(2, 1) * U0;
      vect[1] = Udot - Weight(1, 0) * U - Weight(1, 1) * U0;
 
      DenseDoubleMatrix matrix(2, 2);
      matrix(0, 0) = Weight(2, NSTEPS + 1);
      matrix(0, 1) = Weight(2, NSTEPS + 2);
      matrix(1, 0) = Weight(1, NSTEPS + 1);
      matrix(1, 1) = Weight(1, NSTEPS + 2);
 
      matrix.solve(vect);
 
 
      // Now assign the discrete coefficients
      // so that the Newmark scheme returns the correct
      // results for the present values, and 1st and 2nd derivatives:
 
      // Value at present time
      data_pt->set_value(0, j, U);
 
      // Value at previous time
      data_pt->set_value(1, j, U0);
 
      // Veloc (time deriv) at previous time
      data_pt->set_value(NSTEPS + 1, j, vect[0]);
 
      // Acccel (2nd time deriv) at previous time
      data_pt->set_value(NSTEPS + 2, j, vect[1]);
    }
  }

References j, matrix(), oomph::Data::nvalue(), oomph::Data::set_value(), RachelsAdvectionDiffusion::U, ExactSolution::U0, oomph::Data::value(), and ProblemParameters::Weight.

assign_initial_positions_impulsive()

template<unsigned NSTEPS>

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

virtual

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

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();
 
    // Loop over values
    for (unsigned i = 0; i < n_dim; i++)
    {
      // If 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++)
        {
          // Set previous value 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);
          }
 
          // Initial velocity and initial acceleration are zero
          node_pt->x_gen(NSTEPS + 1, k, i) = 0.0;
          node_pt->x_gen(NSTEPS + 2, k, i) = 0.0;
        }
      }
    }
  }

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::Newmark< NSTEPS >::assign_initial_values_impulsive ( Data *const &  data_pt )

virtual

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

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

Implements oomph::TimeStepper.

  {
    // Find number of values stored in Data object
    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));
        }
      }
 
      // Initial velocity and initial acceleration are zero
      data_pt->set_value(NSTEPS + 1, j, 0.0);
      data_pt->set_value(NSTEPS + 2, j, 0.0);
    }
  }

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

ndt()

template<unsigned NSTEPS>

unsigned oomph::Newmark< 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::Newmark< NSTEPS >::nprev_values ( ) const

inlinevirtual

Number of previous values available.

Implements oomph::TimeStepper.

    {
      return NSTEPS;
    }

operator=()

template<unsigned NSTEPS>

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

delete

Broken assignment operator.

order()

template<unsigned NSTEPS>

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

inlinevirtual

The actual order (accuracy of the scheme)

Reimplemented from oomph::TimeStepper.

    {
      std::string error_message =
        "Can't remember the order of the Newmark scheme";
      error_message += " -- I think it's 2nd order...\n";
 
      OomphLibWarning(
        error_message, "Newmark::order()", OOMPH_EXCEPTION_LOCATION);
      return 2;
    }

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

set_weights()

template<unsigned NSTEPS>

void oomph::Newmark< NSTEPS >::set_weights

virtual

Set weights.

Implements oomph::TimeStepper.

Reimplemented in oomph::NewmarkBDF< NSTEPS >, oomph::NewmarkBDF< NSTEPS >, oomph::NewmarkBDF< NSTEPS >, and oomph::NewmarkBDF< NSTEPS >.

  {
    double dt = Time_pt->dt(0);
 
    // Weights for second derivs
    Weight(2, 0) = 2.0 / (Beta2 * dt * dt);
    Weight(2, 1) = -2.0 / (Beta2 * dt * dt);
    for (unsigned t = 2; t <= NSTEPS; t++)
    {
      Weight(2, t) = 0.0;
    }
    Weight(2, NSTEPS + 1) = -2.0 / (dt * Beta2);
    Weight(2, NSTEPS + 2) = (Beta2 - 1.0) / Beta2;
 
    // Weights for first derivs.
    Weight(1, 0) = Beta1 * dt * Weight(2, 0);
    Weight(1, 1) = Beta1 * dt * Weight(2, 1);
    for (unsigned t = 2; t <= NSTEPS; t++)
    {
      Weight(1, t) = 0.0;
    }
    Weight(1, NSTEPS + 1) = 1.0 + Beta1 * dt * Weight(2, NSTEPS + 1);
    Weight(1, NSTEPS + 2) =
      dt * (1.0 - Beta1) + Beta1 * dt * Weight(2, NSTEPS + 2);
  }

References GlobalParameters::Beta1, plotPSD::t, Flag_definition::Time_pt, and ProblemParameters::Weight.

shift_time_positions()

template<unsigned NSTEPS>

void oomph::Newmark< 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.

Implements oomph::TimeStepper.

Reimplemented in oomph::NewmarkBDF< 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 = 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] += weight(1, t) * node_pt->x_gen(t, k, i);
          accel[k][i] += 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(), and plotPSD::t.

shift_time_values()

template<unsigned NSTEPS>

void oomph::Newmark< 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.

Implements oomph::TimeStepper.

Reimplemented in oomph::NewmarkBDF< NSTEPS >.

  {
    // Find number of values stored
    unsigned n_value = data_pt->nvalue();
 
    Vector<double> veloc(n_value);
    time_derivative(1, data_pt, veloc);
 
    Vector<double> accel(n_value);
    time_derivative(2, data_pt, accel);
 
    // 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]);
      }
    }
  }

Member Data Documentation

Beta1

template<unsigned NSTEPS>

double oomph::Newmark< NSTEPS >::Beta1

protected

First Newmark parameter (usually 0.5)

Beta2

template<unsigned NSTEPS>

double oomph::Newmark< NSTEPS >::Beta2

protected

Second Newmark parameter (usually 0.5)

---

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

• timesteppers.h
• timesteppers.cc