refineable_axisym_navier_stokes_elements.h

Go to the documentation of this file.

// LIC// ====================================================================
// LIC// This file forms part of oomph-lib, the object-oriented,
// LIC// multi-physics finite-element library, available
// LIC// at http://www.oomph-lib.org.
// LIC//
// LIC// Copyright (C) 2006-2023 Matthias Heil and Andrew Hazel
// LIC//
// LIC// This library is free software; you can redistribute it and/or
// LIC// modify it under the terms of the GNU Lesser General Public
// LIC// License as published by the Free Software Foundation; either
// LIC// version 2.1 of the License, or (at your option) any later version.
// LIC//
// LIC// This library is distributed in the hope that it will be useful,
// LIC// but WITHOUT ANY WARRANTY; without even the implied warranty of
// LIC// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// LIC// Lesser General Public License for more details.
// LIC//
// LIC// You should have received a copy of the GNU Lesser General Public
// LIC// License along with this library; if not, write to the Free Software
// LIC// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// LIC// 02110-1301  USA.
// LIC//
// LIC// The authors may be contacted at oomph-lib@maths.man.ac.uk.
// LIC//
// LIC//====================================================================
// Header file for refineable axisymmetric quad Navier Stokes elements
#ifndef OOMPH_REFINEABLE_AXISYMMETRIC_NAVIER_STOKES_ELEMENTS_HEADER
#define OOMPH_REFINEABLE_AXISYMMETRIC_NAVIER_STOKES_ELEMENTS_HEADER
 
// Config header generated by autoconfig
#ifdef HAVE_CONFIG_H
#include <oomph-lib-config.h>
#endif
 
// Oomph lib includes
#include "../generic/refineable_quad_element.h"
#include "../generic/error_estimator.h"
#include "axisym_navier_stokes_elements.h"
 
