Overload Element to allow calculation of the flux. More...

Inheritance diagram for oomph::MyAxisymmetricFluidElement< ELEMENT >:

Public Member Functions
	MyAxisymmetricFluidElement ()
	Empty constructor. More...

double	square_of_l2_norm ()

Detailed Description

template<class ELEMENT>
class oomph::MyAxisymmetricFluidElement< ELEMENT >

Overload Element to allow calculation of the flux.

Constructor & Destructor Documentation

◆ MyAxisymmetricFluidElement()

template<class ELEMENT >

oomph::MyAxisymmetricFluidElement< ELEMENT >::MyAxisymmetricFluidElement ( )

inline

Empty constructor.

116 { }

Member Function Documentation

◆ square_of_l2_norm()

template<class ELEMENT >

double oomph::MyAxisymmetricFluidElement< ELEMENT >::square_of_l2_norm ( )

inline

Get square of L2 norm of velocity components and add to the entries in the vector norm

    {
     //Initialise the sum to zero
     double sum = 0.0;
     
     //Find out how many nodes there are
     const unsigned n_node = this->nnode();
     
     //Find the indices at which the local velocities are stored
     unsigned u_nodal_index[3];
     for(unsigned i=0;i<3;i++) {u_nodal_index[i] = this->u_index_axi_nst(i);}
     
     //Set up memory for the velocity shape fcts
     Shape psif(n_node);
     DShape dpsidx(n_node,2);
     
     //Number of integration points
     const unsigned n_intpt = this->integral_pt()->nweight();
     
     //Set the Vector to hold local coordinates
     Vector<double> s(2);
     
     //Loop over the integration points
     for(unsigned ipt=0;ipt<n_intpt;ipt++)
      {
       //Assign values of s
       for(unsigned i=0;i<2;i++) s[i] = this->integral_pt()->knot(ipt,i);
       
       //Get the integral weight
       double w = this->integral_pt()->weight(ipt);
       
       // Call the derivatives of the veloc shape functions
       // (Derivs not needed but they are free)
       double J = this->dshape_eulerian_at_knot(ipt,psif,dpsidx);
  
  
       // Calculate position
       Vector<double> interpolated_x(2,0.0);
       //Calculate velocities 
       Vector<double> interpolated_u(3,0.0);      
       
       // Loop over nodes
       for(unsigned l=0;l<n_node;l++) 
        {
         const double psif_ = psif[l];
  
         //Loop over physical coordinates
         for(unsigned i=0;i<2;i++)
          {
           interpolated_x[i] += this->raw_nodal_position(l,i)*psif_;
          }
  
         //Loop over velocity components
         for(unsigned i=0;i<3;i++)
          {
           interpolated_u[i] += this->raw_nodal_value(l,u_nodal_index[i])*psif_;
          }
        }
  
       
       //Premultiply the weights and the Jacobian
       double W = interpolated_x[0]*w*J;
  
       //Assemble square of L2 norm
       for(unsigned i=0;i<3;i++)
        {
         sum +=interpolated_u[i]*interpolated_u[i]*W;
        }           
      }
  
     return sum;
    }

References i, J, s, w, and oomph::QuadTreeNames::W.

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

unstructured_torus.cc