oomph::VorticityRecoveryHelpers::RecoveryHelper Class Reference

#include <vorticity_smoother.h>

Public Member Functions
	RecoveryHelper ()
	Constructor. More...
int	maximum_order_of_vorticity_derivative () const
	The maximum order of derivatives calculated in the vorticity recovery. More...
int	maximum_order_of_velocity_derivative () const
	The maximum order of derivatives calculated in the velocity recovery. More...
void	set_maximum_order_of_vorticity_derivative (const int &max_deriv)
	The maximum order of derivatives calculated in the vorticity recovery. More...
void	set_maximum_order_of_velocity_derivative (const int &max_deriv)
	The maximum order of derivatives calculated in the velocity recovery. More...
void	calculate_number_of_values_per_field ()
unsigned	npartial_derivative (const unsigned &n) const
unsigned	ncont_interpolated_values () const
	Number of continuously interpolated values: More...

Private Attributes
unsigned	Number_of_values_per_field
int	Maximum_order_of_vorticity_derivative
int	Maximum_order_of_velocity_derivative

Detailed Description

Class to indicate which derivatives of the vorticity/ velocity we want to recover. We choose to immediately instantiate an object of this class by dropping the semi-colon after the class description.

Constructor & Destructor Documentation

RecoveryHelper()

oomph::VorticityRecoveryHelpers::RecoveryHelper::RecoveryHelper ( )

inline

Constructor.

      {
        // Set the default (max) order of vorticity derivative to recover
        Maximum_order_of_vorticity_derivative = -1;
 
        // Set the default (max) order of velocity derivative to recover
        Maximum_order_of_velocity_derivative = 0;
      }

References Maximum_order_of_velocity_derivative, and Maximum_order_of_vorticity_derivative.

Member Function Documentation

calculate_number_of_values_per_field()

void oomph::VorticityRecoveryHelpers::RecoveryHelper::calculate_number_of_values_per_field ( )

inline

Calculates the number of values per field given the number of vorticity and velocity derivatives to recover (stored as private data)

      {
        // Output: u,v,p
        Number_of_values_per_field = 3;
 
        // Loop over the vorticity derivatives
        for (unsigned i = 0;
             i < unsigned(Maximum_order_of_vorticity_derivative + 1);
             i++)
        {
          // Update the number of values per field
          Number_of_values_per_field += npartial_derivative(i);
        }
 
        // Loop over the velocity derivatives
        for (unsigned i = 1;
             i < unsigned(Maximum_order_of_velocity_derivative + 1);
             i++)
        {
          // Update the number of values per field
          Number_of_values_per_field += 2 * npartial_derivative(i);
        }
      } // End of calculate_number_of_values_per_field

References i, Maximum_order_of_velocity_derivative, Maximum_order_of_vorticity_derivative, npartial_derivative(), and Number_of_values_per_field.

Referenced by set_maximum_order_of_velocity_derivative(), and set_maximum_order_of_vorticity_derivative().

maximum_order_of_velocity_derivative()

int oomph::VorticityRecoveryHelpers::RecoveryHelper::maximum_order_of_velocity_derivative ( ) const

inline

The maximum order of derivatives calculated in the velocity recovery.

      {
        // Return the appropriate value
        return Maximum_order_of_velocity_derivative;
      } // End of get_maximum_order_of_velocity_derivative

References Maximum_order_of_velocity_derivative.

Referenced by oomph::VorticitySmootherElement< ELEMENT >::VorticitySmootherElement().

maximum_order_of_vorticity_derivative()

int oomph::VorticityRecoveryHelpers::RecoveryHelper::maximum_order_of_vorticity_derivative ( ) const

inline

The maximum order of derivatives calculated in the vorticity recovery.

      {
        // Return the appropriate value
        return Maximum_order_of_vorticity_derivative;
      } // End of get_maximum_order_of_vorticity_derivative

References Maximum_order_of_vorticity_derivative.

Referenced by oomph::VorticitySmootherElement< ELEMENT >::VorticitySmootherElement().

ncont_interpolated_values()

unsigned oomph::VorticityRecoveryHelpers::RecoveryHelper::ncont_interpolated_values ( ) const

inline

Number of continuously interpolated values:

      {
        // Return the number of values used per field
        return Number_of_values_per_field;
      } // End of ncont_interpolated_values

References Number_of_values_per_field.

Referenced by oomph::VorticitySmootherElement< ELEMENT >::VorticitySmootherElement().

npartial_derivative()

unsigned oomph::VorticityRecoveryHelpers::RecoveryHelper::npartial_derivative ( const unsigned &  n ) const

inline

