#include <vorticity_smoother.h>

Inheritance diagram for oomph::VorticitySmootherElement< ELEMENT >:

Public Types
typedef void(*	ExactVorticityFctPt) (const Vector< double > &x, Vector< Vector< double >> &vort_and_derivs)

Public Member Functions
	VorticitySmootherElement ()
	Constructor. More...

Vector< Vector< double > >	create_container_for_vorticity_and_derivatives () const

std::pair< unsigned, unsigned >	vorticity_dof_to_container_id (const unsigned &i) const

std::pair< unsigned, unsigned >	recovered_dof_to_container_id (const unsigned &i) const

unsigned	stored_dof_to_recoverable_dof (const unsigned &i) const

unsigned	get_maximum_order_of_recoverable_vorticity_derivative () const

unsigned	get_maximum_order_of_recoverable_velocity_derivative () const

int	get_maximum_order_of_vorticity_derivative () const

int	get_maximum_order_of_velocity_derivative () const

unsigned	nvorticity_derivatives_to_recover () const

unsigned	nvelocity_derivatives_to_recover () const

unsigned	npartial_derivative (const unsigned &n) const
	Call the function written in VorticityRecoveryHelpers. More...

ExactVorticityFctPt &	exact_vorticity_fct_pt ()

ExactVorticityFctPt	exact_vorticity_fct_pt () const

unsigned	smoothed_vorticity_index () const
	Index of smoothed vorticity – followed by derivatives. More...

unsigned	required_nvalue (const unsigned &n) const

unsigned	ncont_interpolated_values () const
	Number of continuously interpolated values: More...

void	get_interpolated_values (const Vector< double > &s, Vector< double > &values)

void	get_interpolated_values (const unsigned &t, const Vector< double > &s, Vector< double > &values)

void	pin_smoothed_vorticity ()
	Pin all smoothed vorticity quantities. More...

void	output_analytical_veloc_and_vorticity (std::ostream &outfile, const unsigned &nplot)

void	output_smoothed_vorticity (std::ostream &outfile, const unsigned &nplot)
	Output the velocity, smoothed vorticity and derivatives. More...

unsigned	nscalar_paraview () const

void	scalar_value_paraview (std::ofstream &file_out, const unsigned &i, const unsigned &nplot) const

std::string	scalar_name_paraview (const unsigned &i) const

void	output (std::ostream &outfile, const unsigned &nplot)

void	get_raw_velocity_deriv (const Vector< double > &s, Vector< double > &dveloc_dx) const
	Get raw derivative of velocity. More...

void	get_raw_velocity_deriv (const Vector< double > &s, double &dveloc_dx, const unsigned &index) const
	Get raw derivative of velocity. More...

void	get_raw_vorticity_deriv (const Vector< double > &s, Vector< double > &dvorticity_dx) const
	Get raw derivative of smoothed vorticity. More...

void	get_raw_vorticity_deriv (const Vector< double > &s, double &dvorticity_dx, const unsigned &index) const
	Get raw derivative of smoothed vorticity. More...

void	get_raw_vorticity_second_deriv (const Vector< double > &s, Vector< double > &dvorticity_dxdy) const
	Get raw derivative of smoothed derivative vorticity. More...

void	get_raw_vorticity_second_deriv (const Vector< double > &s, double &dvorticity_dxdy, const unsigned &index) const

void	get_raw_vorticity_third_deriv (const Vector< double > &s, Vector< double > &dvorticity_dxdxdy) const

void	get_raw_vorticity_third_deriv (const Vector< double > &s, double &dvorticity_dxdxdy, const unsigned &index) const

double	vorticity_error_squared (const unsigned &i)

void	vorticity_and_its_derivs (const Vector< double > &s, Vector< Vector< double >> &vort_and_derivs) const
	Compute smoothed vorticity and its derivatives. More...

Private Attributes
unsigned	N_dim
	Number of dimensions in the element. More...

unsigned	Smoothed_vorticity_index

unsigned	Maximum_order_of_recoverable_vorticity_derivatives

unsigned	Maximum_order_of_recoverable_velocity_derivatives

unsigned	Number_of_values_per_field

int	Maximum_order_of_vorticity_derivative

int	Maximum_order_of_velocity_derivative

ExactVorticityFctPt	Exact_vorticity_fct_pt

Detailed Description

template<class ELEMENT>
class oomph::VorticitySmootherElement< ELEMENT >

Overloaded element that allows projection of vorticity.

Member Typedef Documentation

◆ ExactVorticityFctPt

template<class ELEMENT >

typedef void(* oomph::VorticitySmootherElement< ELEMENT >::ExactVorticityFctPt) (const Vector< double > &x, Vector< Vector< double >> &vort_and_derivs)

Typedef for pointer to function that specifies the exact vorticity and derivatives (for validation)

Constructor & Destructor Documentation

◆ VorticitySmootherElement()

template<class ELEMENT >

oomph::VorticitySmootherElement< ELEMENT >::VorticitySmootherElement ( )

inline

Constructor.

     {
       // Only done for 2D (3D is far more difficult -- recovering a vector field
       // instead of a scalar field)
       N_dim = 2;
  
       // Index of smoothed vorticity ([0]:u, [1]:v, [2]:p ==> [3]:w)
       Smoothed_vorticity_index = 3;
  
       // The current maximum order of vorticity derivatives we can recover. This
       // is currently 10 as we can recover from the zeroth to third derivative
       Maximum_order_of_recoverable_vorticity_derivatives = 3;
  
       // The current maximum order of velocity derivatives we can recover.
       // Currently this is 4 as we only recover first derivatives.
       Maximum_order_of_recoverable_velocity_derivatives = 1;
  
       // Recover as many
       Maximum_order_of_vorticity_derivative =
         VorticityRecoveryHelpers::Recovery_helper
           .maximum_order_of_vorticity_derivative();
  
       // The default is to recover the velocity derivatives
       Maximum_order_of_velocity_derivative =
         VorticityRecoveryHelpers::Recovery_helper
           .maximum_order_of_velocity_derivative();
  
       // Set the number of values per field
       Number_of_values_per_field =
         VorticityRecoveryHelpers::Recovery_helper.ncont_interpolated_values();
  
       // Pointer to fct that specifies exact vorticity and
       // derivs (for validation).
       Exact_vorticity_fct_pt = 0;
     }

Member Function Documentation

◆ create_container_for_vorticity_and_derivatives()

template<class ELEMENT >

Vector<Vector<double> > oomph::VorticitySmootherElement< ELEMENT >::create_container_for_vorticity_and_derivatives ( ) const

inline

Helper function to create a container for the vorticity and its partial derivatives. If the user wishes to output everything then this also creates space for the velocity derivatives too. This function has been written to allow for generalisation of the storage without (hopefully!) affecting too much

     {
       // Maximum number of vorticity derivatives
       unsigned n_vort_deriv = Maximum_order_of_vorticity_derivative;
  
       // Maximum number of velocity derivatives
       unsigned n_veloc_deriv = Maximum_order_of_velocity_derivative;
  
       // The number of vectors in the output
       unsigned n_vector = n_vort_deriv + n_veloc_deriv + 1;
  
       // Container for the vorticity and its derivatives
       Vector<Vector<double>> vort_and_derivs(n_vector);
  
       // Loop over the entries of the vector
       for (unsigned i = 0; i < n_vort_deriv + 1; i++)
       {
         // Get the number of partial derivatives of the vorticity
         vort_and_derivs[i].resize(npartial_derivative(i), 0.0);
       }
  
       // Loop over the entries of the vector
       for (unsigned i = n_vort_deriv + 1; i < n_vort_deriv + n_veloc_deriv + 1;
            i++)
       {
         // Resize the container and initialise all entries to zero
         vort_and_derivs[i].resize(2 * npartial_derivative(i - n_vort_deriv),
                                   0.0);
       }
  
       // Return the container
       return vort_and_derivs;
     } // End of create_container_for_vorticity_and_derivatives

References i, oomph::VorticitySmootherElement< ELEMENT >::Maximum_order_of_velocity_derivative, oomph::VorticitySmootherElement< ELEMENT >::Maximum_order_of_vorticity_derivative, and oomph::VorticitySmootherElement< ELEMENT >::npartial_derivative().

Referenced by oomph::VorticitySmootherElement< ELEMENT >::output(), oomph::VorticitySmootherElement< ELEMENT >::output_analytical_veloc_and_vorticity(), oomph::VorticitySmootherElement< ELEMENT >::output_smoothed_vorticity(), oomph::VorticitySmootherElement< ELEMENT >::scalar_value_paraview(), and oomph::VorticitySmootherElement< ELEMENT >::vorticity_error_squared().

◆ exact_vorticity_fct_pt() [1/2]

