PoissonElementWithSingularity< BASIC_POISSON_ELEMENT > Class Template Reference

#include <poisson_elements_with_singularity.h>

Inheritance diagram for PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >:

Public Member Functions
	PoissonElementWithSingularity ()
	Constructor. More...
void	impose_dirichlet_bc_on_node (const unsigned &j)
void	undo_dirichlet_bc_on_node (const unsigned &j)
	Undo Dirichlet BCs on jth node. More...
void	undo_dirichlet_bc_on_all_nodes ()
	Undo Dirichlet BCs on all nodes. More...
void	set_dirichlet_value_on_node (const unsigned &j, const double &value)
	Specify Dirichlet boundary value for j-th local node. More...
Vector< SingularPoissonSolutionElement< PoissonElementWithSingularity< BASIC_POISSON_ELEMENT > > * >	c_equation_elements_pt ()
void	add_c_equation_element_pt (SingularPoissonSolutionElement< PoissonElementWithSingularity< BASIC_POISSON_ELEMENT > > *c_pt)
double	u_bar (const unsigned &i, const Vector< double > &x) const
double	singular_function (const unsigned &i, const Vector< double > &x) const
	Evaluate i-th "raw" singular function at Eulerian position x. More...
Vector< double >	grad_u_bar (const unsigned i, const Vector< double > &x) const
Vector< double >	grad_singular_function (const unsigned &i, const Vector< double > &x) const
	Evaluate the gradient of the i-th "raw" singular at Eulerian position x. More...
double	interpolated_u_poisson_fe_only (const Vector< double > &s) const
double	interpolated_u_poisson (const Vector< double > &s) const
	Overloaded version including the singular contributions. More...
void	fill_in_contribution_to_residuals (Vector< double > &residuals)
	Add the element's contribution to its residual vector (wrapper) More...
void	fill_in_contribution_to_jacobian (Vector< double > &residuals, DenseMatrix< double > &jacobian)
void	output (std::ostream &outfile, const unsigned &nplot)
	Overloaded output fct: x, y [,z], u, u_fe_only, u-u_fe_only. More...
void	compute_error (std::ostream &outfile, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, double &error, double &norm)
	Compute error. More...

Private Member Functions
void	fill_in_generic_residual_contribution_wrapped_poisson (Vector< double > &residuals, DenseMatrix< double > &jacobian, const unsigned &flag)
	Overloaded fill-in function. More...

Private Attributes
Vector< SingularPoissonSolutionElement< PoissonElementWithSingularity< BASIC_POISSON_ELEMENT > > * >	C_equation_elements_pt
	Vector of pointers to SingularPoissonSolutionElement objects. More...
vector< bool >	Node_is_subject_to_dirichlet_bc
Vector< double >	Imposed_value_at_node

Detailed Description

template<class BASIC_POISSON_ELEMENT>
class PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >

///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// Templated wrapper to add handling of singularities to the underlying Poisson element (specified via the template argument). Slightly inefficient because the integration loop is repeated here. The only alternative is to add the additional functionality into the Poisson elements. Not pretty either!

Dirichlet BCs are applied in hijacking manner and must be imposed from each element that shares a boundary node that is subject to a Dirichlet condition.

Constructor & Destructor Documentation

PoissonElementWithSingularity()

template<class BASIC_POISSON_ELEMENT >

PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::PoissonElementWithSingularity ( )

inline

Constructor.

  {
   // Find the number of nodes in the element
   unsigned n_node = this->nnode();
   
   // Initialise the vector of booleans indicating which
   // node is subject to Dirichlet BC. The size of the
   // vector is equal to the number
   // of nodes in the element. By default, no node is subject
   // to Dirichlet BC, so the vector is full of false. 
   Node_is_subject_to_dirichlet_bc.resize(n_node);
   for (unsigned j=0;j<n_node;j++)
    {
     Node_is_subject_to_dirichlet_bc[j] = false;
    }
   
   // Initialise the vector of imposed values on the nodes subject
   // to Dirichlet BC. The size of the vector is equal to the number
   // of nodes in the element. If a node is not subject to Dirichlet
   // BC, its imposed value is zero. By default, no node is subject
   // to Dirichlet BC so the vector is full of zeros
   Imposed_value_at_node.resize(n_node);
   for (unsigned j=0;j<n_node;j++)
    {
     Imposed_value_at_node[j] = 0.0;
    }
   
  } // End of constructor

References PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::Imposed_value_at_node, j, and PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::Node_is_subject_to_dirichlet_bc.

Member Function Documentation

add_c_equation_element_pt()

template<class BASIC_POISSON_ELEMENT >

void PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::add_c_equation_element_pt ( SingularPoissonSolutionElement< PoissonElementWithSingularity< BASIC_POISSON_ELEMENT > > *  c_pt )

inline

Add pointer to associated SingularPoissonSolutionElement that determines the value of the amplitude of the singular function (and gives access to the singular function). The unknown amplitude becomes external Data for this element so assign_eqn_numbers() must be called after this function has been called.

 {
  // Add the element
  C_equation_elements_pt.push_back(c_pt);
  
  // Add the additional unknown of this object as external data in the
  // Poisson element
  this->add_external_data(c_pt->internal_data_pt(0));
 }

References PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::C_equation_elements_pt.

c_equation_elements_pt()

template<class BASIC_POISSON_ELEMENT >

Vector<SingularPoissonSolutionElement<PoissonElementWithSingularity <BASIC_POISSON_ELEMENT> >*> PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::c_equation_elements_pt ( )

inline

Access function to pointer of vector of SingularPoissonSolutionElements. These specify the singular functions that are added to the (regular) FE solution

  {
   return C_equation_elements_pt;
  }

References PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::C_equation_elements_pt.

compute_error()

template<class BASIC_POISSON_ELEMENT >

void PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::compute_error ( std::ostream &  outfile, FiniteElement::SteadyExactSolutionFctPt  exact_soln_pt, double &  error, double &  norm  )

inline

Compute error.

 { 
 
  // Initialise
  error=0.0;
  norm=0.0;
 
  // Find the dimension of the problem
  unsigned cached_dim = this->dim();
 
  //Vector of local coordinates
  Vector<double> s(cached_dim);
 
  // Vector for coordintes
  Vector<double> x(cached_dim);
 
  //Find out how many nodes there are in the element
  unsigned n_node = this->nnode();
 
  Shape psi(n_node);
 
  //Set the value of n_intpt
  unsigned n_intpt = this->integral_pt()->nweight();
  
  // Tecplot 
  outfile << "ZONE" << std::endl;
 
  // Exact solution Vector (here a scalar)
  Vector<double> exact_soln(1);
 
  //Loop over the integration points
  for(unsigned ipt=0;ipt<n_intpt;ipt++)
   {
   
    //Assign values of s
    for(unsigned i=0;i<cached_dim;i++)
     {
      s[i] = this->integral_pt()->knot(ipt,i);
     }
   
    //Get the integral weight
    double w = this->integral_pt()->weight(ipt);
   
    // Get jacobian of mapping
    double J=this->J_eulerian(s);
   
    //Premultiply the weights and the Jacobian
    double W = w*J;
   
    // Get x position as Vector
    this->interpolated_x(s,x);
   
    // Get FE function value
    double u_fe=interpolated_u_poisson(s);
   
    // Get exact solution at this point
    (*exact_soln_pt)(x,exact_soln);
   
    //Output x,y,...,error
    for(unsigned i=0;i<cached_dim;i++)
     {
      outfile << x[i] << " ";
     }
    outfile << exact_soln[0] << " " << exact_soln[0]-u_fe << std::endl;  
   
    // Add to error and norm
    norm+=exact_soln[0]*exact_soln[0]*W;
    error+=(exact_soln[0]-u_fe)*(exact_soln[0]-u_fe)*W;
   }
 }

References calibrate::error, ProblemParameters::exact_soln(), i, PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::interpolated_u_poisson(), J, s, w, oomph::QuadTreeNames::W, and plotDoE::x.

fill_in_contribution_to_jacobian()

template<class BASIC_POISSON_ELEMENT >

void PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::fill_in_contribution_to_jacobian ( Vector< double > &  residuals, DenseMatrix< double > &  jacobian  )

inline

Add the element's contribution to its residual vector and element Jacobian matrix (wrapper)

 {  
  //Call the generic routine with the flag set to 1
  fill_in_generic_residual_contribution_wrapped_poisson(residuals,jacobian,1);
 }

References PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::fill_in_generic_residual_contribution_wrapped_poisson().

fill_in_contribution_to_residuals()

template<class BASIC_POISSON_ELEMENT >

void PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::fill_in_contribution_to_residuals ( Vector< double > &  residuals )

inline