Helper function that determines the number of n-th order partial derivatives in d-dimensions. Specifically there are (n+d-1)(choose)(d-1) possible n-th order partial derivatives in d-dimensions. Implementation makes use of the code found at: www.geeksforgeeks.org/space-and-time-efficient-binomial-coefficient/

      {
        // This will only work in 2D so n_dim is always 2
        unsigned n_dim = 2;
 
        // Calculate m
        unsigned n_bins = n + n_dim - 1;
 
        // Calculate k
        unsigned k = n_dim - 1;
 
        // Initialise the result
        unsigned value = 1;
 
        // Since C(n_bins,k)=C(n_bins,n_bins-k)
        if (k > n_bins - k)
        {
          // Replace k
          k = n_bins - k;
        }
 
        // Calculate [n_bins*(n_bins-1)*...*(n_bins-k+1)]/[k*(k-1)*...*1]
        for (unsigned i = 0; i < k; ++i)
        {
          // First update
          value *= (n_bins - i);
 
          // Second update
          value /= (i + 1);
        }
 
        // Return the result
        return value;
      } // End of npartial_derivative

References i, k, n, and Eigen::value.

Referenced by calculate_number_of_values_per_field(), and oomph::VorticitySmootherElement< ELEMENT >::npartial_derivative().

set_maximum_order_of_velocity_derivative()

void oomph::VorticityRecoveryHelpers::RecoveryHelper::set_maximum_order_of_velocity_derivative ( const int &  max_deriv )

inline

The maximum order of derivatives calculated in the velocity recovery.

      {
        // Make sure the user has supplied a valid input value. Note, unlike the
        // vorticity, we always output the zeroth derivative of the velocity
        // so we don't use -1 as an input
        if ((max_deriv < 0) || (max_deriv > 1))
        {
          // Throw an error
          throw OomphLibError("Invalid input value! Should be between 0 and 3!",
                              OOMPH_CURRENT_FUNCTION,
                              OOMPH_EXCEPTION_LOCATION);
        }
 
        // Return the appropriate value
        Maximum_order_of_velocity_derivative = max_deriv;
 
        // Calculate the value of Number_of_values_per_field with the updated
        // value of Maximum_order_of_velocity_derivative
        calculate_number_of_values_per_field();
      } // End of set_maximum_order_of_vorticity_derivative

References calculate_number_of_values_per_field(), Maximum_order_of_velocity_derivative, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

set_maximum_order_of_vorticity_derivative()

void oomph::VorticityRecoveryHelpers::RecoveryHelper::set_maximum_order_of_vorticity_derivative ( const int &  max_deriv )

inline

The maximum order of derivatives calculated in the vorticity recovery.

      {
        // Make sure the user has supplied a valid input value
        if ((max_deriv < -1) || (max_deriv > 3))
        {
          // Throw an error
          throw OomphLibError(
            "Invalid input value! Should be between -1 and 3!",
            OOMPH_CURRENT_FUNCTION,
            OOMPH_EXCEPTION_LOCATION);
        }
 
        // Return the appropriate value
        Maximum_order_of_vorticity_derivative = max_deriv;
 
        // Calculate the value of Number_of_values_per_field with the updated
        // value of Maximum_order_of_vorticity_derivative
        calculate_number_of_values_per_field();
      } // End of set_maximum_order_of_vorticity_derivative

References calculate_number_of_values_per_field(), Maximum_order_of_vorticity_derivative, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Member Data Documentation

Maximum_order_of_velocity_derivative

int oomph::VorticityRecoveryHelpers::RecoveryHelper::Maximum_order_of_velocity_derivative

private

Maximum number of derivatives to retain in the velocity recovery. Note, the value 0 means we don't calculate the derivatives of the velocity

Referenced by calculate_number_of_values_per_field(), maximum_order_of_velocity_derivative(), RecoveryHelper(), and set_maximum_order_of_velocity_derivative().

Maximum_order_of_vorticity_derivative

int oomph::VorticityRecoveryHelpers::RecoveryHelper::Maximum_order_of_vorticity_derivative

private

Maximum number of derivatives to retain in the vorticity recovery. Note, the value -1 means we ONLY output u,v[,w],p.

Referenced by calculate_number_of_values_per_field(), maximum_order_of_vorticity_derivative(), RecoveryHelper(), and set_maximum_order_of_vorticity_derivative().

Number_of_values_per_field

unsigned oomph::VorticityRecoveryHelpers::RecoveryHelper::Number_of_values_per_field

private

Number of values per field; how many of the following do we want: u,v,p,omega,d/dx,d/dy, d^2/dx^2,d^2/dxdy,d^2/dy^2, d^3/dx^3,d^3/dx^2dy,d^3/dxdy^2,d^3/dy^3, du/dx,du/dy,dv/dx,dv/dy

Referenced by calculate_number_of_values_per_field(), and ncont_interpolated_values().

---

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

• vorticity_smoother.h