oomph::TR Class Reference

#include <trapezoid_rule.h>

Inheritance diagram for oomph::TR:

Public Member Functions
	TR (const bool &adaptive=false)
virtual	~TR ()
	Virtual destructor. More...
unsigned	order () const
	Return the actual order of the scheme. More...
void	set_weights ()
	Set the weights. More...
void	set_error_weights ()
void	set_predictor_weights ()
	Function to set the predictor weights. More...
unsigned	nprev_values () const
	Number of previous values available. More...
unsigned	derivative_index (const unsigned &t) const
	Location in data of derivatives. More...
unsigned	predicted_value_index () const
	Location of predicted value. More...
unsigned	ndt () const
	Number of timestep increments that need to be stored by the scheme. More...
void	assign_initial_values_impulsive (Data *const &data_pt)
void	assign_initial_positions_impulsive (Node *const &node_pt)
void	actions_after_timestep (Problem *problem_pt)
void	actions_before_timestep (Problem *problem_pt)
void	setup_initial_derivative (Problem *problem_pt)
void	shift_time_values (Data *const &data_pt)
void	shift_time_positions (Node *const &node_pt)
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...
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...
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...

Public Attributes
bool	Initial_derivative_set
bool	Shift_f

Private Member Functions
	TR (const TR &dummy)=delete
	Broken copy constructor. More...
void	operator= (const TR &dummy)=delete
	Broken assignment operator. More...

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

Trapezoid rule time stepping scheme.

This method requires a value of dy/dt at the initial time. The implementation of this calculation is exactly the same as is used for explicit time stepping.

The function setup_initial_derivative(Problem* problem_pt) should be called after the initial conditions have been set, but before beginning time stepping, to compute this initial value of dy/dt.

Warning: moving nodes not implemented (I have no test case).

Constructor & Destructor Documentation

TR() [1/2]

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

inline

Constructor, storage for two history derivatives (one for TR and one for the predictor step), one history value, present value and predicted value.

                                     : TimeStepper(2 + 2 + 1, 1)
    {
      // Set the weight for the zero-th derivative
      Weight(0, 0) = 1.0;
 
      Initial_derivative_set = false;
 
      Adaptive_Flag = adaptive;
 
      // Initialise adaptivity stuff
      Predictor_weight.assign(4, 0.0);
      Error_weight = 0.0;
 
      Shift_f = true;
    }

References Global_Physical_Variables::adaptive, oomph::TimeStepper::Adaptive_Flag, Error_weight, Initial_derivative_set, Predictor_weight, Shift_f, and oomph::TimeStepper::Weight.

~TR()

virtual oomph::TR::~TR ( )

inlinevirtual

Virtual destructor.

{}

TR() [2/2]

oomph::TR::TR ( const TR &  dummy )

privatedelete

Broken copy constructor.

Member Function Documentation

actions_after_timestep()

void oomph::TR::actions_after_timestep ( Problem *  problem_pt )

inlinevirtual

Interface for any actions that need to be performed after a time step.

Reimplemented from oomph::TimeStepper.

    {
      // only ever want this to be true for one step
      Shift_f = true;
    }

References Shift_f.

actions_before_timestep()

void oomph::TR::actions_before_timestep ( Problem *  problem_pt )

inlinevirtual

Interface for any actions that need to be performed before a time step.