Add the element's contribution to its residual vector (wrapper)

 {
  //Call the generic residuals function with flag set to 0
  //using a dummy matrix argument
  this->fill_in_generic_residual_contribution_wrapped_poisson(
   residuals,GeneralisedElement::Dummy_matrix,0);
 }

References PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::fill_in_generic_residual_contribution_wrapped_poisson().

fill_in_generic_residual_contribution_wrapped_poisson()

template<class BASIC_POISSON_ELEMENT >

void PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::fill_in_generic_residual_contribution_wrapped_poisson ( Vector< double > &  residuals, DenseMatrix< double > &  jacobian, const unsigned &  flag  )

inlineprivate

Overloaded fill-in function.

 {
  // Get the contribution from the underlying wrapped element first
  BASIC_POISSON_ELEMENT::fill_in_generic_residual_contribution_poisson
   (residuals,jacobian,flag);
 
  // Do all the singular functions satisfy laplace's eqn?
  bool all_singular_functions_satisfy_laplace_equation=true;
  
  // Find the number of singularities
  unsigned n_sing = C_equation_elements_pt.size();
  
  //Index at which the poisson unknown is stored
  const unsigned u_nodal_index = this->u_index_poisson();
 
  // Find the dimension of the problem
  unsigned cached_dim=this->dim();
  
  //Find out how many nodes there are
  const unsigned n_node = this->nnode();
  
  // Find the local equation number of the additional unknowns
  Vector<int> local_equation_number_C(n_sing);
  for (unsigned i=0;i<n_sing;i++)
   {
    local_equation_number_C[i] =
     this->external_local_eqn(i,0);
    if (!(C_equation_elements_pt[i]->
          singular_function_satisfies_laplace_equation()))
     {
      all_singular_functions_satisfy_laplace_equation=false;
     }
   }
 
  // Do we need to add the singular function's contribution to the
  // residuals or do they vanish by themselves (mathematically)
  if (!all_singular_functions_satisfy_laplace_equation)
   {
    
    //Set up memory for the shape and test functions
    Shape psi(n_node), test(n_node);
    DShape dpsidx(n_node,cached_dim), dtestdx(n_node,cached_dim);
    
    //Set the value of n_intpt
    const unsigned n_intpt = this->integral_pt()->nweight();
    
    //Integers to store the local equation and unknown numbers
    int local_eqn=0;
    
    //Loop over the integration points
    for(unsigned ipt=0;ipt<n_intpt;ipt++)
     
     {
      //Get the integral weight
      double w = this->integral_pt()->weight(ipt);
      
      //Call the derivatives of the shape and test functions
      double J = this->dshape_and_dtest_eulerian_at_knot_poisson(ipt,psi,dpsidx,
                                                                 test,dtestdx);
      
      //Premultiply the weights and the Jacobian
      double W = w*J;
      
      //Calculate the global coordinate of the integration point
      Vector<double> interpolated_x(cached_dim,0.0);
      // Loop over nodes
      for(unsigned l=0;l<n_node;l++) 
       {
        // Loop over directions
        for(unsigned j=0;j<cached_dim;j++)
         {
          interpolated_x[j] += this->raw_nodal_position(l,j)*psi(l);
         }
       }
 
      // Precompute singular fcts
      Vector<Vector<double> > grad_u_bar_local(n_sing);
      for (unsigned i=0;i<n_sing;i++)
       {
        grad_u_bar_local[i]=grad_u_bar(i,interpolated_x);
       }
      Vector<Vector<double> > grad_singular_function_local(n_sing);
      for (unsigned i=0;i<n_sing;i++)
       {
        grad_singular_function_local[i]=grad_singular_function(i,interpolated_x);
       }
      
      // Assemble residuals and Jacobian
      //--------------------------------
      
      // The interior nodes
      //-------------------
      
      // Loop over the test functions
      for(unsigned l=0;l<n_node;l++)
       {
        //Get the local equation number
        local_eqn = this->nodal_local_eqn(l,u_nodal_index);
        
        // If it is not pinned
        if (local_eqn >= 0)
         {
          // IF it's not a boundary condition
          if(not(Node_is_subject_to_dirichlet_bc[l]))
           {
            // Add the contribution of the additional unknowns to the residual
            for(unsigned i=0;i<n_sing;i++)
             {
              if (!(C_equation_elements_pt[i]->
                    singular_function_satisfies_laplace_equation()))
               {
                for (unsigned k=0;k<cached_dim;k++)
                 {
                  residuals[local_eqn] += 
                   grad_u_bar_local[i][k]*dtestdx(l,k)*W;
                 }
               }
             }
            
            // Calculate the jacobian
            //-----------------------
            if(flag)
             {
              // Loop over the singularities and add the 
              // contributions of the additional 
              // unknowns associated with them to the 
              // jacobian if they are not pinned
              for (unsigned i=0;i<n_sing;i++)
               {
                if (!(C_equation_elements_pt[i]->
                      singular_function_satisfies_laplace_equation()))
                 {
                  if (local_equation_number_C[i]>=0)
                   {
                    for(unsigned d=0;d<cached_dim;d++)
                     {
                      jacobian(local_eqn,local_equation_number_C[i])
                       += grad_singular_function_local[i][d]*
                       dtestdx(l,d)*W;
                     }
                   }
                 }
               }
             }
           }
         }
       } // end of loop over shape functions
      
     } // End of loop over integration points
    
   }
  
  // The Dirichlet nodes
  //--------------------
  
  // Loop over the nodes to see if there is a node subject to
  // Dirichlet BC
  for (unsigned j=0;j<n_node;j++)
   {
    // If it is a dirichlet boundary condition
    if (Node_is_subject_to_dirichlet_bc[j])
     {
      // Find the global coordinate of the node
      Vector<double> global_coordinate_boundary_node(cached_dim);
      for (unsigned d=0;d<cached_dim;d++)
       {
        global_coordinate_boundary_node[d] = this->raw_nodal_position(j,d);
       }
      
      // If it is not pinned
      int local_eqn_number_boundary_node = 
       this->nodal_local_eqn(j,u_nodal_index);
      if (local_eqn_number_boundary_node >= 0)
       {
        // Add the contribution of the node unknown to the residual
        residuals[local_eqn_number_boundary_node] = 
        this->raw_nodal_value(j,u_nodal_index);
        
        // Add the contribution of the additional unknowns to the residual
        for (unsigned i=0;i<n_sing;i++)
         {
          residuals[local_eqn_number_boundary_node] += 
           u_bar(i,global_coordinate_boundary_node);
         }
        
        // Substract the value imposed by the Dirichlet BC from the residual
        residuals[local_eqn_number_boundary_node] -= Imposed_value_at_node[j];
        
        if (flag)
         {
          // Loop over the nodes
          for (unsigned l=0;l<n_node;l++)
           {
            // Find the equation number of the node
            int local_unknown = this->nodal_local_eqn(l,u_nodal_index);
 
            // If it is not pinned
            if (local_unknown >=0)
             {
              // Put to 0 the corresponding jacobian component
              jacobian(local_eqn_number_boundary_node,local_unknown)=0.0;
             }
           }
            
          // Find the contribution of the node to the local jacobian
          jacobian(local_eqn_number_boundary_node,
                   local_eqn_number_boundary_node) += 1.0;
 
          // Loop over the singularities
          for (unsigned i=0;i<n_sing;i++)
           {
            // Find the contribution of the additional unknowns to the jacobian
            int local_unknown=local_equation_number_C[i];
            if (local_unknown>=0)
             {
              jacobian(local_eqn_number_boundary_node,
                       local_unknown) += 
               singular_function(i,global_coordinate_boundary_node);
             }
           }
             
         }
       } // End of check of the pin status of the node
     } // End of check if the node is subject to Dirichlet BC-
   } // End of loop over the nodes
 } // End of function

References PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::C_equation_elements_pt, PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::grad_singular_function(), PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::grad_u_bar(), i, PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::Imposed_value_at_node, J, j, k, PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::Node_is_subject_to_dirichlet_bc, PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::singular_function(), Eigen::test, PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::u_bar(), w, and oomph::QuadTreeNames::W.

Referenced by PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::fill_in_contribution_to_jacobian(), and PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::fill_in_contribution_to_residuals().

grad_singular_function()

template<class BASIC_POISSON_ELEMENT >

Vector<double> PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::grad_singular_function ( const unsigned &  i, const Vector< double > &  x  ) const

inline

Evaluate the gradient of the i-th "raw" singular at Eulerian position x.

  {
   return C_equation_elements_pt[i]->grad_singular_function(x);
  }

References PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::C_equation_elements_pt, i, and plotDoE::x.

Referenced by PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::fill_in_generic_residual_contribution_wrapped_poisson().

grad_u_bar()

template<class BASIC_POISSON_ELEMENT >

Vector<double> PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::grad_u_bar ( const unsigned  i, const Vector< double > &  x  ) const

inline

Evaluate the gradient the i-th singular (incl. the amplitude ) at Eulerian position x

  {
   return C_equation_elements_pt[i]->grad_u_bar(x);
  }

References PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::C_equation_elements_pt, i, and plotDoE::x.

Referenced by PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::fill_in_generic_residual_contribution_wrapped_poisson().

impose_dirichlet_bc_on_node()

template<class BASIC_POISSON_ELEMENT >

void PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::impose_dirichlet_bc_on_node ( const unsigned &  j )

inline

Impose Dirichlet BC on sum of FE solution and u_bar on j-th local node

 {
  Node_is_subject_to_dirichlet_bc[j] = true;
 }

References j, and PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::Node_is_subject_to_dirichlet_bc.

interpolated_u_poisson()

template<class BASIC_POISSON_ELEMENT >

double PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::interpolated_u_poisson ( const Vector< double > &  s ) const

inline

Overloaded version including the singular contributions.

 {
  //Find number of nodes
  const unsigned n_node = this->nnode();
  
  //Get the index at which the poisson unknown is stored
  const unsigned u_nodal_index = this->u_index_poisson();
  
  //Local shape function
  Shape psi(n_node);
  
  //Find values of shape function
  this->shape(s,psi);
  
  //Initialise value of u
  double interpolated_u = 0.0;
  
  // Calculate the global coordinate associated to s
  unsigned cached_dim=this->dim();
  Vector<double> x(cached_dim,0.0);
 
  // Add the contribution of u_FE
  //Loop over the local nodes and sum
  for(unsigned l=0;l<n_node;l++) 
   {
    interpolated_u += this->nodal_value(l,u_nodal_index)*psi[l];
    for (unsigned i=0;i<cached_dim;i++)
     {
      x[i]+=this->raw_nodal_position(l,i)*psi(l);
     }
   }
    
  // Loop over the singularities
  unsigned n_sing=C_equation_elements_pt.size();
  for (unsigned i=0;i<n_sing;i++)
   {
    // Add the contribution of ubari
    interpolated_u += u_bar(i,x);
   }
  
  return(interpolated_u);
 }

References PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::C_equation_elements_pt, i, oomph::OneDimLagrange::shape(), PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::u_bar(), and plotDoE::x.

Referenced by PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::compute_error(), and PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::output().

interpolated_u_poisson_fe_only()

template<class BASIC_POISSON_ELEMENT >

double PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::interpolated_u_poisson_fe_only ( const Vector< double > &  s ) const

inline

Return FE representation of solution WITHOUT singular contributions at local coordinate s

 {
  //Find number of nodes
  const unsigned n_node = this->nnode();
  
  //Get the index at which the poisson unknown is stored
  const unsigned u_nodal_index = this->u_index_poisson();
  
  //Local shape function
  Shape psi(n_node);
  
  //Find values of shape function
  this->shape(s,psi);
  
  //Initialise value of u
  double interpolated_u = 0.0;
  
  // Add the contribution of u_FE
  //Loop over the local nodes and sum
  for(unsigned l=0;l<n_node;l++) 
   {
    interpolated_u += this->nodal_value(l,u_nodal_index)*psi[l];
   }
  
  return interpolated_u;
 }

References oomph::OneDimLagrange::shape().

Referenced by PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::output().

output()

template<class BASIC_POISSON_ELEMENT >

void PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::output ( std::ostream &  outfile, const unsigned &  nplot  )

inline

Overloaded output fct: x, y [,z], u, u_fe_only, u-u_fe_only.

 {
  // Find the dimension of the problem
  unsigned cached_dim = this->dim();
 
  //Vector of local coordinates
  Vector<double> s(cached_dim);
 
  // Tecplot header info
  outfile << this->tecplot_zone_string(nplot);
 
  // Loop over plot points
  unsigned num_plot_points=this->nplot_points(nplot);
  for (unsigned iplot=0;iplot<num_plot_points;iplot++)
   {
   
    // Get local coordinates of plot point
    this->get_s_plot(iplot,nplot,s);
 
    Vector<double> x(cached_dim);
    for(unsigned i=0;i<cached_dim;i++) 
     {
      outfile << this->interpolated_x(s,i) << " ";
      x[i] = this->interpolated_x(s,i);
     }
    
    outfile << interpolated_u_poisson(s) << " "
            << interpolated_u_poisson_fe_only(s) << " "
            << interpolated_u_poisson(s)-interpolated_u_poisson_fe_only(s)
            << std::endl;
   
   }
 
  // Write tecplot footer (e.g. FE connectivity lists)
  this->write_tecplot_zone_footer(outfile,nplot);
 }