template<class ELEMENT >

ExactVorticityFctPt& oomph::VorticitySmootherElement< ELEMENT >::exact_vorticity_fct_pt ( )

inline

Access function: Pointer to function that specifies exact vorticity and derivatives (for validation).

     {
       // Return the address of the function pointer
       return Exact_vorticity_fct_pt;
     } // End of exact_vorticity_fct_pt

References oomph::VorticitySmootherElement< ELEMENT >::Exact_vorticity_fct_pt.

◆ exact_vorticity_fct_pt() [2/2]

template<class ELEMENT >

ExactVorticityFctPt oomph::VorticitySmootherElement< ELEMENT >::exact_vorticity_fct_pt ( ) const

inline

Access function: Pointer to function that specifies exact vorticity and derivatives (for validation) – const version

     {
       // Return the address of the function pointer
       return Exact_vorticity_fct_pt;
     } // End of exact_vorticity_fct_pt

References oomph::VorticitySmootherElement< ELEMENT >::Exact_vorticity_fct_pt.

◆ get_interpolated_values() [1/2]

template<class ELEMENT >

void oomph::VorticitySmootherElement< ELEMENT >::get_interpolated_values	(	const unsigned &	t,
		const Vector< double > &	s,
		Vector< double > &	values
	)

inline

Get the function value u in Vector. Note: Given the generality of the interface (this function is usually called from black-box documentation or interpolation routines), the values Vector sets its own size in here.

     {
       // Set size of vector and initialise all entries to zero
       values.resize(Number_of_values_per_field, 0.0);
  
       // Find out how many nodes there are
       unsigned n_node = this->nnode();
  
       // Shape functions
       Shape psif(n_node);
  
       // Get the value of the shape function at the local coordinate s
       this->shape(s, psif);
  
       // Calculate velocities: values[0],...
       for (unsigned i = 0; i < N_dim; i++)
       {
         // Get the index at which the i-th velocity is stored
         unsigned u_nodal_index = this->u_index_nst(i);
  
         // Loop over the nodes
         for (unsigned l = 0; l < n_node; l++)
         {
           // Update the i-th entry of the value vector
           values[i] += this->nodal_value(t, l, u_nodal_index) * psif[l];
         }
       } // for (unsigned i=0;i<N_dim;i++)
  
       // Calculate pressure: values[N_dim] (no history is carried in the
       // pressure)
       values[N_dim] = this->interpolated_p_nst(s);
     } // End of get_interpolated_values

References i, oomph::VorticitySmootherElement< ELEMENT >::N_dim, oomph::VorticitySmootherElement< ELEMENT >::Number_of_values_per_field, s, oomph::OneDimLagrange::shape(), and plotPSD::t.

◆ get_interpolated_values() [2/2]

template<class ELEMENT >

void oomph::VorticitySmootherElement< ELEMENT >::get_interpolated_values	(	const Vector< double > &	s,
		Vector< double > &	values
	)

inline

Get the function value u in Vector. Note: Given the generality of the interface (this function is usually called from black-box documentation or interpolation routines), the values Vector sets its own size in here.

     {
       // Get the value at the current time
       unsigned t = 0;
  
       // Get the interpolated values
       get_interpolated_values(t, s, values);
     } // End of get_interpolated_values

References s, and plotPSD::t.

◆ get_maximum_order_of_recoverable_velocity_derivative()

template<class ELEMENT >

unsigned oomph::VorticitySmootherElement< ELEMENT >::get_maximum_order_of_recoverable_velocity_derivative ( ) const

inline

The maximum order of velocity derivative that can be recovered. This is set in the constructor and should NOT be changed during the running of the code. As such, a set...() function is not provided. DRAIG: Leave get_ prefix?

     {
       // Return the appropriate value
       return Maximum_order_of_recoverable_velocity_derivatives;
     } // End of get_maximum_order_of_recoverable_velocity_derivative

References oomph::VorticitySmootherElement< ELEMENT >::Maximum_order_of_recoverable_velocity_derivatives.

◆ get_maximum_order_of_recoverable_vorticity_derivative()

template<class ELEMENT >

unsigned oomph::VorticitySmootherElement< ELEMENT >::get_maximum_order_of_recoverable_vorticity_derivative ( ) const

inline

The maximum order of vorticity derivative that can be recovered. This is set in the constructor and should NOT be changed during the running of the code. As such, a set...() function is not provided. DRAIG: Leave get_ prefix?

     {
       // Return the appropriate value
       return Maximum_order_of_recoverable_vorticity_derivatives;
     } // End of get_maximum_order_of_recoverable_vorticity_derivative

References oomph::VorticitySmootherElement< ELEMENT >::Maximum_order_of_recoverable_vorticity_derivatives.

◆ get_maximum_order_of_velocity_derivative()

template<class ELEMENT >

int oomph::VorticitySmootherElement< ELEMENT >::get_maximum_order_of_velocity_derivative ( ) const

inline

The maximum order of derivatives calculated in the velocity recovery. Note, this value can only be set through the namespace VorticityRecoveryHelpers. DRAIG: Leave get_ prefix?

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

References oomph::VorticitySmootherElement< ELEMENT >::Maximum_order_of_velocity_derivative.

◆ get_maximum_order_of_vorticity_derivative()

template<class ELEMENT >

int oomph::VorticitySmootherElement< ELEMENT >::get_maximum_order_of_vorticity_derivative ( ) const

inline

The maximum order of derivatives calculated in the vorticity recovery. Note, this value can only be set through the namespace VorticityRecoveryHelpers. DRAIG: Leave get_ prefix?

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

References oomph::VorticitySmootherElement< ELEMENT >::Maximum_order_of_vorticity_derivative.

◆ get_raw_velocity_deriv() [1/2]

template<class ELEMENT >

void oomph::VorticitySmootherElement< ELEMENT >::get_raw_velocity_deriv	(	const Vector< double > &	s,
		double &	dveloc_dx,
		const unsigned &	index
	)		const

inline

Get raw derivative of velocity.

     {
       // Find out how many nodes there are
       unsigned n_node = this->nnode();
  
       // Set up memory for the shape functions
       Shape psif(n_node);
  
       // Set up memory for the shape function derivatives
       DShape dpsifdx(n_node, 2);
  
       // Call the derivatives of the shape and test functions
       this->dshape_eulerian(s, psif, dpsifdx);
  
       // Initialise value to zero
       dveloc_dx = 0.0;
  
       // Use a switch statement
       switch (index)
       {
         case 0:
           // Loop over the nodes
           for (unsigned l = 0; l < n_node; l++)
           {
             // Derivatives of the first velocity component
             dveloc_dx += this->nodal_value(l, 0) * dpsifdx(l, 0);
           }
           break;
         case 1:
           // Loop over the nodes
           for (unsigned l = 0; l < n_node; l++)
           {
             // Derivatives of the first velocity component
             dveloc_dx += this->nodal_value(l, 0) * dpsifdx(l, 1);
           }
           break;
         case 2:
           // Loop over the nodes
           for (unsigned l = 0; l < n_node; l++)
           {
             // Derivatives of the second velocity component
             dveloc_dx += this->nodal_value(l, 1) * dpsifdx(l, 0);
           }
           break;
         case 3:
           // Loop over the nodes
           for (unsigned l = 0; l < n_node; l++)
           {
             // Derivatives of the second velocity component
             dveloc_dx += this->nodal_value(l, 1) * dpsifdx(l, 1);
           }
           break;
         default:
           oomph_info << "Never get here!" << std::endl;
           abort();
       }
     } // End of get_raw_velocity_deriv

References oomph::oomph_info, and s.

◆ get_raw_velocity_deriv() [2/2]

template<class ELEMENT >

void oomph::VorticitySmootherElement< ELEMENT >::get_raw_velocity_deriv	(	const Vector< double > &	s,
		Vector< double > &	dveloc_dx
	)		const

inline

Get raw derivative of velocity.

     {
       // Find out how many nodes there are
       unsigned n_node = this->nnode();
  
       // Set up memory for the shape functions
       Shape psif(n_node);
  
       // Set up memory for the shape function derivatives
       DShape dpsifdx(n_node, 2);
  
       // Call the derivatives of the shape and test functions
       this->dshape_eulerian(s, psif, dpsifdx);
  
       // Initialise all entries to zero
       dveloc_dx.initialise(0.0);
  
       // Loop over nodes
       for (unsigned l = 0; l < n_node; l++)
       {
         // Loop over derivative directions
         for (unsigned j = 0; j < 2; j++)
         {
           // Derivatives of the first velocity component
           dveloc_dx[j] += this->nodal_value(l, 0) * dpsifdx(l, j);
  
           // Derivatives of the second velocity component
           dveloc_dx[j + 2] += this->nodal_value(l, 1) * dpsifdx(l, j);
         }
       } // for (unsigned l=0;l<n_node;l++)
     } // End of get_raw_velocity_deriv

