#include <poisson_elements_with_singularity.h>

Inheritance diagram for SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >:

Public Types
typedef double(*	PoissonSingularFctPt) (const Vector< double > &x)
	Function pointer to the singular function: More...

typedef Vector< double >(*	PoissonGradSingularFctPt) (const Vector< double > &x)
	Function pointer to the gradient of the singular function: More...

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

bool &	singular_function_satisfies_laplace_equation ()

double	c () const
	Find the value of the unknown C. More...

void	set_wrapped_poisson_element_pt (WRAPPED_POISSON_ELEMENT wrapped_poisson_el_pt, const Vector< double > &s, unsigned direction_pt)

PoissonSingularFctPt &	singular_fct_pt ()
	Access function to pointer to singular function. More...

double	singular_function (const Vector< double > &x) const
	Evaluate singular function at Eulerian position x. More...

double	u_bar (const Vector< double > &x)

PoissonGradSingularFctPt &	grad_singular_fct_pt ()
	Access function to pointer to the gradient of sing function. More...

Vector< double >	grad_singular_function (const Vector< double > &x) const
	Evaluate the gradient of the sing function at Eulerian position x. More...

Vector< double >	grad_u_bar (const Vector< double > &x)
	Gradient of ubar (including the constant!) More...

void	fill_in_contribution_to_residuals (Vector< double > &residual)

void	fill_in_contribution_to_jacobian (Vector< double > &residual, DenseMatrix< double > &jacobian)

Private Member Functions
void	fill_in_generic_contribution_to_residuals (Vector< double > &residual, DenseMatrix< double > &jacobian, const unsigned &flag)
	Compute local residual, and, if flag=1, local jacobian matrix. More...

Private Attributes
WRAPPED_POISSON_ELEMENT *	Wrapped_poisson_el_pt
	Pointer to Poisson element that contains the singularity. More...

PoissonSingularFctPt	Singular_fct_pt
	Pointer to singular function. More...

PoissonGradSingularFctPt	Grad_singular_fct_pt
	Pointer to the gradient of the singular function. More...

Vector< double >	S_in_wrapped_poisson_element
	Local coordinates of singularity in the wrapped Poisson element. More...

unsigned *	Direction_pt
	Direction of the derivative used for the residual of the element. More...

bool	Singular_function_satisfies_laplace_equation
	Does singular fct satisfy Laplace's eqn? More...

Detailed Description

template<class WRAPPED_POISSON_ELEMENT>
class SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >

//////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// We consider a singularity in the solution at the point O.

This class defines the functions u_sing and u_bar = C*u_sing and their gradients.

The class also defines the function that computes the residual associated with C. R_C = \frac{\partial u_FE}{\partial x_d}(O) where u_FE is : \sum_{i} U_i \Psi_i. This sets the derivative of the finite-element part of the solution to zero in the specified direction (d) and thus imposes regularity on that part.

Member Typedef Documentation

◆ PoissonGradSingularFctPt

template<class WRAPPED_POISSON_ELEMENT >

typedef Vector<double>(* SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::PoissonGradSingularFctPt) (const Vector< double > &x)

Function pointer to the gradient of the singular function:

◆ PoissonSingularFctPt

template<class WRAPPED_POISSON_ELEMENT >

typedef double(* SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::PoissonSingularFctPt) (const Vector< double > &x)

Function pointer to the singular function:

Constructor & Destructor Documentation

◆ SingularPoissonSolutionElement()

template<class WRAPPED_POISSON_ELEMENT >

SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::SingularPoissonSolutionElement ( )

inline

Constructor.

   {
    // Initialise Function pointer to singular function 
    Singular_fct_pt=0;
    
    // Initialise Function pointer to gradient of the singular function
    Grad_singular_fct_pt=0;
    
    // Initalise pointer to the wrapped Poisson element which will be used to
    // compute the residual and which includes the point O
    Wrapped_poisson_el_pt=0;
  
    // Initialise the pointer to the direction of the derivative used
    // for the residual of this element
    Direction_pt=0;
    
    // Create a single item of internal Data, storing one unknown which
    // represents the unknown C.
    add_internal_data(new Data(1));
    
    // Safe assumption: Singular fct does not satisfy Laplace's eqn
    Singular_function_satisfies_laplace_equation=false;
  
   } // End of constructor

References SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::Direction_pt, SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::Grad_singular_fct_pt, SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::Singular_fct_pt, SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::Singular_function_satisfies_laplace_equation, and SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::Wrapped_poisson_el_pt.

Member Function Documentation

◆ c()

template<class WRAPPED_POISSON_ELEMENT >

double SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::c ( ) const

inline

Find the value of the unknown C.

  {
   return internal_data_pt(0)->value(0);
  }

Referenced by SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::grad_u_bar(), and SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::u_bar().

◆ fill_in_contribution_to_jacobian()

template<class WRAPPED_POISSON_ELEMENT >

void SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::fill_in_contribution_to_jacobian	(	Vector< double > &	residual,
		DenseMatrix< double > &	jacobian
	)

inline

  {
   fill_in_generic_contribution_to_residuals(residual,jacobian,1);
  }

References SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::fill_in_generic_contribution_to_residuals().

◆ fill_in_contribution_to_residuals()

template<class WRAPPED_POISSON_ELEMENT >

void SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::fill_in_contribution_to_residuals ( Vector< double > & residual )

inline

  {
   fill_in_generic_contribution_to_residuals
    (residual,GeneralisedElement::Dummy_matrix,0);
  }

References SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::fill_in_generic_contribution_to_residuals().

◆ fill_in_generic_contribution_to_residuals()

template<class WRAPPED_POISSON_ELEMENT >

void SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::fill_in_generic_contribution_to_residuals	(	Vector< double > &	residual,
		DenseMatrix< double > &	jacobian,
		const unsigned &	flag
	)

inlineprivate

Compute local residual, and, if flag=1, local jacobian matrix.

  {
   // Get the local eqn number of our one-and-only
   // unknown
   int eqn_number=internal_local_eqn(0,0);
   
   // Get the derivative
   unsigned cached_dim=Wrapped_poisson_el_pt->dim();
   Vector<double> flux(cached_dim);
   Wrapped_poisson_el_pt->get_flux(S_in_wrapped_poisson_element,flux);
   double derivative = flux[*Direction_pt];
   
   // fill in the contribution to the residual
   residual[eqn_number] = derivative;
   
   if (flag)
    {
     // Find the number of nodes in the Poisson element associated to the
     // SingularPoissonSolutionElement class
     unsigned n_node = Wrapped_poisson_el_pt->nnode();
     
     // Compute the derivatives of the shape functions of the poisson
     // element associated to the SingularPoissonSolutionElement at the 
     // local coordinate S_in_wrapped_poisson_element_pt
     Shape psi(n_node);
     DShape dpsidx(n_node,cached_dim);
     Wrapped_poisson_el_pt->dshape_eulerian(
      S_in_wrapped_poisson_element,psi,dpsidx);
     
     // Loop over the nodes
     for (unsigned j=0;j<n_node;j++)
      {
       // Find the local equation number of the node
       int node_eqn_number = external_local_eqn(j,0);
       if (node_eqn_number>=0)
        {
        // Add the contribution of the node to the local jacobian
        jacobian(eqn_number,node_eqn_number) = dpsidx(j,*Direction_pt);
        }
  
      }
    }
   
  }

References SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::Direction_pt, ProblemParameters::flux(), j, SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::S_in_wrapped_poisson_element, and SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::Wrapped_poisson_el_pt.

Referenced by SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::fill_in_contribution_to_jacobian(), and SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::fill_in_contribution_to_residuals().

◆ grad_singular_fct_pt()

template<class WRAPPED_POISSON_ELEMENT >

PoissonGradSingularFctPt& SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::grad_singular_fct_pt ( )

inline

Access function to pointer to the gradient of sing function.

172 {return Grad_singular_fct_pt;}

References SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::Grad_singular_fct_pt.

◆ grad_singular_function()

template<class WRAPPED_POISSON_ELEMENT >

Vector<double> SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::grad_singular_function ( const Vector< double > & x ) const

inline