namespace oomph
{
  //======================================================================
  /// Refineable version of the Axisymmetric Navier--Stokes equations
  //======================================================================
  class RefineableAxisymmetricNavierStokesEquations
    : public virtual AxisymmetricNavierStokesEquations,
      public virtual RefineableElement,
      public virtual ElementWithZ2ErrorEstimator
  {
  protected:
    /// Pointer to n_p-th pressure node (Default: NULL,
    /// indicating that pressure is not based on nodal interpolation).
    virtual Node* pressure_node_pt(const unsigned& n_p)
    {
      return NULL;
    }
 
    /// Unpin all pressure dofs in the element
    virtual void unpin_elemental_pressure_dofs() = 0;
 
    /// Pin unused nodal pressure dofs (empty by default, because
    /// by default pressure dofs are not associated with nodes)
    virtual void pin_elemental_redundant_nodal_pressure_dofs() {}
 
  public:
    /// Empty Constructor
    RefineableAxisymmetricNavierStokesEquations()
      : AxisymmetricNavierStokesEquations(),
        RefineableElement(),
        ElementWithZ2ErrorEstimator()
    {
    }
 
    /// Number of 'flux' terms for Z2 error estimation
    unsigned num_Z2_flux_terms()
    {
      // 3 diagonal strain rates, 3 off diagonal
      return 6;
    }
 
    /// Get 'flux' for Z2 error recovery:   Upper triangular entries
    /// in strain rate tensor.
    void get_Z2_flux(const Vector<double>& s, Vector<double>& flux)
    {
      // Specify the number of velocity dimensions
      unsigned DIM = 3;
 
#ifdef PARANOID
      unsigned num_entries = DIM + ((DIM * DIM) - DIM) / 2;
      if (flux.size() < num_entries)
      {
        std::ostringstream error_message;
        error_message << "The flux vector has the wrong number of entries, "
                      << flux.size() << ", whereas it should be " << num_entries
                      << std::endl;
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif
 
 
      // Get strain rate matrix
      DenseMatrix<double> strainrate(DIM);
      this->strain_rate(s, strainrate);
 
      // Pack into flux Vector
      unsigned icount = 0;
 
      // Start with diagonal terms
      for (unsigned i = 0; i < DIM; i++)
      {
        flux[icount] = strainrate(i, i);
        icount++;
      }
 
      // Off diagonals row by row
      for (unsigned i = 0; i < DIM; i++)
      {
        for (unsigned j = i + 1; j < DIM; j++)
        {
          flux[icount] = strainrate(i, j);
          icount++;
        }
      }
    }
 
    /// Fill in the geometric Jacobian, which in this case is r
    double geometric_jacobian(const Vector<double>& x)
    {
      return x[0];
    }
 
 
    ///  Further build: pass the pointers down to the sons
    void further_build()
    {
      // Find the father element
      RefineableAxisymmetricNavierStokesEquations* cast_father_element_pt =
        dynamic_cast<RefineableAxisymmetricNavierStokesEquations*>(
          this->father_element_pt());
 
      // Set the viscosity ratio pointer
      this->Viscosity_Ratio_pt = cast_father_element_pt->viscosity_ratio_pt();
      // Set the density ratio pointer
      this->Density_Ratio_pt = cast_father_element_pt->density_ratio_pt();
      // Set pointer to global Reynolds number
      this->Re_pt = cast_father_element_pt->re_pt();
      // Set pointer to global Reynolds number x Strouhal number (=Womersley)
      this->ReSt_pt = cast_father_element_pt->re_st_pt();
      // Set pointer to global Reynolds number x inverse Froude number
      this->ReInvFr_pt = cast_father_element_pt->re_invfr_pt();
      // Set pointer to the global Reynolds number x inverse Rossby number
      this->ReInvRo_pt = cast_father_element_pt->re_invro_pt();
      // Set pointer to global gravity Vector
      this->G_pt = cast_father_element_pt->g_pt();
 
      // Set pointer to body force function
      this->Body_force_fct_pt =
        cast_father_element_pt->axi_nst_body_force_fct_pt();
 
      // Set pointer to volumetric source function
      this->Source_fct_pt = cast_father_element_pt->source_fct_pt();
 
      // Set the ALE_is_disabled flag
      this->ALE_is_disabled = cast_father_element_pt->ALE_is_disabled;
    }
 
    /// Compute the derivatives of the i-th component of
    /// velocity at point s with respect
    /// to all data that can affect its value. In addition, return the global
    /// equation numbers corresponding to the data.
    /// Overload the non-refineable version to take account of hanging node
    /// information
    void dinterpolated_u_axi_nst_ddata(const Vector<double>& s,
                                       const unsigned& i,
                                       Vector<double>& du_ddata,
                                       Vector<unsigned>& global_eqn_number)
    {
      // Find number of nodes
      unsigned n_node = this->nnode();
      // Local shape function
      Shape psi(n_node);
      // Find values of shape function at the given local coordinate
      this->shape(s, psi);
 
      // Find the index at which the velocity component is stored
      const unsigned u_nodal_index = this->u_index_axi_nst(i);
 
      // Storage for hang info pointer
      HangInfo* hang_info_pt = 0;
      // Storage for global equation
      int global_eqn = 0;
 
      // Find the number of dofs associated with interpolated u
      unsigned n_u_dof = 0;
      for (unsigned l = 0; l < n_node; l++)
      {
        unsigned n_master = 1;
 
        // Local bool (is the node hanging)
        bool is_node_hanging = this->node_pt(l)->is_hanging();
 
        // If the node is hanging, get the number of master nodes
        if (is_node_hanging)
        {
          hang_info_pt = this->node_pt(l)->hanging_pt();
          n_master = hang_info_pt->nmaster();
        }
        // Otherwise there is just one master node, the node itself
        else
        {
          n_master = 1;
        }
 
        // Loop over the master nodes
        for (unsigned m = 0; m < n_master; m++)
        {
          // Get the equation number
          if (is_node_hanging)
          {
            // Get the equation number from the master node
            global_eqn =
              hang_info_pt->master_node_pt(m)->eqn_number(u_nodal_index);
          }
          else
          {
            // Global equation number
            global_eqn = this->node_pt(l)->eqn_number(u_nodal_index);
          }
 
          // If it's positive add to the count
          if (global_eqn >= 0)
          {
            ++n_u_dof;
          }
        }
      }
 
      // Now resize the storage schemes
      du_ddata.resize(n_u_dof, 0.0);
      global_eqn_number.resize(n_u_dof, 0);
 
      // Loop over th nodes again and set the derivatives
      unsigned count = 0;
      // Loop over the local nodes and sum
      for (unsigned l = 0; l < n_node; l++)
      {
        unsigned n_master = 1;
        double hang_weight = 1.0;
 
        // Local bool (is the node hanging)
        bool is_node_hanging = this->node_pt(l)->is_hanging();
 
        // If the node is hanging, get the number of master nodes
        if (is_node_hanging)
        {
          hang_info_pt = this->node_pt(l)->hanging_pt();
          n_master = hang_info_pt->nmaster();
        }
        // Otherwise there is just one master node, the node itself
        else
        {
          n_master = 1;
        }
 
        // Loop over the master nodes
        for (unsigned m = 0; m < n_master; m++)
        {
          // If the node is hanging get weight from master node
          if (is_node_hanging)
          {
            // Get the hang weight from the master node
            hang_weight = hang_info_pt->master_weight(m);
          }
          else
          {
            // Node contributes with full weight
            hang_weight = 1.0;
          }
 
          // Get the equation number
          if (is_node_hanging)
          {
            // Get the equation number from the master node
            global_eqn =
              hang_info_pt->master_node_pt(m)->eqn_number(u_nodal_index);
          }
          else
          {
            // Local equation number
            global_eqn = this->node_pt(l)->eqn_number(u_nodal_index);
          }
 
          if (global_eqn >= 0)
          {
            // Set the global equation number
            global_eqn_number[count] = global_eqn;
            // Set the derivative with respect to the unknown
            du_ddata[count] = psi[l] * hang_weight;
            // Increase the counter
            ++count;
          }
        }
      }
    }
 
 
    ///  Loop over all elements in Vector (which typically contains
    /// all the elements in a fluid mesh) and pin the nodal pressure degrees
    /// of freedom that are not being used. Function uses
    /// the member function
    /// - \c RefineableAxisymmetricNavierStokesEquations::
    ///       pin_all_nodal_pressure_dofs()
    /// .
    /// which is empty by default and should be implemented for
    /// elements with nodal pressure degrees of freedom
    /// (e.g. for refineable Taylor-Hood.)
    static void pin_redundant_nodal_pressures(
      const Vector<GeneralisedElement*>& element_pt)
    {
      // Loop over all elements to brutally pin all nodal pressure degrees of
      // freedom
      unsigned n_element = element_pt.size();
      for (unsigned e = 0; e < n_element; e++)
      {
        dynamic_cast<RefineableAxisymmetricNavierStokesEquations*>(
          element_pt[e])
          ->pin_elemental_redundant_nodal_pressure_dofs();
      }
    }
 
    /// Unpin all pressure dofs in elements listed in vector.
    static void unpin_all_pressure_dofs(
      const Vector<GeneralisedElement*>& element_pt)
    {
      // Loop over all elements to brutally unpin all nodal pressure degrees of
      // freedom and internal pressure degrees of freedom
      unsigned n_element = element_pt.size();
      for (unsigned e = 0; e < n_element; e++)
      {
        dynamic_cast<RefineableAxisymmetricNavierStokesEquations*>(
          element_pt[e])
          ->unpin_elemental_pressure_dofs();
      }
    }
 
    /// Compute derivatives of elemental residual vector with respect to
    /// nodal coordinates. This function computes these terms analytically and
    /// overwrites the default implementation in the FiniteElement base class.
    /// dresidual_dnodal_coordinates(l,i,j) = d res(l) / dX_{ij}
    virtual void get_dresidual_dnodal_coordinates(
      RankThreeTensor<double>& dresidual_dnodal_coordinates);
 
  private:
    /// Add element's contribution to the elemental residual vector
    /// and/or Jacobian matrix and mass matrix
    /// flag=2: compute all
    /// flag=1: compute both residual and Jacobian
    /// flag=0: compute only residual vector
    void fill_in_generic_residual_contribution_axi_nst(
      Vector<double>& residuals,
      DenseMatrix<double>& jacobian,
      DenseMatrix<double>& mass_matrix,
      unsigned flag);
 
    /// Add element's contribution to the derivative of the
    /// elemental residual vector
    /// and/or Jacobian matrix and/or mass matrix
    /// flag=2: compute all
    /// flag=1: compute both residual and Jacobian
    /// flag=0: compute only residual vector
    void fill_in_generic_dresidual_contribution_axi_nst(
      double* const& parameter_pt,
      Vector<double>& dres_dparam,
      DenseMatrix<double>& djac_dparam,
      DenseMatrix<double>& dmass_matrix_dparam,
      unsigned flag)
    {
      throw OomphLibError("Not yet implemented\n",
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
 
    /// Compute the hessian tensor vector products required to
    /// perform continuation of bifurcations analytically
    void fill_in_contribution_to_hessian_vector_products(
      Vector<double> const& Y,
      DenseMatrix<double> const& C,
      DenseMatrix<double>& product)
    {
      throw OomphLibError("Not yet implemented\n",
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
  };
 
  //======================================================================
  /// Refineable version of Axisymmetric Quad Taylor Hood elements.
  /// (note that unlike the cartesian version this is not scale-able
  /// to higher dimensions!)
  //======================================================================
  class RefineableAxisymmetricQTaylorHoodElement
    : public AxisymmetricQTaylorHoodElement,
      public virtual RefineableAxisymmetricNavierStokesEquations,
      public virtual RefineableQElement<2>
  {
  private:
    /// Pointer to n_p-th pressure node
    Node* pressure_node_pt(const unsigned& n_p)
    {
      return this->node_pt(this->Pconv[n_p]);
    }
 
    /// Unpin all pressure dofs
    void unpin_elemental_pressure_dofs()
    {
      unsigned n_node = this->nnode();
      int p_index = this->p_nodal_index_axi_nst();
      // loop over nodes
      for (unsigned n = 0; n < n_node; n++)
      {
        this->node_pt(n)->unpin(p_index);
      }
    }
 
    ///  Unpin the proper nodal pressure dofs
    void pin_elemental_redundant_nodal_pressure_dofs()
    {
      // Loop over all nodes
      unsigned n_node = this->nnode();
      int p_index = this->p_nodal_index_axi_nst();
      // loop over all nodes and pin all  the nodal pressures
      for (unsigned n = 0; n < n_node; n++)
      {
        this->node_pt(n)->pin(p_index);
      }
 
      // Loop over all actual pressure nodes and unpin if they're not hanging
      unsigned n_pres = this->npres_axi_nst();
      for (unsigned l = 0; l < n_pres; l++)
      {
        Node* nod_pt = this->node_pt(this->Pconv[l]);
        if (!nod_pt->is_hanging(p_index))
        {
          nod_pt->unpin(p_index);
        }
      }
    }
 
  public:
    /// Constructor:
    RefineableAxisymmetricQTaylorHoodElement()
      : RefineableElement(),
        RefineableAxisymmetricNavierStokesEquations(),
        RefineableQElement<2>(),
        AxisymmetricQTaylorHoodElement()
    {
    }
 
    /// Number of values (pinned or dofs) required at node n.
    // Bumped up to 4 so we don't have to worry if a hanging mid-side node
    // gets shared by a corner node (which has extra degrees of freedom)
    unsigned required_nvalue(const unsigned& n) const
    {
      return 4;
    }
 
    /// Number of continuously interpolated values: 4 (3 velocities + 1
    /// pressure)
    unsigned ncont_interpolated_values() const
    {
      return 4;
    }
 
    /// Rebuild from sons: empty
    void rebuild_from_sons(Mesh*& mesh_pt) {}
 
    /// Order of recovery shape functions for Z2 error estimation:
    /// Same order as shape functions.
    unsigned nrecovery_order()
    {
      return 2;
    }
 
    /// Number of vertex nodes in the element
    unsigned nvertex_node() const
    {
      return AxisymmetricQTaylorHoodElement::nvertex_node();
    }
 
    /// Pointer to the j-th vertex node in the element
    Node* vertex_node_pt(const unsigned& j) const
    {
      return AxisymmetricQTaylorHoodElement::vertex_node_pt(j);
    }
 
    /// 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.
    void get_interpolated_values(const Vector<double>& s,
                                 Vector<double>& values)
    {
      // Set the velocity dimension of the element
      unsigned DIM = 3;
 
      // Set size of values Vector: u,w,v,p and initialise to zero
      values.resize(DIM + 1, 0.0);
 
      // Calculate velocities: values[0],...
      for (unsigned i = 0; i < DIM; i++)
      {
        values[i] = interpolated_u_axi_nst(s, i);
      }
 
      // Calculate pressure: values[DIM]
      values[DIM] = interpolated_p_axi_nst(s);
    }
 
    /// 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.
    void get_interpolated_values(const unsigned& t,
                                 const Vector<double>& s,
                                 Vector<double>& values)
    {
      unsigned DIM = 3;
 
      // Set size of Vector: u,w,v,p
      values.resize(DIM + 1);
 
      // Initialise
      for (unsigned i = 0; i < DIM + 1; i++)
      {
        values[i] = 0.0;
      }
 
      // Find out how many nodes there are
      unsigned n_node = nnode();
 
      // Shape functions
      Shape psif(n_node);
      shape(s, psif);
 
      // Calculate velocities: values[0],...
      for (unsigned i = 0; i < DIM; i++)
      {
        // Get the nodal coordinate of the velocity
        unsigned u_nodal_index = u_index_axi_nst(i);
        for (unsigned l = 0; l < n_node; l++)
        {
          values[i] += nodal_value(t, l, u_nodal_index) * psif[l];
        }
      }
 
      // Calculate pressure: values[DIM]
      //(no history is carried in the pressure)
      values[DIM] = interpolated_p_axi_nst(s);
    }
 
    ///  Perform additional hanging node procedures for variables
    /// that are not interpolated by all nodes. The pressures are stored
    /// at the 3rd location in each node
    void further_setup_hanging_nodes()
    {
      int DIM = 3;
      this->setup_hang_for_value(DIM);
    }
 
    /// The velocities are isoparametric and so the "nodes" interpolating
    /// the velocities are the geometric nodes. The pressure "nodes" are a
    /// subset of the nodes, so when n_value==DIM, the n-th pressure
    /// node is returned.
    Node* interpolating_node_pt(const unsigned& n, const int& n_value)
 
    {
      int DIM = 3;
      // The only different nodes are the pressure nodes
      if (n_value == DIM)
      {
        return this->node_pt(this->Pconv[n]);
      }
      // The other variables are interpolated via the usual nodes
      else
      {
        return this->node_pt(n);
      }
    }
 
    /// The pressure nodes are the corner nodes, so when n_value==DIM,
    /// the fraction is the same as the 1d node number, 0 or 1.
    double local_one_d_fraction_of_interpolating_node(const unsigned& n1d,
                                                      const unsigned& i,
                                                      const int& n_value)
    {
      int DIM = 3;
      if (n_value == DIM)
      {
        // The pressure nodes are just located on the boundaries at 0 or 1
        return double(n1d);
      }
      // Otherwise the velocity nodes are the same as the geometric ones
      else
      {
        return this->local_one_d_fraction_of_node(n1d, i);
      }
    }
 
    /// The velocity nodes are the same as the geometric nodes. The
    /// pressure nodes must be calculated by using the same methods as
    /// the geometric nodes, but by recalling that there are only two pressure
    /// nodes per edge.
    Node* get_interpolating_node_at_local_coordinate(const Vector<double>& s,
                                                     const int& n_value)
    {
      int DIM = 3;
      // If we are calculating pressure nodes
      if (n_value == static_cast<int>(DIM))
      {
        // Storage for the index of the pressure node
        unsigned total_index = 0;
        // The number of nodes along each 1d edge is 2.
        unsigned NNODE_1D = 2;
        // Storage for the index along each boundary
        // Note that it's only a 2D spatial element
        Vector<int> index(2);
        // Loop over the coordinates
        for (unsigned i = 0; i < 2; i++)
        {
          // If we are at the lower limit, the index is zero
          if (s[i] == -1.0)
          {
            index[i] = 0;
          }
          // If we are at the upper limit, the index is the number of nodes
          // minus 1
          else if (s[i] == 1.0)
          {
            index[i] = NNODE_1D - 1;
          }
          // Otherwise, we have to calculate the index in general
          else
          {
            // For uniformly spaced nodes the 0th node number would be
            double float_index = 0.5 * (1.0 + s[i]) * (NNODE_1D - 1);
            index[i] = int(float_index);
            // What is the excess. This should be safe because the
            // taking the integer part rounds down
            double excess = float_index - index[i];
            // If the excess is bigger than our tolerance there is no node,
            // return null
            if ((excess > FiniteElement::Node_location_tolerance) &&
                ((1.0 - excess) > FiniteElement::Node_location_tolerance))
            {
              return 0;
            }
          }
          /// Construct the general pressure index from the components.
          total_index +=
            index[i] * static_cast<unsigned>(pow(static_cast<float>(NNODE_1D),
                                                 static_cast<int>(i)));
        }
        // If we've got here we have a node, so let's return a pointer to it
        return this->node_pt(this->Pconv[total_index]);
      }
      // Otherwise velocity nodes are the same as pressure nodes
      else
      {
        return this->get_node_at_local_coordinate(s);
      }
    }
 
 
    /// The number of 1d pressure nodes is 2, the number of 1d velocity
    /// nodes is the same as the number of 1d geometric nodes.
    unsigned ninterpolating_node_1d(const int& n_value)
    {
      int DIM = 3;
      if (n_value == DIM)
      {
        return 2;
      }
      else
      {
        return this->nnode_1d();
      }
    }
 
    /// The number of pressure nodes is 4. The number of
    /// velocity nodes is the same as the number of geometric nodes.
    unsigned ninterpolating_node(const int& n_value)
    {
      int DIM = 3;
      if (n_value == DIM)
      {
        return 4;
      }
      else
      {
        return this->nnode();
      }
    }
 
    /// The basis interpolating the pressure is given by pshape().
    /// / The basis interpolating the velocity is shape().
    void interpolating_basis(const Vector<double>& s,
                             Shape& psi,
                             const int& n_value) const
    {
      int DIM = 3;
      if (n_value == DIM)
      {
        return this->pshape_axi_nst(s, psi);
      }
      else
      {
        return this->shape(s, psi);
      }
    }
  };
 
 
  /// ////////////////////////////////////////////////////////////////////////
  /// ////////////////////////////////////////////////////////////////////////
  /// ////////////////////////////////////////////////////////////////////////
 
  //=======================================================================
  /// Face geometry of the RefineableQuadQTaylorHoodElements
  //=======================================================================
  template<>
  class FaceGeometry<RefineableAxisymmetricQTaylorHoodElement>
    : public virtual FaceGeometry<AxisymmetricQTaylorHoodElement>
  {
  public:
    FaceGeometry() : FaceGeometry<AxisymmetricQTaylorHoodElement>() {}
  };
 
 
  //=======================================================================
  /// Face geometry of the RefineableQuadQTaylorHoodElements
  //=======================================================================
  template<>
  class FaceGeometry<FaceGeometry<RefineableAxisymmetricQTaylorHoodElement>>
    : public virtual FaceGeometry<FaceGeometry<AxisymmetricQTaylorHoodElement>>
  {
  public:
    FaceGeometry()
      : FaceGeometry<FaceGeometry<AxisymmetricQTaylorHoodElement>>()
    {
    }
  };
 
 
  //======================================================================
  /// Refineable version of Axisymmetric Quad Crouzeix Raviart elements
  /// (note that unlike the cartesian version this is not scale-able
  /// to higher dimensions!)
  //======================================================================
  class RefineableAxisymmetricQCrouzeixRaviartElement
    : public AxisymmetricQCrouzeixRaviartElement,
      public virtual RefineableAxisymmetricNavierStokesEquations,
      public virtual RefineableQElement<2>
  {
  private:
    /// Unpin all the internal pressure freedoms
    void unpin_elemental_pressure_dofs()
    {
      unsigned n_pres = this->npres_axi_nst();
      // loop over pressure dofs and unpin
      for (unsigned l = 0; l < n_pres; l++)
      {
        this->internal_data_pt(P_axi_nst_internal_index)->unpin(l);
      }
    }
 
  public:
    /// Constructor:
    RefineableAxisymmetricQCrouzeixRaviartElement()
      : RefineableElement(),
        RefineableAxisymmetricNavierStokesEquations(),
        RefineableQElement<2>(),
        AxisymmetricQCrouzeixRaviartElement()
    {
    }
 
    /// Number of continuously interpolated values: 3 (velocities)
    unsigned ncont_interpolated_values() const
    {
      return 3;
    }
 
    /// Rebuild from sons: Reconstruct pressure from the (merged) sons
    void rebuild_from_sons(Mesh*& mesh_pt)
    {
      using namespace QuadTreeNames;
 
      // Central pressure value:
      //-----------------------
 
      // Use average of the sons central pressure values
      // Other options: Take average of the four (discontinuous)
      // pressure values at the father's midpoint]
 
      double av_press = 0.0;
 
      // Loop over the sons
      for (unsigned ison = 0; ison < 4; ison++)
      {
        // Add the sons midnode pressure
        av_press += quadtree_pt()
                      ->son_pt(ison)
                      ->object_pt()
                      ->internal_data_pt(P_axi_nst_internal_index)
                      ->value(0);
      }
 
      // Use the average
      internal_data_pt(P_axi_nst_internal_index)->set_value(0, 0.25 * av_press);
 
 
      // Slope in s_0 direction
      //----------------------
 
      // Use average of the 2 FD approximations based on the
      // elements central pressure values
      // [Other options: Take average of the four
      // pressure derivatives]
 
      double slope1 = quadtree_pt()
                        ->son_pt(SE)
                        ->object_pt()
                        ->internal_data_pt(P_axi_nst_internal_index)
                        ->value(0) -
                      quadtree_pt()
                        ->son_pt(SW)
                        ->object_pt()
                        ->internal_data_pt(P_axi_nst_internal_index)
                        ->value(0);
 
      double slope2 = quadtree_pt()
                        ->son_pt(NE)
                        ->object_pt()
                        ->internal_data_pt(P_axi_nst_internal_index)
                        ->value(0) -
                      quadtree_pt()
                        ->son_pt(NW)
                        ->object_pt()
                        ->internal_data_pt(P_axi_nst_internal_index)
                        ->value(0);
 
 
      // Use the average
      internal_data_pt(P_axi_nst_internal_index)
        ->set_value(1, 0.5 * (slope1 + slope2));
 
 
      // Slope in s_1 direction
      //----------------------
 
      // Use average of the 2 FD approximations based on the
      // elements central pressure values
      // [Other options: Take average of the four
      // pressure derivatives]
 
      slope1 = quadtree_pt()
                 ->son_pt(NE)
                 ->object_pt()
                 ->internal_data_pt(P_axi_nst_internal_index)
                 ->value(0) -
               quadtree_pt()
                 ->son_pt(SE)
                 ->object_pt()
                 ->internal_data_pt(P_axi_nst_internal_index)
                 ->value(0);
 
      slope2 = quadtree_pt()
                 ->son_pt(NW)
                 ->object_pt()
                 ->internal_data_pt(P_axi_nst_internal_index)
                 ->value(0) -
               quadtree_pt()
                 ->son_pt(SW)
                 ->object_pt()
                 ->internal_data_pt(P_axi_nst_internal_index)
                 ->value(0);
 
 
      // Use the average
      internal_data_pt(P_axi_nst_internal_index)
        ->set_value(2, 0.5 * (slope1 + slope2));
    }
 
    /// Order of recovery shape functions for Z2 error estimation:
    /// Same order as shape functions.
    unsigned nrecovery_order()
    {
      return 2;
    }
 
    /// Number of vertex nodes in the element
    unsigned nvertex_node() const
    {
      return AxisymmetricQCrouzeixRaviartElement::nvertex_node();
    }
 
    /// Pointer to the j-th vertex node in the element
    Node* vertex_node_pt(const unsigned& j) const
    {
      return AxisymmetricQCrouzeixRaviartElement::vertex_node_pt(j);
    }
 
    /// 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.
    void get_interpolated_values(const Vector<double>& s,
                                 Vector<double>& values)
    {
      unsigned DIM = 3;
 
      // Set size of Vector: u,w,v and initialise to zero
      values.resize(DIM, 0.0);
 
      // Calculate velocities: values[0],...
      for (unsigned i = 0; i < DIM; i++)
      {
        values[i] = interpolated_u_axi_nst(s, i);
      }
    }
 
    /// Get all function values [u,v..,p] at previous timestep t
    /// (t=0: present; t>0: previous timestep).
    /// \n
    /// 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.
    /// \n
    /// Note: No pressure history is kept, so pressure is always
    /// the current value.
    void get_interpolated_values(const unsigned& t,
                                 const Vector<double>& s,
                                 Vector<double>& values)
    {
      unsigned DIM = 3;
 
      // Set size of Vector: u,w,v
      values.resize(DIM);
 
      // Initialise
      for (unsigned i = 0; i < DIM; i++)
      {
        values[i] = 0.0;
      }
 
      // Find out how many nodes there are
      unsigned n_node = nnode();
 
      // Shape functions
      Shape psif(n_node);
      shape(s, psif);
 
      // Calculate velocities: values[0],...
      for (unsigned i = 0; i < DIM; i++)
      {
        // Get the local index at which the i-th velocity is stored
        unsigned u_local_index = u_index_axi_nst(i);
        for (unsigned l = 0; l < n_node; l++)
        {
          values[i] += nodal_value(t, l, u_local_index) * psif[l];
        }
      }
    }
 
    ///  Perform additional hanging node procedures for variables
    /// that are not interpolated by all nodes. Empty
    void further_setup_hanging_nodes() {}
 
    /// Further build for Crouzeix_Raviart interpolates the internal
    /// pressure dofs from father element: Make sure pressure values and
    /// dp/ds agree between fathers and sons at the midpoints of the son
    /// elements.
    void further_build()
    {
      // Call the generic further build
      RefineableAxisymmetricNavierStokesEquations::further_build();
 
      using namespace QuadTreeNames;
 
      // What type of son am I? Ask my quadtree representation...
      int son_type = quadtree_pt()->son_type();
 
      // Pointer to my father (in element impersonation)
      RefineableElement* father_el_pt = quadtree_pt()->father_pt()->object_pt();
 
      Vector<double> s_father(2);
 
      // Son midpoint is located at the following coordinates in father element:
 
      // South west son
      if (son_type == SW)
      {
        s_father[0] = -0.5;
        s_father[1] = -0.5;
      }
      // South east son
      else if (son_type == SE)
      {
        s_father[0] = 0.5;
        s_father[1] = -0.5;
      }
      // North east son
      else if (son_type == NE)
      {
        s_father[0] = 0.5;
        s_father[1] = 0.5;
      }
 
      // North west son
      else if (son_type == NW)
      {
        s_father[0] = -0.5;
        s_father[1] = 0.5;
      }
 
      // Pressure value in father element
      RefineableAxisymmetricQCrouzeixRaviartElement* cast_father_el_pt =
        dynamic_cast<RefineableAxisymmetricQCrouzeixRaviartElement*>(
          father_el_pt);
      double press = cast_father_el_pt->interpolated_p_axi_nst(s_father);
 
      // Pressure value gets copied straight into internal dof:
      internal_data_pt(P_axi_nst_internal_index)->set_value(0, press);
 
 
      // The slopes get copied from father
      internal_data_pt(P_axi_nst_internal_index)
        ->set_value(
          1,
          0.5 * cast_father_el_pt->internal_data_pt(P_axi_nst_internal_index)
                  ->value(1));
 
      internal_data_pt(P_axi_nst_internal_index)
        ->set_value(
          2,
          0.5 * cast_father_el_pt->internal_data_pt(P_axi_nst_internal_index)
                  ->value(2));
    }
  };
 
 
  //=======================================================================
  /// Face geometry of the RefineableQuadQCrouzeixRaviartElements
  //=======================================================================
  template<>
  class FaceGeometry<RefineableAxisymmetricQCrouzeixRaviartElement>
    : public virtual FaceGeometry<AxisymmetricQCrouzeixRaviartElement>
  {
  public:
    FaceGeometry() : FaceGeometry<AxisymmetricQCrouzeixRaviartElement>() {}
  };
 
 
  //=======================================================================
  /// Face geometry of the RefineableQuadQCrouzeixRaviartElements
  //=======================================================================
  template<>
  class FaceGeometry<
    FaceGeometry<RefineableAxisymmetricQCrouzeixRaviartElement>>
    : public virtual FaceGeometry<
        FaceGeometry<AxisymmetricQCrouzeixRaviartElement>>
  {
  public:
    FaceGeometry()
      : FaceGeometry<FaceGeometry<AxisymmetricQCrouzeixRaviartElement>>()
    {
    }
  };
 
 
} // namespace oomph
 
#endif