References oomph::Vector< _Tp >::initialise(), j, and s.

◆ get_raw_vorticity_deriv() [1/2]

template<class ELEMENT >

void oomph::VorticitySmootherElement< ELEMENT >::get_raw_vorticity_deriv	(	const Vector< double > &	s,
		double &	dvorticity_dx,
		const unsigned &	index
	)		const

inline

Get raw derivative of smoothed vorticity.

     {
       // Find out how many nodes there are
       unsigned n_node = this->nnode();
  
       // Set up memory for the shape functions
       Shape psif(n_node);
  
       // Set up memory for the shape function derivatives
       DShape dpsifdx(n_node, 2);
  
       // Call the derivatives of the shape and test functions
       this->dshape_eulerian(s, psif, dpsifdx);
  
       // Initialise value to zero
       dvorticity_dx = 0.0;
  
       // Use a switch statement
       switch (index)
       {
         case 0:
           // Loop over the nodes
           for (unsigned l = 0; l < n_node; l++)
           {
             // Calculate the x derivative
             dvorticity_dx +=
               this->nodal_value(l, Smoothed_vorticity_index) * dpsifdx(l, 0);
           }
           break;
         case 1:
           // Loop over the nodes
           for (unsigned l = 0; l < n_node; l++)
           {
             // Calculate the y derivative
             dvorticity_dx +=
               this->nodal_value(l, Smoothed_vorticity_index) * dpsifdx(l, 1);
           }
           break;
         default:
           oomph_info << "Never get here!" << std::endl;
           abort();
       }
     } // End of get_raw_vorticity_deriv

References oomph::oomph_info, s, and oomph::VorticitySmootherElement< ELEMENT >::Smoothed_vorticity_index.

◆ get_raw_vorticity_deriv() [2/2]

template<class ELEMENT >

void oomph::VorticitySmootherElement< ELEMENT >::get_raw_vorticity_deriv	(	const Vector< double > &	s,
		Vector< double > &	dvorticity_dx
	)		const

inline

Get raw derivative of smoothed vorticity.

     {
       // Find out how many nodes there are
       unsigned n_node = this->nnode();
  
       // Set up memory for the shape functions
       Shape psif(n_node);
  
       // Set up memory for the shape function derivatives
       DShape dpsifdx(n_node, 2);
  
       // Call the derivatives of the shape and test functions
       this->dshape_eulerian(s, psif, dpsifdx);
  
       // Initialise all entries to zero
       dvorticity_dx.initialise(0.0);
  
       // Loop over nodes
       for (unsigned l = 0; l < n_node; l++)
       {
         // Loop over derivative directions
         for (unsigned j = 0; j < 2; j++)
         {
           // Calculate the x and y derivative
           dvorticity_dx[j] +=
             this->nodal_value(l, Smoothed_vorticity_index) * dpsifdx(l, j);
         }
       } // for (unsigned l=0;l<n_node;l++)
     } // End of get_raw_vorticity_deriv

References oomph::Vector< _Tp >::initialise(), j, s, and oomph::VorticitySmootherElement< ELEMENT >::Smoothed_vorticity_index.

◆ get_raw_vorticity_second_deriv() [1/2]

template<class ELEMENT >

void oomph::VorticitySmootherElement< ELEMENT >::get_raw_vorticity_second_deriv	(	const Vector< double > &	s,
		double &	dvorticity_dxdy,
		const unsigned &	index
	)		const

inline

Get raw derivative of smoothed derivative vorticity [0]: d^2/dx^2, [1]: d^2/dxdy, [2]: d^2/dy^2

     {
       // Find out how many nodes there are
       unsigned n_node = this->nnode();
  
       // Set up memory for the shape functions
       Shape psif(n_node);
  
       // Set up memory for the shape function derivatives
       DShape dpsifdx(n_node, 2);
  
       // Call the derivatives of the shape and test functions
       this->dshape_eulerian(s, psif, dpsifdx);
  
       // Initialise value to zero
       dvorticity_dxdy = 0.0;
  
       // Use a switch statement
       switch (index)
       {
         case 0:
           // Loop over the nodes
           for (unsigned l = 0; l < n_node; l++)
           {
             // Calculate xx derivative
             dvorticity_dxdy +=
               this->nodal_value(l, Smoothed_vorticity_index + 1) *
               dpsifdx(l, 0);
           }
           break;
         case 1:
           // Loop over the nodes
           for (unsigned l = 0; l < n_node; l++)
           {
             // Calculate xy derivative
             dvorticity_dxdy +=
               this->nodal_value(l, Smoothed_vorticity_index + 1) *
               dpsifdx(l, 1);
           }
           break;
         case 2:
           // Loop over the nodes
           for (unsigned l = 0; l < n_node; l++)
           {
             // Calculate the yy derivative
             dvorticity_dxdy +=
               this->nodal_value(l, Smoothed_vorticity_index + 2) *
               dpsifdx(l, 1);
           }
           break;
         default:
           oomph_info << "Never get here!" << std::endl;
           abort();
       }
     } // End of get_raw_vorticity_second_deriv

References oomph::oomph_info, s, and oomph::VorticitySmootherElement< ELEMENT >::Smoothed_vorticity_index.

◆ get_raw_vorticity_second_deriv() [2/2]

template<class ELEMENT >

void oomph::VorticitySmootherElement< ELEMENT >::get_raw_vorticity_second_deriv	(	const Vector< double > &	s,
		Vector< double > &	dvorticity_dxdy
	)		const

inline

Get raw derivative of smoothed derivative vorticity.

     {
       // Find out how many nodes there are
       unsigned n_node = this->nnode();
  
       // Set up memory for the shape functions
       Shape psif(n_node);
  
       // Set up memory for the shape function derivatives
       DShape dpsifdx(n_node, 2);
  
       // Call the derivatives of the shape and test functions
       this->dshape_eulerian(s, psif, dpsifdx);
  
       // Initialise all entries to zero
       dvorticity_dxdy.initialise(0.0);
  
       // Loop over nodes
       for (unsigned l = 0; l < n_node; l++)
       {
         // Loop over derivative directions to obtain xx and xy derivatives
         for (unsigned j = 0; j < 2; j++)
         {
           // Calculate xx and xy derivative
           dvorticity_dxdy[j] +=
             this->nodal_value(l, Smoothed_vorticity_index + 1) * dpsifdx(l, j);
         }
  
         // Calculate the yy derivative
         dvorticity_dxdy[2] +=
           this->nodal_value(l, Smoothed_vorticity_index + 2) * dpsifdx(l, 1);
       } // for (unsigned l=0;l<n_node;l++)
     } // End of get_raw_vorticity_second_deriv

References oomph::Vector< _Tp >::initialise(), j, s, and oomph::VorticitySmootherElement< ELEMENT >::Smoothed_vorticity_index.

◆ get_raw_vorticity_third_deriv() [1/2]

template<class ELEMENT >

void oomph::VorticitySmootherElement< ELEMENT >::get_raw_vorticity_third_deriv	(	const Vector< double > &	s,
		double &	dvorticity_dxdxdy,
		const unsigned &	index
	)		const

inline

Get raw derivative of smoothed derivative vorticity [0]: d^3/dx^3, [1]: d^3/dx^2dy, [2]: d^3/dxdy^2, [3]: d^3/dy^3,

     {
       // Find out how many nodes there are
       unsigned n_node = this->nnode();
  
       // Set up memory for the shape functions
       Shape psif(n_node);
  
       // Set up memory for the shape function derivatives
       DShape dpsifdx(n_node, 2);
  
       // Call the derivatives of the shape and test functions
       this->dshape_eulerian(s, psif, dpsifdx);
  
       // Initialise value to zero
       dvorticity_dxdxdy = 0.0;
  
       // Use a switch statement
       switch (index)
       {
         case 0:
           // Loop over the nodes
           for (unsigned l = 0; l < n_node; l++)
           {
             // d^3/dx^3 = d/dx \overline{d^2/dx^2}
             dvorticity_dxdxdy +=
               this->nodal_value(l, Smoothed_vorticity_index + 3) *
               dpsifdx(l, 0);
           }
           break;
         case 1:
           // Loop over the nodes
           for (unsigned l = 0; l < n_node; l++)
           {
             // d^3/dx^2dy = d/dx \overline{d^2/dxdy}
             dvorticity_dxdxdy +=
               this->nodal_value(l, Smoothed_vorticity_index + 4) *
               dpsifdx(l, 0);
           }
           break;
         case 2:
           // Loop over the nodes
           for (unsigned l = 0; l < n_node; l++)
           {
             // d^3/dxdy^2 = d/dy \overline{d^2/dxdy}
             dvorticity_dxdxdy +=
               this->nodal_value(l, Smoothed_vorticity_index + 4) *
               dpsifdx(l, 1);
           }
           break;
         case 3:
           // Loop over the nodes
           for (unsigned l = 0; l < n_node; l++)
           {
             // d^3/dy^3 = d/dy \overline{d^2/dy^2}
             dvorticity_dxdxdy +=
               this->nodal_value(l, Smoothed_vorticity_index + 5) *
               dpsifdx(l, 1);
           }
           break;
         default:
           oomph_info << "Never get here!" << std::endl;
           abort();
       }
     } // End of get_raw_vorticity_third_deriv