Evaluate the gradient of the sing function at Eulerian position x.

   {
    // Find the dimension of the problem
    unsigned cached_dim=Wrapped_poisson_el_pt->dim();
    
    // Declare the gradient of sing
    Vector<double> dsingular(cached_dim);
    
 #ifdef PARANOID
    if (Grad_singular_fct_pt==0)
     {
      std::stringstream error_stream;
      error_stream 
       << "Pointer to gradient of singular function hasn't been defined!"
       << std::endl;
      throw OomphLibError(
       error_stream.str(),
       OOMPH_CURRENT_FUNCTION,
       OOMPH_EXCEPTION_LOCATION);
     }
 #endif
    
    // Evaluate gradient of the sing function
    return (*Grad_singular_fct_pt)(x);
   }

References SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::Grad_singular_fct_pt, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::Wrapped_poisson_el_pt, and plotDoE::x.

Referenced by SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::grad_u_bar().

◆ grad_u_bar()

template<class WRAPPED_POISSON_ELEMENT >

Vector<double> SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::grad_u_bar ( const Vector< double > & x )

inline

Gradient of ubar (including the constant!)

   {
    // Compute the gradient of sing
    Vector<double> dsingular = grad_singular_function(x);
    
    // Initialise the gradient of ubar
    unsigned cached_dim=Wrapped_poisson_el_pt->dim();
    Vector<double> dubar(cached_dim);
    
    // Find the value of C
    double c=internal_data_pt(0)->value(0);
    for (unsigned i=0;i<cached_dim;i++)
     {
      dubar[i] = c*dsingular[i];
     }
    
    return dubar;
   } // End of function

References SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::c(), SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::grad_singular_function(), i, SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::Wrapped_poisson_el_pt, and plotDoE::x.

◆ set_wrapped_poisson_element_pt()

template<class WRAPPED_POISSON_ELEMENT >

void SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::set_wrapped_poisson_element_pt	(	WRAPPED_POISSON_ELEMENT *	wrapped_poisson_el_pt,
		const Vector< double > &	s,
		unsigned *	direction_pt
	)

inline

Set pointer to associated wrapped Poisson element which contains the singularity (at local coordinate s). Also specify the direction in which the slope of the FE part of the solution is set to zero

  {
   // Assign the pointer to the variable Wrapped_poisson_el_pt
   Wrapped_poisson_el_pt = wrapped_poisson_el_pt;
   
   // Find number of nodes in the element
   unsigned nnod=wrapped_poisson_el_pt->nnode();
   
   // Loop over the nodes of the element
   for (unsigned j=0;j<nnod;j++)
    {
     // Add the node as external data in the SingularPoissonSolutionElement class
     // because they affect the slope that we set to zero to
     // determine the value of the amplitude C
     add_external_data(Wrapped_poisson_el_pt->node_pt(j));
    }
   
   // Assign the pointer to the local coordinate at which the residual
   // will be computed
   S_in_wrapped_poisson_element = s;
   
   // Assign the pointer to the direction at which the derivative used
   // in the residual will be computed
   Direction_pt = direction_pt;
  }

References SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::Direction_pt, j, s, SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::S_in_wrapped_poisson_element, and SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::Wrapped_poisson_el_pt.

◆ singular_fct_pt()

template<class WRAPPED_POISSON_ELEMENT >

PoissonSingularFctPt& SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::singular_fct_pt ( )

inline

Access function to pointer to singular function.

136 {return Singular_fct_pt;}

References SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::Singular_fct_pt.

◆ singular_function()

template<class WRAPPED_POISSON_ELEMENT >

double SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::singular_function ( const Vector< double > & x ) const

inline

Evaluate singular function at Eulerian position x.

  {
 #ifdef PARANOID
   if (Singular_fct_pt==0)
    {
     std::stringstream error_stream;
     error_stream 
      << "Pointer to singular function hasn't been defined!"
      << std::endl;
     throw OomphLibError(
      error_stream.str(),
      OOMPH_CURRENT_FUNCTION,
      OOMPH_EXCEPTION_LOCATION);
    }
 #endif
   
   // Evaluate singular function
   return (*Singular_fct_pt)(x);
  }

References OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::Singular_fct_pt, and plotDoE::x.

Referenced by SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::u_bar().

◆ singular_function_satisfies_laplace_equation()

template<class WRAPPED_POISSON_ELEMENT >