References i, PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::interpolated_u_poisson(), PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::interpolated_u_poisson_fe_only(), s, and plotDoE::x.

set_dirichlet_value_on_node()

template<class BASIC_POISSON_ELEMENT >

void PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::set_dirichlet_value_on_node ( const unsigned &  j, const double &  value  )

inline

Specify Dirichlet boundary value for j-th local node.

 {
  Imposed_value_at_node[j] = value;
 }

References PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::Imposed_value_at_node, j, and Eigen::value.

singular_function()

template<class BASIC_POISSON_ELEMENT >

double PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::singular_function ( const unsigned &  i, const Vector< double > &  x  ) const

inline

Evaluate i-th "raw" singular function at Eulerian position x.

 {
  return C_equation_elements_pt[i]->singular_function(x);
 }

References PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::C_equation_elements_pt, i, and plotDoE::x.

Referenced by PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::fill_in_generic_residual_contribution_wrapped_poisson().

u_bar()

template<class BASIC_POISSON_ELEMENT >

double PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::u_bar ( const unsigned &  i, const Vector< double > &  x  ) const

inline

Evaluate i-th u_bar function (i.e. i-th singular incl. the amplitude) function at Eulerian position x

 {
  return C_equation_elements_pt[i]->u_bar(x);
 }

References PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::C_equation_elements_pt, i, and plotDoE::x.

Referenced by PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::fill_in_generic_residual_contribution_wrapped_poisson(), and PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::interpolated_u_poisson().

undo_dirichlet_bc_on_all_nodes()

template<class BASIC_POISSON_ELEMENT >

void PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::undo_dirichlet_bc_on_all_nodes ( )

inline

Undo Dirichlet BCs on all nodes.

 {
  unsigned n_node = this->nnode();
  for (unsigned j=0;j<n_node;j++)
   {
    undo_dirichlet_bc_on_node(j);
   }
 }

References j, and PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::undo_dirichlet_bc_on_node().

undo_dirichlet_bc_on_node()

template<class BASIC_POISSON_ELEMENT >

void PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::undo_dirichlet_bc_on_node ( const unsigned &  j )

inline

Undo Dirichlet BCs on jth node.

 {
  Node_is_subject_to_dirichlet_bc[j] = false;
 }

References j, and PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::Node_is_subject_to_dirichlet_bc.

Referenced by PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::undo_dirichlet_bc_on_all_nodes().

Member Data Documentation

C_equation_elements_pt

template<class BASIC_POISSON_ELEMENT >

Vector<SingularPoissonSolutionElement<PoissonElementWithSingularity <BASIC_POISSON_ELEMENT> >*> PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::C_equation_elements_pt

private

Vector of pointers to SingularPoissonSolutionElement objects.

Referenced by PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::add_c_equation_element_pt(), PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::c_equation_elements_pt(), PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::fill_in_generic_residual_contribution_wrapped_poisson(), PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::grad_singular_function(), PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::grad_u_bar(), PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::interpolated_u_poisson(), PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::singular_function(), and PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::u_bar().

Imposed_value_at_node

template<class BASIC_POISSON_ELEMENT >

Vector<double> PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::Imposed_value_at_node

private

Imposed value at nodes that are subject to Dirichlet BC [size = number of nodes; initialised to zero]

Referenced by PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::fill_in_generic_residual_contribution_wrapped_poisson(), PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::PoissonElementWithSingularity(), and PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::set_dirichlet_value_on_node().

Node_is_subject_to_dirichlet_bc

template<class BASIC_POISSON_ELEMENT >

vector<bool> PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::Node_is_subject_to_dirichlet_bc

private

Boolean indicating which node is subject to Dirichlet BC [size = number of nodes; initialised to false]

Referenced by PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::fill_in_generic_residual_contribution_wrapped_poisson(), PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::impose_dirichlet_bc_on_node(), PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::PoissonElementWithSingularity(), and PoissonElementWithSingularity< BASIC_POISSON_ELEMENT >::undo_dirichlet_bc_on_node().

---

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

• poisson_elements_with_singularity.h