References oomph::oomph_info, s, and oomph::VorticitySmootherElement< ELEMENT >::Smoothed_vorticity_index.

◆ get_raw_vorticity_third_deriv() [2/2]

template<class ELEMENT >

void oomph::VorticitySmootherElement< ELEMENT >::get_raw_vorticity_third_deriv	(	const Vector< double > &	s,
		Vector< double > &	dvorticity_dxdxdy
	)		const

inline

Get raw derivative of smoothed derivative vorticity [0]: d^3/dx^3, [1]: d^3/dx^2dy, [2]: d^3/dxdy^2, [3]: d^3/dy^3

     {
       // Find out how many nodes there are
       unsigned n_node = this->nnode();
  
       // Set up memory for the shape functions
       Shape psif(n_node);
  
       // Set up memory for the shape function derivatives
       DShape dpsifdx(n_node, 2);
  
       // Call the derivatives of the shape and test functions
       this->dshape_eulerian(s, psif, dpsifdx);
  
       // Initialise all entries to zero
       dvorticity_dxdxdy.initialise(0.0);
  
       // Loop over the nodes
       for (unsigned l = 0; l < n_node; l++)
       {
         // d^3/dx^3 = d/dx \overline{d^2/dx^2}
         dvorticity_dxdxdy[0] +=
           this->nodal_value(l, Smoothed_vorticity_index + 3) * dpsifdx(l, 0);
  
         // d^3/dx^2dy = d/dx \overline{d^2/dxdy}
         dvorticity_dxdxdy[1] +=
           this->nodal_value(l, Smoothed_vorticity_index + 4) * dpsifdx(l, 0);
  
         // d^3/dxdy^2 = d/dy \overline{d^2/dxdy}
         dvorticity_dxdxdy[2] +=
           this->nodal_value(l, Smoothed_vorticity_index + 4) * dpsifdx(l, 1);
  
         // d^3/dy^3 = d/dy \overline{d^2/dy^2}
         dvorticity_dxdxdy[3] +=
           this->nodal_value(l, Smoothed_vorticity_index + 5) * dpsifdx(l, 1);
       }
     } // End of get_raw_vorticity_third_deriv

References oomph::Vector< _Tp >::initialise(), s, and oomph::VorticitySmootherElement< ELEMENT >::Smoothed_vorticity_index.

◆ ncont_interpolated_values()

template<class ELEMENT >

unsigned oomph::VorticitySmootherElement< ELEMENT >::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 oomph::VorticitySmootherElement< ELEMENT >::Number_of_values_per_field.

Referenced by oomph::VorticitySmootherElement< ELEMENT >::nscalar_paraview(), and oomph::VorticitySmootherElement< ELEMENT >::scalar_value_paraview().

◆ npartial_derivative()

template<class ELEMENT >

unsigned oomph::VorticitySmootherElement< ELEMENT >::npartial_derivative ( const unsigned & n ) const

inline

Call the function written in VorticityRecoveryHelpers.

     {
       // Return the result
       return VorticityRecoveryHelpers::Recovery_helper.npartial_derivative(n);
     } // End of npartial_derivative

References n, oomph::VorticityRecoveryHelpers::RecoveryHelper::npartial_derivative(), and oomph::VorticityRecoveryHelpers::Recovery_helper.

Referenced by oomph::VorticitySmootherElement< ELEMENT >::create_container_for_vorticity_and_derivatives(), oomph::VorticitySmootherElement< ELEMENT >::nvelocity_derivatives_to_recover(), oomph::VorticitySmootherElement< ELEMENT >::nvorticity_derivatives_to_recover(), oomph::VorticitySmootherElement< ELEMENT >::recovered_dof_to_container_id(), oomph::VorticitySmootherElement< ELEMENT >::stored_dof_to_recoverable_dof(), and oomph::VorticitySmootherElement< ELEMENT >::vorticity_dof_to_container_id().

◆ nscalar_paraview()

template<class ELEMENT >

unsigned oomph::VorticitySmootherElement< ELEMENT >::nscalar_paraview ( ) const

inline

Number of scalars/fields output by this element. Re-implements broken virtual function in base class.

     {
       // Return the number of continuously interpolated values
       return ncont_interpolated_values();
     } // End of nscalar_paraview

References oomph::VorticitySmootherElement< ELEMENT >::ncont_interpolated_values().

Referenced by oomph::VorticitySmootherElement< ELEMENT >::scalar_name_paraview(), and oomph::VorticitySmootherElement< ELEMENT >::scalar_value_paraview().

◆ nvelocity_derivatives_to_recover()

template<class ELEMENT >

unsigned oomph::VorticitySmootherElement< ELEMENT >::nvelocity_derivatives_to_recover ( ) const

inline

The number of derivatives calculated in the velocity recovery. This does NOT include the zeroth derivatives as they are not "recovered"

     {
       // The number of terms recovered
       unsigned n_terms = 0;
  
       // Loop over the derivatives
       for (unsigned i = 1;
            i < unsigned(Maximum_order_of_velocity_derivative + 1);
            i++)
       {
         // Update n_terms
         n_terms += 2 * npartial_derivative(i);
       }
  
       // Return the appropriate value
       return n_terms;
     } // End of nvelocity_derivatives_to_recover

References i, oomph::VorticitySmootherElement< ELEMENT >::Maximum_order_of_velocity_derivative, and oomph::VorticitySmootherElement< ELEMENT >::npartial_derivative().

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

◆ nvorticity_derivatives_to_recover()

template<class ELEMENT >

unsigned oomph::VorticitySmootherElement< ELEMENT >::nvorticity_derivatives_to_recover ( ) const

inline

The number of terms calculated in the vorticity recovery. Also includes the zeroth derivative, i.e. the vorticity itself

     {
       // The number of terms recovered
       unsigned n_terms = 0;
  
       // Loop over the derivatives
       for (unsigned i = 0;
            i < unsigned(Maximum_order_of_vorticity_derivative + 1);
            i++)
       {
         // Update n_terms
         n_terms += npartial_derivative(i);
       }
  
       // Return the appropriate value
       return n_terms;
     } // End of nvorticity_derivatives_to_recover

References i, oomph::VorticitySmootherElement< ELEMENT >::Maximum_order_of_vorticity_derivative, and oomph::VorticitySmootherElement< ELEMENT >::npartial_derivative().

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

◆ output()

template<class ELEMENT >

void oomph::VorticitySmootherElement< ELEMENT >::output	(	std::ostream &	outfile,
		const unsigned &	nplot
	)

inline

Overloaded output function: Output velocity, pressure and the smoothed vorticity

     {
       // Vector of local coordinates
       Vector<double> s(N_dim, 0.0);
  
       // Global coordinates container
       Vector<double> x(N_dim, 0.0);
  
       // Get the number of nodes in this element
       unsigned n_node = this->nnode();
  
       // Shape functions
       Shape psif(n_node);
  
       // Tecplot header info
       outfile << this->tecplot_zone_string(nplot);
  
       // Get the number of plot points
       unsigned num_plot_points = this->nplot_points(nplot);
  
       // Create a container for the vorticity and its derivatives
       Vector<Vector<double>> vort_and_derivs =
         create_container_for_vorticity_and_derivatives();
  
       // Loop over plot points
       for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
       {
         // Get local coordinates of plot point
         this->get_s_plot(iplot, nplot, s);
  
         // Get shape fct
         this->shape(s, psif);
  
         // Loop over the coordinates
         for (unsigned i = 0; i < N_dim; i++)
         {
           // Get the interpolated coordinate value at this local coordinate
           x[i] = this->interpolated_x(s, i);
  
           // Output the i-th coordinate value to file
           outfile << x[i] << " ";
         }
  
         // Loop over the coordinates
         for (unsigned i = 0; i < N_dim; i++)
         {
           // Output the i-th velocity component
           outfile << this->interpolated_u_nst(s, i) << " ";
         }
  
         // Pressure
         outfile << this->interpolated_p_nst(s) << " ";
  
         // Get vorticity and its derivatives (reconstructed)
         vorticity_and_its_derivs(s, vort_and_derivs);
  
         // Number of vectors
         unsigned n_vector = vort_and_derivs.size();
  
         // Loop over the number of vectors we're outputting from
         for (unsigned i = 0; i < n_vector; i++)
         {
           // The number of entries in the vector
           unsigned i_entries = vort_and_derivs[i].size();
  
           // Loop over the entries in the vector
           for (unsigned j = 0; j < i_entries; j++)
           {
             // Output the smoothed vorticity to file
             outfile << (vort_and_derivs[i])[j] << " ";
           }
         } // for (unsigned i=0;i<n_vector;i++)
  
         // Finish the line off
         outfile << std::endl;
       }
  
       // Write tecplot footer (e.g. FE connectivity lists)
       this->write_tecplot_zone_footer(outfile, nplot);
     } // End of output