bool& SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::singular_function_satisfies_laplace_equation ( )

inline

Does the singular fct satisfy Laplace's eqn? Default assumption is that it doesn't; user can overwrite this here to avoid unnecessary computation of integrals in residual

   {
    return Singular_function_satisfies_laplace_equation;
   }

References SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::Singular_function_satisfies_laplace_equation.

◆ u_bar()

template<class WRAPPED_POISSON_ELEMENT >

double SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::u_bar ( const Vector< double > & x )

inline

The singular function (including its amplitude): ubar = C * sing where sing is defined via the function pointer.

  {
   // Find the value of C
   double c=internal_data_pt(0)->value(0);
   
   // Value of ubar at the position x
   return c*singular_function(x);
  } // End of function

References SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::c(), SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::singular_function(), and plotDoE::x.

Member Data Documentation

◆ Direction_pt

template<class WRAPPED_POISSON_ELEMENT >

unsigned* SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::Direction_pt

private

Direction of the derivative used for the residual of the element.

Referenced by SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::fill_in_generic_contribution_to_residuals(), SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::set_wrapped_poisson_element_pt(), and SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::SingularPoissonSolutionElement().

◆ Grad_singular_fct_pt

template<class WRAPPED_POISSON_ELEMENT >

PoissonGradSingularFctPt SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::Grad_singular_fct_pt

private

Pointer to the gradient of the singular function.

Referenced by SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::grad_singular_fct_pt(), SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::grad_singular_function(), and SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::SingularPoissonSolutionElement().

◆ S_in_wrapped_poisson_element

template<class WRAPPED_POISSON_ELEMENT >

Vector<double> SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::S_in_wrapped_poisson_element

private

Local coordinates of singularity in the wrapped Poisson element.

Referenced by SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::fill_in_generic_contribution_to_residuals(), and SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::set_wrapped_poisson_element_pt().

◆ Singular_fct_pt

template<class WRAPPED_POISSON_ELEMENT >

PoissonSingularFctPt SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::Singular_fct_pt

private

Pointer to singular function.

Referenced by SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::singular_fct_pt(), SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::singular_function(), and SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::SingularPoissonSolutionElement().

◆ Singular_function_satisfies_laplace_equation

template<class WRAPPED_POISSON_ELEMENT >

bool SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::Singular_function_satisfies_laplace_equation

private

Does singular fct satisfy Laplace's eqn?

Referenced by SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::singular_function_satisfies_laplace_equation(), and SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::SingularPoissonSolutionElement().

◆ Wrapped_poisson_el_pt

template<class WRAPPED_POISSON_ELEMENT >

WRAPPED_POISSON_ELEMENT* SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::Wrapped_poisson_el_pt

private

Pointer to Poisson element that contains the singularity.

Referenced by SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::fill_in_generic_contribution_to_residuals(), SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::grad_singular_function(), SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::grad_u_bar(), SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::set_wrapped_poisson_element_pt(), and SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >::SingularPoissonSolutionElement().

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

poisson_elements_with_singularity.h

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

template<class WRAPPED_POISSON_ELEMENT> class SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >

Member Typedef Documentation

◆ PoissonGradSingularFctPt

◆ PoissonSingularFctPt

Constructor & Destructor Documentation

◆ SingularPoissonSolutionElement()

Member Function Documentation

◆ c()

◆ fill_in_contribution_to_jacobian()

◆ fill_in_contribution_to_residuals()

◆ fill_in_generic_contribution_to_residuals()

◆ grad_singular_fct_pt()

◆ grad_singular_function()

◆ grad_u_bar()

◆ set_wrapped_poisson_element_pt()

◆ singular_fct_pt()

◆ singular_function()

◆ singular_function_satisfies_laplace_equation()

◆ u_bar()

Member Data Documentation

◆ Direction_pt

◆ Grad_singular_fct_pt

◆ S_in_wrapped_poisson_element

◆ Singular_fct_pt

◆ Singular_function_satisfies_laplace_equation

◆ Wrapped_poisson_el_pt

template<class WRAPPED_POISSON_ELEMENT>
class SingularPoissonSolutionElement< WRAPPED_POISSON_ELEMENT >