Reimplemented from oomph::TimeStepper.

    {
#ifdef PARANOID
      if (!Initial_derivative_set)
      {
        std::string err = "Initial derivative of TR has not been set";
        throw OomphLibError(
          err, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
      }
#endif
    }

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

assign_initial_positions_impulsive()

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

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

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

assign_initial_values_impulsive()

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

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

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

calculate_predicted_positions()

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

inlinevirtual

Function to calculate predicted positions at a node.

Reimplemented from oomph::TimeStepper.

    {
      // Loop over the dimensions
      unsigned n_dim = node_pt->ndim();
      for (unsigned j = 0; j < n_dim; j++)
      {
        // If the node is not copied
        if (!node_pt->position_is_a_copy(j))
        {
          // Initialise the predictor to zero
          double predicted_value = 0.0;
 
          // 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(predicted_value_index(), j) = predicted_value;
        }
      }
    }

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

calculate_predicted_values()

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

inlinevirtual

Function to calculate predicted data values in a Data object.

Reimplemented from oomph::TimeStepper.

    {
      // Loop over the values
      unsigned n_value = data_pt->nvalue();
      for (unsigned j = 0; j < n_value; j++)
      {
        // If the value is not copied
        if (!data_pt->is_a_copy(j))
        {
          // Loop over all the stored data and add appropriate
          // values to the predictor
          double predicted_value = 0.0;
          for (unsigned i = 1; i < 4; i++)
          {
            predicted_value += data_pt->value(i, j) * Predictor_weight[i];
          }
 
          // Store the predicted value
          data_pt->set_value(predicted_value_index(), j, predicted_value);
        }
      }
    }

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

derivative_index()

unsigned oomph::TR::derivative_index ( const unsigned &  t ) const

inline

Location in data of derivatives.

    {
#ifdef PARANOID
      if (t >= 2)
      {
        std::string err = "Only storing two derivatives.";
        throw OomphLibError(
          err, OOMPH_EXCEPTION_LOCATION, OOMPH_CURRENT_FUNCTION);
      }
#endif
      return t + 2;
    }

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

Referenced by predicted_value_index(), set_predictor_weights(), set_weights(), setup_initial_derivative(), and shift_time_values().

ndt()

unsigned oomph::TR::ndt ( ) const

inlinevirtual

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

Implements oomph::TimeStepper.

    {
      return 2;
    }

nprev_values()

unsigned oomph::TR::nprev_values ( ) const

inlinevirtual

Number of previous values available.

Implements oomph::TimeStepper.

    {
      return 1;
    }

operator=()

void oomph::TR::operator= ( const TR &  dummy )

privatedelete

Broken assignment operator.

order()

unsigned oomph::TR::order ( ) const

inlinevirtual

Return the actual order of the scheme.

Reimplemented from oomph::TimeStepper.

    {
      return 2;
    }

predicted_value_index()

unsigned oomph::TR::predicted_value_index ( ) const

inline

Location of predicted value.

    {
      return derivative_index(1) + 1;
    }

References derivative_index().

Referenced by calculate_predicted_positions(), calculate_predicted_values(), temporal_error_in_position(), and temporal_error_in_value().

set_error_weights()

void oomph::TR::set_error_weights ( )

inlinevirtual

Set the weights for the error computation, (currently empty – overwrite for specific scheme)

Reimplemented from oomph::TimeStepper.

    {
      double dt = Time_pt->dt(0);
      double dtprev = Time_pt->dt(1);
      Error_weight = 1 / (3 * (1 + (dtprev / dt)));
    }

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

set_predictor_weights()

void oomph::TR::set_predictor_weights ( )

inlinevirtual

Function to set the predictor weights.

Reimplemented from oomph::TimeStepper.

    {
      // Read the value of the time steps
      double dt = Time_pt->dt(0);
      double dtprev = Time_pt->dt(1);
      double dtr = dt / dtprev;
 
      // y weights
      Predictor_weight[0] = 0.0;
      Predictor_weight[1] = 1.0;
 
      // dy weights
      Predictor_weight[derivative_index(0)] = (dt / 2) * (2 + dtr);
      Predictor_weight[derivative_index(1)] = -(dt / 2) * dtr;
    }

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

set_weights()

void oomph::TR::set_weights ( )

inlinevirtual

Set the weights.

Implements oomph::TimeStepper.

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

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

setup_initial_derivative()

void oomph::TR::setup_initial_derivative ( Problem *  problem_pt )

inline

    {
      oomph_info
        << "Solving for derivative at initial time."
        << " Warning: if residual is not in the correct form this may fail."
        << std::endl;
 
      // Get the derivative at initial time
      DoubleVector f0;
      problem_pt->get_dvaluesdt(f0);
 
      // store in derivatives slot ready for use in timestepping.
      problem_pt->set_dofs(this->derivative_index(0), f0);
 
      Initial_derivative_set = true;
      Shift_f = false;
    }

References derivative_index(), oomph::Problem::get_dvaluesdt(), Initial_derivative_set, oomph::oomph_info, oomph::Problem::set_dofs(), and Shift_f.

Referenced by oomph::MyProblem::actions_after_set_initial_condition().

shift_time_positions()

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

inlinevirtual

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

Implements oomph::TimeStepper.

    {
      // do nothing, not implemented for moving nodes
    }

shift_time_values()

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

Implements oomph::TimeStepper.

    {
      // Find number of values stored
      unsigned n_value = data_pt->nvalue();
 
      // Get previous step dt, time_pt has already been shifted so it's in
      // slot 1.
      double dtn = time_pt()->dt(1);
 
      // 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)
        {
          if (Shift_f)
          {
            // Calculate time derivative at step n by rearranging the TR
            // formula.
            double fnm1 = data_pt->value(derivative_index(0), j);
            double ynm1 = data_pt->value(1, j);
            double yn = data_pt->value(0, j);
            double fn = (2 / dtn) * (yn - ynm1) - fnm1;
 
            data_pt->set_value(derivative_index(0), j, fn);
 
            // Shift time derivative
            data_pt->set_value(derivative_index(1), j, fnm1);
          }
          else
          {
            std::cout << "didn't shift derivatives" << std::endl;
          }
 
          // Shift value
          data_pt->set_value(1, j, data_pt->value(0, j));
        }
      }
    }

References derivative_index(), oomph::Time::dt(), oomph::Data::is_a_copy(), j, oomph::Data::nvalue(), oomph::Data::set_value(), Shift_f, oomph::TimeStepper::time_pt(), and oomph::Data::value().

temporal_error_in_position()

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

inlinevirtual

Compute the error in the position i at a node.

Reimplemented from oomph::TimeStepper.

    {
      return Error_weight *
             (node_pt->x(i) - node_pt->x(predicted_value_index(), i));
    }

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

temporal_error_in_value()

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

inlinevirtual

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

Reimplemented from oomph::TimeStepper.

    {
      return Error_weight *
             (data_pt->value(i) - data_pt->value(predicted_value_index(), i));
    }

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

Member Data Documentation

Error_weight

double oomph::TR::Error_weight

private

Private data for the error weight.

Referenced by set_error_weights(), temporal_error_in_position(), temporal_error_in_value(), and TR().

Initial_derivative_set

bool oomph::TR::Initial_derivative_set

Referenced by actions_before_timestep(), setup_initial_derivative(), and TR().

Predictor_weight

Vector<double> oomph::TR::Predictor_weight

private

Private data for the predictor weights.

Referenced by calculate_predicted_positions(), calculate_predicted_values(), set_predictor_weights(), and TR().

Shift_f

bool oomph::TR::Shift_f

Referenced by actions_after_timestep(), setup_initial_derivative(), shift_time_values(), and TR().

---

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

• trapezoid_rule.h