References oomph::VorticitySmootherElement< ELEMENT >::create_container_for_vorticity_and_derivatives(), i, j, oomph::VorticitySmootherElement< ELEMENT >::N_dim, s, oomph::OneDimLagrange::shape(), oomph::VorticitySmootherElement< ELEMENT >::vorticity_and_its_derivs(), and plotDoE::x.

◆ output_analytical_veloc_and_vorticity()

template<class ELEMENT >

void oomph::VorticitySmootherElement< ELEMENT >::output_analytical_veloc_and_vorticity	(	std::ostream &	outfile,
		const unsigned &	nplot
	)

inline

Output exact velocity, vorticity, derivatives and indicator based on functions specified by two function pointers

     {
       // Vector of local coordinates
       Vector<double> s(N_dim, 0.0);
  
       // Global coordinates container
       Vector<double> x(N_dim);
  
       // Get the number of nodes in this element
       unsigned n_node = this->nnode();
  
       // Shape functions
       Shape psif(n_node);
  
       // Tecplot header info
       outfile << this->tecplot_zone_string(nplot);
  
       // Get the number of plot points
       unsigned num_plot_points = this->nplot_points(nplot);
  
       // Create a container for the vorticity and its derivatives
       Vector<Vector<double>> vort_and_derivs =
         create_container_for_vorticity_and_derivatives();
  
       // Loop over plot points
       for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
       {
         // Get local coordinates of plot point
         this->get_s_plot(iplot, nplot, s);
  
         // Loop over the coordinates
         for (unsigned i = 0; i < N_dim; i++)
         {
           // Get the interpolated coordinate value at this local coordinate
           x[i] = this->interpolated_x(s, i);
  
           // Output the i-th coordinate value to file
           outfile << x[i] << " ";
         }
  
         // Fake velocity and pressure
         outfile << "0.0 0.0 0.0 ";
  
         // Get the vorticity and its derivatives (and the derivatives of the
         // velocity if required)
         Exact_vorticity_fct_pt(x, vort_and_derivs);
  
         // Number of vectors
         unsigned n_vector = vort_and_derivs.size();
  
         // Loop over the number of vectors we're outputting from
         for (unsigned i = 0; i < n_vector; i++)
         {
           // The number of entries in the vector
           unsigned i_entries = vort_and_derivs[i].size();
  
           // Loop over the entries in the vector
           for (unsigned j = 0; j < i_entries; j++)
           {
             // Output the smoothed vorticity to file
             outfile << (vort_and_derivs[i])[j] << " ";
           }
         } // for (unsigned i=0;i<n_vector;i++)
  
         // Finish the line
         outfile << std::endl;
       } // for (unsigned iplot=0;iplot<num_plot_points;iplot++)
  
       // Write tecplot footer (e.g. FE connectivity lists)
       this->write_tecplot_zone_footer(outfile, nplot);
     } // End of output_analytical_veloc_and_vorticity

References oomph::VorticitySmootherElement< ELEMENT >::create_container_for_vorticity_and_derivatives(), oomph::VorticitySmootherElement< ELEMENT >::Exact_vorticity_fct_pt, i, j, oomph::VorticitySmootherElement< ELEMENT >::N_dim, s, and plotDoE::x.

◆ output_smoothed_vorticity()

template<class ELEMENT >

void oomph::VorticitySmootherElement< ELEMENT >::output_smoothed_vorticity	(	std::ostream &	outfile,
		const unsigned &	nplot
	)

inline

Output the velocity, smoothed vorticity and derivatives.

     {
       // Vector of local coordinates
       Vector<double> s(N_dim, 0.0);
  
       // Vector of global coordinates
       Vector<double> x(N_dim, 0.0);
  
       // Get the number of nodes in the element
       unsigned n_node = this->nnode();
  
       // Shape functions
       Shape psif(n_node);
  
       // Tecplot header info
       outfile << this->tecplot_zone_string(nplot);
  
       // Create a container for the vorticity and its derivatives
       Vector<Vector<double>> vort_and_derivs =
         create_container_for_vorticity_and_derivatives();
  
       // Vector of velocities
       Vector<double> velocity(N_dim, 0.0);
  
       // Get the number of plot points
       unsigned num_plot_points = this->nplot_points(nplot);
  
       // Loop over plot points
       for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
       {
         // Get local coordinates of plot point
         this->get_s_plot(iplot, nplot, s);
  
         // Get vorticity and its derivatives (reconstructed)
         vorticity_and_its_derivs(s, vort_and_derivs);
  
         // Loop over the coordinates
         for (unsigned i = 0; i < N_dim; i++)
         {
           // Get the i-th interpolated coordinate at a given local coordinate
           x[i] = this->interpolated_x(s, i);
  
           // Output the interpolated coordinate to file
           outfile << x[i] << " ";
         }
  
         // Loop over the coordinates
         for (unsigned i = 0; i < N_dim; i++)
         {
           // Output the i-th velocity component
           outfile << this->interpolated_u_nst(s, i) << " ";
         }
  
         // Pressure
         outfile << this->interpolated_p_nst(s) << " ";
  
         // Output the smoothed vorticity derivatives
         // (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):
  
         // Number of vectors
         unsigned n_vector = vort_and_derivs.size();
  
         // Loop over the number of vectors we're outputting from
         for (unsigned i = 0; i < n_vector; i++)
         {
           // The number of entries in the vector
           unsigned i_entries = vort_and_derivs[i].size();
  
           // Loop over the entries in the vector
           for (unsigned j = 0; j < i_entries; j++)
           {
             // Output the smoothed vorticity to file
             outfile << (vort_and_derivs[i])[j] << " ";
           }
         } // for (unsigned i=0;i<n_vector;i++)
  
         // End the line
         outfile << std::endl;
       } // for (unsigned iplot=0;iplot<num_plot_points;iplot++)
  
       // Write tecplot footer (e.g. FE connectivity lists)
       this->write_tecplot_zone_footer(outfile, nplot);
     } // End of output_smoothed_vorticity

References oomph::VorticitySmootherElement< ELEMENT >::create_container_for_vorticity_and_derivatives(), i, j, oomph::VorticitySmootherElement< ELEMENT >::N_dim, s, Jeffery_Solution::velocity(), oomph::VorticitySmootherElement< ELEMENT >::vorticity_and_its_derivs(), and plotDoE::x.

◆ pin_smoothed_vorticity()

template<class ELEMENT >

void oomph::VorticitySmootherElement< ELEMENT >::pin_smoothed_vorticity ( )

inline

Pin all smoothed vorticity quantities.

     {
       // Get the number of nodes in the element
       unsigned nnod = this->nnode();
  
       // Loop over the nodes
       for (unsigned j = 0; j < nnod; j++)
       {
         // Make a pointer to the j-th node in the element
         Node* nod_pt = this->node_pt(j);
  
         // Loop over the fields
         for (unsigned i = Smoothed_vorticity_index;
              i < Number_of_values_per_field;
              i++)
         {
           // Pin the i-th field at this node
           nod_pt->pin(i);
         }
       } // for (unsigned j=0;j<nnod;j++)
     } // End of pin_smoothed_vorticity

References i, j, oomph::VorticitySmootherElement< ELEMENT >::Number_of_values_per_field, oomph::Data::pin(), and oomph::VorticitySmootherElement< ELEMENT >::Smoothed_vorticity_index.

◆ recovered_dof_to_container_id()

template<class ELEMENT >

std::pair<unsigned, unsigned> oomph::VorticitySmootherElement< ELEMENT >::recovered_dof_to_container_id ( const unsigned & i ) const

inline

Helper function that, given the local dof number of the i-th vorticity or velocity derivative, returns the index in the container that stores the corresponding value. Note 1: this function goes hand-in-hand with create_container_for_vorticity_and_derivatives() Note 2: The input to this function is the i associated with the STORED nodal dof value. For example, if we're only recovering the velocity derivatives then i=0 is associated with du/dx

     {
       // Create a pair to store the output
       std::pair<unsigned, unsigned> container_id;
  
       // Find which derivative to calculate
       unsigned derivative_index = i;
  
       // Variable to store the index of the vector (initialise the value to -1
       // so we know whether or not the value has been set)
       int vector_index = -1;
  
       // Get the number of vorticity derivatives to recover
       unsigned n_vort_derivs = Maximum_order_of_vorticity_derivative;
  
       // Get the number of vorticity derivatives to recover
       unsigned n_veloc_derivs = Maximum_order_of_velocity_derivative;
  
       // Loop over the entries of the vector
       for (unsigned i = 0; i < n_vort_derivs + 1; i++)
       {
         // Get the number of partial derivatives of the vorticity
         if (derivative_index < npartial_derivative(i))
         {
           // We're on the i-th vector
           vector_index = i;
  
           // We're done
           break;
         }
         else
         {
           // Decrease the value of derivative_index
           derivative_index -= npartial_derivative(i);
         }
       } // for (unsigned i=0;i<n_vort_derivs+1;i++)
  
       // If the vector_index variable value hasn't been found yet
       if (vector_index == -1)
       {
         // Loop over the entries of the vector
         for (unsigned i = 1; i < n_veloc_derivs + 1; i++)
         {
           // Get the number of partial derivatives of the vorticity
           if (derivative_index < 2 * npartial_derivative(i))
           {
             // We're on the i-th vector
             vector_index = n_vort_derivs + i;
  
             // We're done
             break;
           }
           else
           {
             // Decrease the value of derivative_index
             derivative_index -= 2 * npartial_derivative(i);
           }
         } // for (unsigned i=1;i<n_veloc_derivs+1;i++)
       } // if (vector_index==-1)
  
 #ifdef PARANOID
       // Sanity check: if the value hasn't been set yet, something's wrong
       if (vector_index == -1)
       {
         // Create an ostringstream object to create an error message
         std::ostringstream error_message_stream;
  
         // Create an error message
         error_message_stream << "Value of vector_index has not been set. "
                              << "Something's wrong!";
  
         // Throw an error
         throw OomphLibError(error_message_stream.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       // Assign the first entry of container_id
       container_id.first = vector_index;
  
       // Assign the second entry of container_id
       container_id.second = derivative_index;
  
       // We'll never get here but need to return something
       return container_id;
     } // End of recovered_dof_to_container_id

References i, oomph::VorticitySmootherElement< ELEMENT >::Maximum_order_of_velocity_derivative, oomph::VorticitySmootherElement< ELEMENT >::Maximum_order_of_vorticity_derivative, oomph::VorticitySmootherElement< ELEMENT >::npartial_derivative(), OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by oomph::VorticitySmootherElement< ELEMENT >::scalar_value_paraview(), oomph::VorticitySmootherElement< ELEMENT >::stored_dof_to_recoverable_dof(), and oomph::VorticitySmootherElement< ELEMENT >::vorticity_error_squared().

◆ required_nvalue()

template<class ELEMENT >

unsigned oomph::VorticitySmootherElement< ELEMENT >::required_nvalue ( const unsigned & n ) const

inline

Number of values required at local node n. In order to simplify matters, we allocate storage for pressure variables at all the nodes and then pin those that are not used.

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

References oomph::VorticitySmootherElement< ELEMENT >::Number_of_values_per_field.

◆ scalar_name_paraview()

template<class ELEMENT >

std::string oomph::VorticitySmootherElement< ELEMENT >::scalar_name_paraview ( const unsigned & i ) const

inline

Name of the i-th scalar field. Default implementation returns V1 for the first one, V2 for the second etc. Can (should!) be overloaded with more meaningful names in specific elements.

     {
       // Velocities
       if (i < N_dim)
       {
         // Return the velocity name
         return "Velocity " + StringConversion::to_string(i);
       }
       // Pressure
       else if (i == N_dim)
       {
         // Return the appropriate string
         return "Pressure";
       }
       // Vorticity or its derivatives
       else if (i < nscalar_paraview())
       {
         // Calculate the appropriate value of index
         unsigned index =
           Smoothed_vorticity_index + stored_dof_to_recoverable_dof(i);
  
         // Switch statement is the easiest way to output smoothed vorticity
         // and velocity derivatives:
         // (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)
         switch (index)
         {
           case 3:
             return "w";
             break;
           case 4:
             return "dw/dx";
             break;
           case 5:
             return "dw/dy";
             break;
           case 6:
             return "d^2w/dx^2";
             break;
           case 7:
             return "d^2w/dxdy";
             break;
           case 8:
             return "d^2w/dy^2";
             break;
           case 9:
             return "d^3/dx^3";
             break;
           case 10:
             return "d^3/dx^2dy";
             break;
           case 11:
             return "d^3/dxdy^2";
             break;
           case 12:
             return "d^3/dy^3";
             break;
           case 13:
             return "du/dx";
             break;
           case 14:
             return "du/dy";
             break;
           case 15:
             return "dv/dx";
             break;
           case 16:
             return "dv/dy";
             break;
           default:
             oomph_info << "Never get here" << std::endl;
             abort();
             break;
         }
       }
       // Never get here
       else
       {
         std::stringstream error_stream;
         error_stream << "These Navier Stokes elements only store "
                      << nscalar_paraview() << " fields,\n"
                      << "but i is currently: " << i << std::endl;
  
         // Throw the error
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
         // Dummy return
         return " ";
       }
     } // End of scalar_name_paraview

References i, oomph::VorticitySmootherElement< ELEMENT >::N_dim, oomph::VorticitySmootherElement< ELEMENT >::nscalar_paraview(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, oomph::VorticitySmootherElement< ELEMENT >::Smoothed_vorticity_index, oomph::VorticitySmootherElement< ELEMENT >::stored_dof_to_recoverable_dof(), and oomph::StringConversion::to_string().

◆ scalar_value_paraview()

template<class ELEMENT >

void oomph::VorticitySmootherElement< ELEMENT >::scalar_value_paraview	(	std::ofstream &	file_out,
		const unsigned &	i,
		const unsigned &	nplot
	)		const

inline

Write values of the i-th scalar field at the plot points. Needs to be implemented for each new specific element type.

     {
       // Vector of local coordinates
       Vector<double> s(N_dim, 0.0);
  
       // Get the number of plot points
       unsigned num_plot_points = this->nplot_points_paraview(nplot);
  
       // Create a container for the vorticity and its derivatives
       Vector<Vector<double>> vort_and_derivs =
         create_container_for_vorticity_and_derivatives();
  
       // Loop over plot points
       for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
       {
         // Get local coordinates of plot point
         this->get_s_plot(iplot, nplot, s);
  
         // Velocities
         if (i < N_dim)
         {
           // Output the interpolated velocity component
           file_out << this->interpolated_u_nst(s, i) << std::endl;
         }
         // Pressure
         else if (i == N_dim)
         {
           // Output the interpolated pressure value
           file_out << this->interpolated_p_nst(s) << std::endl;
         }
         // Output the vorticity and required derivatives
         else if (i < nscalar_paraview())
         {
           // Get vorticity and its derivatives (reconstructed)
           vorticity_and_its_derivs(s, vort_and_derivs);
  
           // Get the ID in the storage associated with i-th recovered dof
           std::pair<unsigned, unsigned> id =
             recovered_dof_to_container_id(i - N_dim - 1);
  
           // Output the appropriate value
           file_out << (vort_and_derivs[id.first])[id.second] << std::endl;
         }
         // Never get here
         else
         {
 #ifdef PARANOID
           // Using a std::stringstream object to create a string
           std::stringstream error_stream;
  
           // Create the error message
           error_stream << "These VorticitySmoother elements only store "
                        << ncont_interpolated_values() << " fields, "
                        << "but i is currently: " << i << std::endl;
  
           // Throw an error
           throw OomphLibError(error_stream.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
 #endif
         }
       } // for (unsigned iplot=0;iplot<num_plot_points;iplot++)
     } // End of scalar_value_paraview

References oomph::VorticitySmootherElement< ELEMENT >::create_container_for_vorticity_and_derivatives(), i, oomph::VorticitySmootherElement< ELEMENT >::N_dim, oomph::VorticitySmootherElement< ELEMENT >::ncont_interpolated_values(), oomph::VorticitySmootherElement< ELEMENT >::nscalar_paraview(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::VorticitySmootherElement< ELEMENT >::recovered_dof_to_container_id(), s, and oomph::VorticitySmootherElement< ELEMENT >::vorticity_and_its_derivs().

◆ smoothed_vorticity_index()

template<class ELEMENT >

unsigned oomph::VorticitySmootherElement< ELEMENT >::smoothed_vorticity_index ( ) const

inline

Index of smoothed vorticity – followed by derivatives.

     {
       // Return the value of the Smoothed_vorticity_index
       return Smoothed_vorticity_index;
     } // End of smoothed_vorticity_index

References oomph::VorticitySmootherElement< ELEMENT >::Smoothed_vorticity_index.

◆ stored_dof_to_recoverable_dof()

template<class ELEMENT >

unsigned oomph::VorticitySmootherElement< ELEMENT >::stored_dof_to_recoverable_dof ( const unsigned & i ) const

inline

Given the STORED dof number, this function returns the global recovered number. For example, if we only want to recover the velocity derivatives then the stored dof number of du/dy is 1 (as 0 is associated with du/dx). The global recovered number is 11 (as there are currently 10 vorticity derivatives that can be recovered and du/dy is the second velocity derivative we can recover).

     {
       // Get the ID in the storage associated with i-th recovered dof
       std::pair<unsigned, unsigned> id =
         recovered_dof_to_container_id(i - N_dim - 1);
  
       // Vector entry index
       unsigned vector_index = id.first;
  
       // Derivative index
       unsigned deriv_index = id.second;
  
       // The index we want
       unsigned index = 0;
  
       // Maximum possible order of vorticity derivatives that can be recovered
       unsigned max_vort_recov =
         Maximum_order_of_recoverable_vorticity_derivatives;
  
       // If we're dealing with a vorticity derivative
       if (vector_index < max_vort_recov + 1)
       {
         // Holds the number of derivatives of lower order
         unsigned n_prev_deriv = 0;
  
         // Loop over the derivative orders
         for (unsigned j = 0; j < vector_index; j++)
         {
           // Increment n_prev_deriv
           n_prev_deriv += npartial_derivative(j);
         }
  
         // Update the value of index
         index += n_prev_deriv + deriv_index;
       }
       // We're dealing with derivatives of the velocity
       else
       {
         // Holds the number of vorticity derivatives
         unsigned n_prev_deriv = 0;
  
         // Loop over the derivative orders
         for (unsigned j = 0; j < max_vort_recov + 1; j++)
         {
           // Increment n_prev_deriv
           n_prev_deriv += npartial_derivative(j);
         }
  
         // What is the user-chosen maximum vorticity derivative to recover?
         unsigned n_vort_deriv = Maximum_order_of_vorticity_derivative;
  
         // Loop over the derivative orders
         for (unsigned j = 1; j < vector_index - n_vort_deriv; j++)
         {
           // Increment n_prev_deriv
           n_prev_deriv += 2 * npartial_derivative(j);
         }
  
         // Update the value of index
         index += n_prev_deriv + deriv_index;
       } // if (vector_index<max_vort_recov)
  
       // Return the value of index
       return index;
     } // End of stored_dof_to_recoverable_dof

References i, j, oomph::VorticitySmootherElement< ELEMENT >::Maximum_order_of_recoverable_vorticity_derivatives, oomph::VorticitySmootherElement< ELEMENT >::Maximum_order_of_vorticity_derivative, oomph::VorticitySmootherElement< ELEMENT >::N_dim, oomph::VorticitySmootherElement< ELEMENT >::npartial_derivative(), and oomph::VorticitySmootherElement< ELEMENT >::recovered_dof_to_container_id().

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

◆ vorticity_and_its_derivs()

template<class ELEMENT >

void oomph::VorticitySmootherElement< ELEMENT >::vorticity_and_its_derivs	(	const Vector< double > &	s,
		Vector< Vector< double >> &	vort_and_derivs
	)		const

inline

Compute smoothed vorticity and its derivatives.

     {
       // Get the number of nodes in this element
       unsigned n_node = this->nnode();
  
       // Shape functions
       Shape psif(n_node);
  
       // Get the shape function value at the given local coordinate
       this->shape(s, psif);
  
       // Find out how much information we need to calculate
       unsigned n_vector = vort_and_derivs.size();
  
       // Initialise a counter (holds the dof number)
       unsigned i_dof = 0;
  
       // Loop over the vectors
       for (unsigned i = 0; i < n_vector; i++)
       {
         // Initialise entries to zero
         vort_and_derivs[i].initialise(0.0);
  
         // Find out how many entries there are in the i-th vector
         unsigned num_entries = vort_and_derivs[i].size();
  
         // Loop over the entries
         for (unsigned j = 0; j < num_entries; j++)
         {
           // Loop over the nodes
           for (unsigned l = 0; l < n_node; l++)
           {
             // Get the contribution to the smoothed derivative from the l-th
             // node
             (vort_and_derivs[i])[j] +=
               this->nodal_value(l, Smoothed_vorticity_index + i_dof) * psif[l];
           }
  
           // Increment the counter
           i_dof++;
         } // for (unsigned j=0;j<num_entries;j++)
       } // for (unsigned i=0;i<n_vector;i++)
     } // End of vorticity_and_its_derivs

References i, j, oomph::OneDimLagrange::shape(), and oomph::VorticitySmootherElement< ELEMENT >::Smoothed_vorticity_index.

Referenced by oomph::VorticitySmootherElement< ELEMENT >::output(), oomph::VorticitySmootherElement< ELEMENT >::output_smoothed_vorticity(), and oomph::VorticitySmootherElement< ELEMENT >::scalar_value_paraview().

◆ vorticity_dof_to_container_id()

template<class ELEMENT >

std::pair<unsigned, unsigned> oomph::VorticitySmootherElement< ELEMENT >::vorticity_dof_to_container_id ( const unsigned & i ) const

inline

Helper function that, given the local dof number of the i-th vorticity or velocity derivative, returns the index in the container that stores the corresponding value. Note 1: this function goes hand-in-hand with create_container_for_vorticity_and_derivatives() Note 2: i=0: vorticity itself; i>0: vorticity derivatives

     {
       // Maximum number of vorticity derivatives (that we actually want)
       unsigned n_vort_deriv = Maximum_order_of_vorticity_derivative;
  
       // Maximum number of velocity derivatives (that we actually want)
       unsigned n_veloc_deriv = Maximum_order_of_velocity_derivative;
  
 #ifdef PARANOID
       // We cannot calculate this if we're not recovering anything
       if (n_vort_deriv + n_veloc_deriv + 1 == 0)
       {
         // Throw an error
         throw OomphLibError(
           "Not recovering anything so this shouldn't be called.",
           OOMPH_CURRENT_FUNCTION,
           OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       // Maximum order of vorticity derivative (that can be recovered)
       unsigned max_vort_order =
         Maximum_order_of_recoverable_vorticity_derivatives;
  
       // Maximum order of velocity derivative (that can be recovered)
       unsigned max_veloc_order =
         Maximum_order_of_recoverable_velocity_derivatives;
  
       // Maximum number of recoverable vorticity terms
       unsigned max_vort_recov = 0;
  
       // Maximum number of recoverable velocity terms
       unsigned max_veloc_recov = 0;
  
       // Loop over the entries of the vector
       for (unsigned j = 0; j < max_vort_order + 1; j++)
       {
         // Get the number of partial derivatives of the vorticity
         max_vort_recov += npartial_derivative(j);
       }
  
       // Loop over the entries of the vector
       for (unsigned j = 1; j < max_veloc_order + 1; j++)
       {
         // Get the number of partial derivatives of the vorticity
         max_veloc_recov += 2 * npartial_derivative(j);
       }
  
       // Create a pair to store the output
       std::pair<unsigned, unsigned> container_id;
  
       // Store the number of derivatives we've gone over
       unsigned nprev_deriv = 0;
  
       // The number of derivatives available of a given order
       unsigned n_deriv = 0;
  
       // If the dof number i is associated with a vorticity derivative
       if (i < max_vort_recov)
       {
         // Loop over the vorticity vectors
         for (unsigned jj = 0; jj < n_vort_deriv + 1; jj++)
         {
           // Number of derivatives of order jj
           n_deriv = npartial_derivative(jj);
  
           // Update nprev_derivs
           nprev_deriv += n_deriv;
  
           // If this is true then we need the jj-th vector
           if (i < nprev_deriv)
           {
             // Assign the first index
             container_id.first = jj;
  
             // Index of the entry
             container_id.second = i - (nprev_deriv - n_deriv);
  
             // We're done
             return container_id;
           }
         } // for (unsigned jj=0;jj<n_vort_deriv+1;jj++)
       }
       // If the dof number i is associated with a velocity derivative
       else if (i < max_vort_recov + max_veloc_recov)
       {
         // Initialise the value of nprev_deriv (depending on how many
         // vorticity derivatives we can recover)
         nprev_deriv = max_vort_recov;
  
         // Loop over the velocity vectors
         for (unsigned jj = n_vort_deriv + 1;
              jj < n_vort_deriv + n_veloc_deriv + 1;
              jj++)
         {
           // Number of velocity derivatives
           n_deriv = 2 * npartial_derivative(jj - n_vort_deriv);
  
           // Update nprev_derivs
           nprev_deriv += n_deriv;
  
           // If this is true then we need the jj-th vector
           if (i < nprev_deriv)
           {
             // Assign the first index
             container_id.first = jj;
  
             // Index of the entry
             container_id.second = i - (nprev_deriv - n_deriv);
  
             // We're done
             return container_id;
           }
         } // for (unsigned jj=n_vort_deriv+1;jj<n_veloc_deriv;jj++)
       }
       else
       {
         // Create an ostringstream object to create an error message
         std::ostringstream error_message_stream;
  
         // Create an error message
         error_message_stream << "Dof number " << i << " not associated "
                              << "with a vorticity or velocity derivative!"
                              << std::endl;
  
         // Throw an error
         throw OomphLibError(error_message_stream.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       } // if (i<max_vort_recov)
  
       // We'll never get here but need to return something
       return container_id;
     } // End of vorticity_dof_to_container_id

References i, j, oomph::VorticitySmootherElement< ELEMENT >::Maximum_order_of_recoverable_velocity_derivatives, oomph::VorticitySmootherElement< ELEMENT >::Maximum_order_of_recoverable_vorticity_derivatives, oomph::VorticitySmootherElement< ELEMENT >::Maximum_order_of_velocity_derivative, oomph::VorticitySmootherElement< ELEMENT >::Maximum_order_of_vorticity_derivative, oomph::VorticitySmootherElement< ELEMENT >::npartial_derivative(), OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ vorticity_error_squared()

template<class ELEMENT >

double oomph::VorticitySmootherElement< ELEMENT >::vorticity_error_squared ( const unsigned & i )

inline

Compute the element's contribution to the (squared) L2 norm of the difference between exact and smoothed vorticity. The input i corresponds to the i-th dof stored at each node (excluding the velocities and pressure).

     {
 #ifdef PARANOID
       // Number of derivatives to be recovered
       unsigned n_recovered_derivs = (nvorticity_derivatives_to_recover() +
                                      nvelocity_derivatives_to_recover());
  
       // We cannot calculate this if we're not recovering the data
       if ((n_recovered_derivs == 0) || (i >= n_recovered_derivs))
       {
         // Throw an error
         throw OomphLibError("Can't calculate this; not recovering enough data.",
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       // Create a container for the synthetic quantities
       Vector<Vector<double>> synth_vort_and_derivs =
         create_container_for_vorticity_and_derivatives();
  
       // Get the appropriate indices associated with the i-th recovered dof
       std::pair<unsigned, unsigned> indices = recovered_dof_to_container_id(i);
  
       // Find out how much information we need to calculate
       unsigned n_vector = synth_vort_and_derivs.size();
  
       // Initialise the norm squared value
       double norm_squared = 0.0;
  
       // Find out how many nodes there are in the element
       unsigned n_node = this->nnode();
  
       // Set up memory for the shape functions
       Shape psif(n_node);
  
       // Set up memory for the shape function derivatives
       DShape dpsifdx(n_node, 2);
  
       // Number of integration points
       unsigned n_intpt = this->integral_pt()->nweight();
  
       // Create the vector to hold local coordinates
       Vector<double> s(N_dim, 0.0);
  
       // Create the vector to hold the global coordinates
       Vector<double> x(N_dim, 0.0);
  
       // Loop over the integration points
       for (unsigned ipt = 0; ipt < n_intpt; ipt++)
       {
         // Loop over the coordinates
         for (unsigned ii = 0; ii < N_dim; ii++)
         {
           // Get the local coordinate value
           s[ii] = this->integral_pt()->knot(ipt, ii);
         }
  
         // Calculate the corresponding global coordinate
         this->interpolated_x(s, x);
  
         // Get the integral weight
         double w = this->integral_pt()->weight(ipt);
  
         // Call the derivatives of the shape and test functions
         double J = this->dshape_eulerian(s, psif, dpsifdx);
  
         // Pre-multiply the weights and the Jacobian
         double W = w * J;
  
         // Initialise the smoothed vorticity value
         double smoothed_vort = 0.0;
  
         // Smoothed vorticity
         for (unsigned l = 0; l < n_node; l++)
         {
           // Update the smoothed vorticity value
           smoothed_vort +=
             this->nodal_value(l, Smoothed_vorticity_index + i) * psif[l];
         }
  
         // Initialise the entries of the storage for the vorticity and
         // derivatives
         for (unsigned jj = 0; jj < n_vector; jj++)
         {
           // Initialise the entries to zero
           synth_vort_and_derivs[jj].initialise(0.0);
         }
  
         // If pointer isn't null
         if (0 != Exact_vorticity_fct_pt)
         {
           // Use the function pointer to calculate the appropriate quantities
           Exact_vorticity_fct_pt(x, synth_vort_and_derivs);
         }
  
         // Initialise the synthetic quantity
         double synth_quantity = 0.0;
  
         // Calculate the synthetic quantity
         synth_quantity = (synth_vort_and_derivs[indices.first])[indices.second];
  
         // Add the squared difference
         norm_squared += pow(smoothed_vort - synth_quantity, 2) * W;
       } // for (unsigned ipt=0;ipt<n_intpt;ipt++)
  
       // Return the norm squared value
       return norm_squared;
     } // End of vorticity_error_squared

◆ Number_of_values_per_field

template<class ELEMENT >

unsigned oomph::VorticitySmootherElement< ELEMENT >::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 oomph::VorticitySmootherElement< ELEMENT >::get_interpolated_values(), oomph::VorticitySmootherElement< ELEMENT >::ncont_interpolated_values(), oomph::VorticitySmootherElement< ELEMENT >::pin_smoothed_vorticity(), oomph::VorticitySmootherElement< ELEMENT >::required_nvalue(), and oomph::VorticitySmootherElement< ELEMENT >::VorticitySmootherElement().

◆ Smoothed_vorticity_index

template<class ELEMENT >

unsigned oomph::VorticitySmootherElement< ELEMENT >::Smoothed_vorticity_index

private

Index of smoothed vorticity – followed by derivatives; in 2D this has value 3

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

vorticity_smoother.h

Public Types

Public Member Functions

Private Attributes

Detailed Description

template<class ELEMENT> class oomph::VorticitySmootherElement< ELEMENT >

Member Typedef Documentation

◆ ExactVorticityFctPt

Constructor & Destructor Documentation

◆ VorticitySmootherElement()

Member Function Documentation

◆ create_container_for_vorticity_and_derivatives()

◆ exact_vorticity_fct_pt() [1/2]

◆ exact_vorticity_fct_pt() [2/2]

◆ get_interpolated_values() [1/2]

◆ get_interpolated_values() [2/2]

◆ get_maximum_order_of_recoverable_velocity_derivative()

◆ get_maximum_order_of_recoverable_vorticity_derivative()

◆ get_maximum_order_of_velocity_derivative()

◆ get_maximum_order_of_vorticity_derivative()

◆ get_raw_velocity_deriv() [1/2]

◆ get_raw_velocity_deriv() [2/2]

◆ get_raw_vorticity_deriv() [1/2]

◆ get_raw_vorticity_deriv() [2/2]

◆ get_raw_vorticity_second_deriv() [1/2]

◆ get_raw_vorticity_second_deriv() [2/2]

◆ get_raw_vorticity_third_deriv() [1/2]

◆ get_raw_vorticity_third_deriv() [2/2]

◆ ncont_interpolated_values()

◆ npartial_derivative()

◆ nscalar_paraview()

◆ nvelocity_derivatives_to_recover()

◆ nvorticity_derivatives_to_recover()

◆ output()

◆ output_analytical_veloc_and_vorticity()

◆ output_smoothed_vorticity()

◆ pin_smoothed_vorticity()

◆ recovered_dof_to_container_id()

◆ required_nvalue()

◆ scalar_name_paraview()

◆ scalar_value_paraview()

◆ smoothed_vorticity_index()

◆ stored_dof_to_recoverable_dof()

◆ vorticity_and_its_derivs()

◆ vorticity_dof_to_container_id()

◆ vorticity_error_squared()

Member Data Documentation

◆ Exact_vorticity_fct_pt

◆ Maximum_order_of_recoverable_velocity_derivatives

◆ Maximum_order_of_recoverable_vorticity_derivatives

◆ Maximum_order_of_velocity_derivative

◆ Maximum_order_of_vorticity_derivative

◆ N_dim

◆ Number_of_values_per_field

◆ Smoothed_vorticity_index

template<class ELEMENT>
class oomph::VorticitySmootherElement< ELEMENT >