pml_fourier_decomposed_helmholtz_flux_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//    Version 1.0; svn revision $LastChangedRevision$
//LIC//
//LIC// $LastChangedDate$
//LIC// 
//LIC// Copyright (C) 2006-2016 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 elements that are used to apply prescribed flux
// boundary conditions to the Fourier decomposed Helmholtz equations
#ifndef OOMPH_PML_FOURIER_DECOMPOSED_HELMHOLTZ_FLUX_ELEMENTS_HEADER
#define OOMPH_PML_FOURIER_DECOMPOSED_HELMHOLTZ_FLUX_ELEMENTS_HEADER


// Config header generated by autoconfig
#ifdef HAVE_CONFIG_H
#include <oomph-lib-config.h>
#endif

#include "math.h"
#include <complex>

// oomph-lib includes
#include "../generic/Qelements.h"


namespace oomph
{

//======================================================================
/// \short A class for elements that allow the imposition of an
/// applied flux on the boundaries of Fourier decomposed Helmholtz elements.
/// The element geometry is obtained from the  FaceGeometry<ELEMENT>
/// policy class.
//======================================================================
 template <class ELEMENT>
  class PMLFourierDecomposedHelmholtzFluxElement :
 public virtual FaceGeometry<ELEMENT>,
  public virtual FaceElement
  {

    public:

   /// \short Function pointer to the prescribed-flux function fct(x,f(x)) --
   /// x is a Vector and  the flux is a complex

   typedef void (*PMLFourierDecomposedHelmholtzPrescribedFluxFctPt)
    (const Vector<double>& x, std::complex<double>& flux);

   /// \short Constructor, takes the pointer to the "bulk" element and the
   /// index of the face to which the element is attached.
   PMLFourierDecomposedHelmholtzFluxElement(
    FiniteElement* const &bulk_el_pt,
    const int& face_index);

   ///\short  Broken empty constructor
   PMLFourierDecomposedHelmholtzFluxElement()
    {
     throw OomphLibError(
      "Don't call empty constructor for PMLFourierDecomposedHelmholtzFluxElement",
      OOMPH_CURRENT_FUNCTION,
      OOMPH_EXCEPTION_LOCATION);
    }

   /// Broken copy constructor
   PMLFourierDecomposedHelmholtzFluxElement(
    const PMLFourierDecomposedHelmholtzFluxElement& dummy)
    {
     BrokenCopy::broken_copy
      ("PMLFourierDecomposedHelmholtzFluxElement");
    }

   /// Broken assignment operator
//Commented out broken assignment operator because this can lead to a conflict warning
//when used in the virtual inheritence hierarchy. Essentially the compiler doesn't
//realise that two separate implementations of the broken function are the same and so,
//quite rightly, it shouts.
   /*void operator=(const PMLFourierDecomposedHelmholtzFluxElement&)
    {
     BrokenCopy::broken_assign
      ("PMLFourierDecomposedHelmholtzFluxElement");
      }*/


   /// Access function for the prescribed-flux function pointer
   PMLFourierDecomposedHelmholtzPrescribedFluxFctPt& flux_fct_pt()
    {return Flux_fct_pt;}


   /// Add the element's contribution to its residual vector
   inline void fill_in_contribution_to_residuals(Vector<double> &residuals)
   {
    //Call the generic residuals function with flag set to 0
    //using a dummy matrix argument
    fill_in_generic_residual_contribution_pml_fourier_decomposed_helmholtz_flux(
     residuals,GeneralisedElement::Dummy_matrix,0);
   }


   /// \short Add the element's contribution to its residual vector and its
   /// Jacobian matrix
   inline void fill_in_contribution_to_jacobian(Vector<double> &residuals,
                                                DenseMatrix<double> &jacobian)
   {
    //Call the generic routine with the flag set to 1
    fill_in_generic_residual_contribution_pml_fourier_decomposed_helmholtz_flux
     (residuals,jacobian,1);
   }

   /// Output function -- forward to broken version in FiniteElement
   /// until somebody decides what exactly they want to plot here...
   void output(std::ostream &outfile) {FiniteElement::output(outfile);}

   /// \short Output function -- forward to broken version in FiniteElement
   /// until somebody decides what exactly they want to plot here...
   void output(std::ostream &outfile, const unsigned &n_plot)
   {FiniteElement::output(outfile,n_plot);}


   /// C-style output function -- forward to broken version in FiniteElement
   /// until somebody decides what exactly they want to plot here...
   void output(FILE* file_pt) {FiniteElement::output(file_pt);}

   /// \short C-style output function -- forward to broken version in
   /// FiniteElement until somebody decides what exactly they want to plot
   /// here...
   void output(FILE* file_pt, const unsigned &n_plot)
   {FiniteElement::output(file_pt,n_plot);}


   /// \short Return the index at which the unknown value
   /// is stored. (Real/imag part gives real index of real/imag part).
   virtual inline std::complex<unsigned>
    u_index_pml_fourier_decomposed_helmholtz() const
    {
     return std::complex<unsigned>(
      U_index_pml_fourier_decomposed_helmholtz.real(),
      U_index_pml_fourier_decomposed_helmholtz.imag());
    }


    protected:

   /// \short Function to compute the shape and test functions and to return
   /// the Jacobian of mapping between local and global (Eulerian)
   /// coordinates
   inline double shape_and_test(const Vector<double> &s, Shape &psi,
                                Shape &test)
    const
   {
    //Find number of nodes
    unsigned n_node = nnode();

    //Get the shape functions
    shape(s,psi);

    //Set the test functions to be the same as the shape functions
    for(unsigned i=0;i<n_node;i++) {test[i] = psi[i];}

    //Return the value of the jacobian
    return J_eulerian(s);
   }


   /// \short Function to compute the shape and test functions and to return
   /// the Jacobian of mapping between local and global (Eulerian)
   /// coordinates
   inline double shape_and_test_at_knot(const unsigned &ipt,
                                        Shape &psi, Shape &test)
    const
   {
    //Find number of nodes
    unsigned n_node = nnode();

    //Get the shape functions
    shape_at_knot(ipt,psi);

   //Set the test functions to be the same as the shape functions
    for(unsigned i=0;i<n_node;i++) {test[i] = psi[i];}

    //Return the value of the jacobian
    return J_eulerian_at_knot(ipt);
   }


 /// Function to calculate the prescribed flux at a given spatial
 /// position
   void get_flux(const Vector<double>& x, std::complex<double>& flux)
   {
    //If the function pointer is zero return zero
    if(Flux_fct_pt == 0)
     {
      flux = std::complex<double>(0.0,0.0);
     }
    //Otherwise call the function
    else
     {
      (*Flux_fct_pt)(x,flux);
     }
   }


   /// \short The index at which the real and imag part of the
   /// unknown is stored at the nodes
   std::complex<unsigned> U_index_pml_fourier_decomposed_helmholtz;


   /// \short Add the element's contribution to its residual vector.
   /// flag=1(or 0): do (or don't) compute the contribution to the
   /// Jacobian as well.
   virtual void
    fill_in_generic_residual_contribution_pml_fourier_decomposed_helmholtz_flux(
     Vector<double> &residuals, DenseMatrix<double> &jacobian,
     const unsigned& flag);


   /// Function pointer to the (global) prescribed-flux function
   PMLFourierDecomposedHelmholtzPrescribedFluxFctPt Flux_fct_pt;

  };

//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////



//===========================================================================
/// Constructor, takes the pointer to the "bulk" element, the
/// index of the fixed local coordinate and its value represented
/// by an integer (+/- 1), indicating that the face is located
/// at the max. or min. value of the "fixed" local coordinate
/// in the bulk element.
//===========================================================================
 template<class ELEMENT>
  PMLFourierDecomposedHelmholtzFluxElement<ELEMENT>::
  PMLFourierDecomposedHelmholtzFluxElement(
   FiniteElement* const &bulk_el_pt,
   const int &face_index) :
  FaceGeometry<ELEMENT>(), FaceElement()
  {
   // Let the bulk element build the FaceElement, i.e. setup the pointers
   // to its nodes (by referring to the appropriate nodes in the bulk
   // element), etc.
   bulk_el_pt->build_face_element(face_index,this);

   // Initialise the prescribed-flux function pointer to zero
   Flux_fct_pt = 0;

   // Initialise index at which real and imag unknowns are stored
   U_index_pml_fourier_decomposed_helmholtz =
    std::complex<unsigned>(0,1);

   // Now read out indices from bulk element
   PMLFourierDecomposedHelmholtzEquationsBase* eqn_pt =
    dynamic_cast<PMLFourierDecomposedHelmholtzEquationsBase*>(bulk_el_pt);
   //If the cast has failed die
   if(eqn_pt==0)
    {
     std::string error_string =
      "Bulk element must inherit from PMLFourierDecomposedHelmholtzEquationsBase.";
     throw OomphLibError(
      error_string,
      OOMPH_CURRENT_FUNCTION,
      OOMPH_EXCEPTION_LOCATION);
    }
   else
    {
     //Read the index from the (cast) bulk element
     U_index_pml_fourier_decomposed_helmholtz =
      eqn_pt->u_index_pml_fourier_decomposed_helmholtz();
    }

  }


//===========================================================================
/// Compute the element's residual vector and the (zero) Jacobian matrix.
//===========================================================================
 template<class ELEMENT>
  void PMLFourierDecomposedHelmholtzFluxElement<ELEMENT>::
  fill_in_generic_residual_contribution_pml_fourier_decomposed_helmholtz_flux(
   Vector<double> &residuals, DenseMatrix<double> &jacobian,
   const unsigned& flag)
  {
   //Find out how many nodes there are3
   const unsigned n_node = nnode();

   //Set up memory for the shape and test functions
   Shape psif(n_node), testf(n_node);

   //Set the value of Nintpt
   const unsigned n_intpt = integral_pt()->nweight();

   //Set the Vector to hold local coordinates
   Vector<double> s(1);

   //Integers to hold the local equation and unknown numbers
   int local_eqn_real=0 ,local_eqn_imag=0;

   //Loop over the integration points
   //--------------------------------
   for(unsigned ipt=0;ipt<n_intpt;ipt++)
    {

     //Assign values of s
     for(unsigned i=0;i<1;i++) {s[i] = integral_pt()->knot(ipt,i);}

     //Get the integral weight
     double w = integral_pt()->weight(ipt);

     //Find the shape and test functions and return the Jacobian
     //of the mapping
     double J = shape_and_test(s,psif,testf);

     //Premultiply the weights and the Jacobian
     double W = w*J;

   //Need to find position to feed into flux function, initialise to zero
     Vector<double> interpolated_x(2,0.0);

     //Calculate coordinates
     for(unsigned l=0;l<n_node;l++)
      {
       //Loop over coordinates
       for(unsigned i=0;i<2;i++)
        {
         interpolated_x[i] += nodal_position(l,i)*psif[l];
        }
      }

     //first component
     double r = interpolated_x[0];

     //Get the imposed flux
     std::complex<double> flux(0.0,0.0);
     get_flux(interpolated_x,flux);

     //Now add to the appropriate equations
     //Loop over the test functions
     for(unsigned l=0;l<n_node;l++)
      {
       local_eqn_real =
        nodal_local_eqn
        (l,U_index_pml_fourier_decomposed_helmholtz.real());

       /*IF it's not a boundary condition*/
       if(local_eqn_real >= 0)
        {
         //Add the prescribed flux terms
         residuals[local_eqn_real] -= flux.real()*testf[l]*r*W;

         // Imposed traction doesn't depend upon the solution,
         // --> the Jacobian is always zero, so no Jacobian
         // terms are required
        }
       local_eqn_imag =
        nodal_local_eqn
        (l,U_index_pml_fourier_decomposed_helmholtz.imag());

       /*IF it's not a boundary condition*/
       if(local_eqn_imag >= 0)
        {
         //Add the prescribed flux terms
         residuals[local_eqn_imag] -= flux.imag()*testf[l]*r*W;

         // Imposed traction doesn't depend upon the solution,
         // --> the Jacobian is always zero, so no Jacobian
         // terms are required
        }
      }
    }
  }




/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////


//======================================================================
/// \short A class for elements that allow postprocessing of the
/// results -- currently computes radiated power over domain
/// boundaries.
/// The element geometry is obtained from the  FaceGeometry<ELEMENT>
/// policy class.
//======================================================================
template <class ELEMENT>
 class PMLFourierDecomposedHelmholtzPowerMonitorElement :
public virtual FaceGeometry<ELEMENT>,
 public virtual FaceElement
 {
   public:

  /// \short Constructor, takes the pointer to the "bulk" element and the
  /// index of the face to which the element is attached.
  PMLFourierDecomposedHelmholtzPowerMonitorElement
   (FiniteElement* const &bulk_el_pt,
    const int& face_index);

  ///\short Broken empty constructor
  PMLFourierDecomposedHelmholtzPowerMonitorElement()
   {
    throw OomphLibError(
     "Don't call empty constructor for PMLFourierDecomposedHelmholtzPowerMonitorElement",
     OOMPH_CURRENT_FUNCTION,
     OOMPH_EXCEPTION_LOCATION);
   }

  /// Broken copy constructor
  PMLFourierDecomposedHelmholtzPowerMonitorElement
   (const PMLFourierDecomposedHelmholtzPowerMonitorElement& dummy)
   {
    BrokenCopy::broken_copy
     ("PMLFourierDecomposedHelmholtzPowerMonitorElement");
   }

  /// Broken assignment operator
  /*void operator=(const PMLFourierDecomposedHelmholtzPowerMonitorElement&)
   {
    BrokenCopy::broken_assign
     ("PMLFourierDecomposedHelmholtzPowerMonitorElement");
     }*/


  /// \short Specify the value of nodal zeta from the face geometry
  /// The "global" intrinsic coordinate of the element when
  /// viewed as part of a geometric object should be given by
  /// the FaceElement representation, by default (needed to break
  /// indeterminacy if bulk element is SolidElement)
  double zeta_nodal(const unsigned &n, const unsigned &k,
                    const unsigned &i) const
  {return FaceElement::zeta_nodal(n,k,i);}


  /// Output function -- forward to broken version in FiniteElement
  /// until somebody decides what exactly they want to plot here...
  void output(std::ostream &outfile) {FiniteElement::output(outfile);}

  /// \short Output function -- forward to broken version in FiniteElement
  /// until somebody decides what exactly they want to plot here...
  void output(std::ostream &outfile, const unsigned &n_plot)
  {FiniteElement::output(outfile,n_plot);}

  /// C-style output function -- forward to broken version in FiniteElement
  /// until somebody decides what exactly they want to plot here...
  void output(FILE* file_pt) {FiniteElement::output(file_pt);}

  /// \short C-style output function -- forward to broken version in
  /// FiniteElement until somebody decides what exactly they want to plot
  /// here...
  void output(FILE* file_pt, const unsigned &n_plot)
  {FiniteElement::output(file_pt,n_plot);}

  /// \short Return the index at which the real/imag unknown value
  /// is stored.
  virtual inline std::complex<unsigned>
   u_index_pml_fourier_decomposed_helmholtz()
   const
   {
    return std::complex<unsigned>(
     U_index_pml_fourier_decomposed_helmholtz.real(),
     U_index_pml_fourier_decomposed_helmholtz.imag());
   }

  /// \short Compute the element's contribution to the time-averaged
  /// radiated power over the artificial boundary.
  /// NOTE: This may give the wrong result
  /// if the constitutive parameters genuinely vary!
  double global_power_contribution()
  {
   // Dummy output file
   std::ofstream outfile;
   return global_power_contribution(outfile);
  }

  /// \short Compute the element's contribution to the time-averaged
  /// radiated power over the artificial boundary. Also output the
  /// power density as a fct of the zenith angle in the specified
  /// output file if it's open. NOTE: This may give the wrong result
  /// if the constitutive parameters genuinely vary!
  double global_power_contribution(std::ofstream& outfile)
  {
   // pointer to the corresponding bulk element
   ELEMENT* bulk_elem_pt = dynamic_cast<ELEMENT*>(this->bulk_element_pt());

   // Number of nodes in bulk element
   unsigned nnode_bulk=bulk_elem_pt->nnode();
   const unsigned n_node_local = this->nnode();

   //get the dim of the bulk and local nodes
   const unsigned bulk_dim= bulk_elem_pt->dim();
   const unsigned local_dim= this->node_pt(0)->ndim();

   //Set up memory for the shape and test functions
   Shape psi(n_node_local);

   //Set up memory for the shape functions
   Shape psi_bulk(nnode_bulk);
   DShape dpsi_bulk_dx(nnode_bulk,bulk_dim);

   //Set up memory for the outer unit normal
   Vector< double > unit_normal(bulk_dim);

   //Set the value of n_intpt
   const unsigned n_intpt = integral_pt()->nweight();

   //Set the Vector to hold local coordinates
   Vector<double> s(local_dim-1);
   double power=0.0;

   // Output?
   if (outfile.is_open())
    {
     outfile << "ZONE\n";
    }

   //Loop over the integration points
   //--------------------------------
   for(unsigned ipt=0;ipt<n_intpt;ipt++)
    {
     //Assign values of s
     for(unsigned i=0;i<(local_dim-1);i++)
      {
       s[i] = integral_pt()->knot(ipt,i);
      }
     //get the outer_unit_ext vector
     this->outer_unit_normal(s,unit_normal);

     //Get the integral weight
     double w = integral_pt()->weight(ipt);

     // Get jacobian of mapping
     double J=J_eulerian(s);

     //Premultiply the weights and the Jacobian
     double W = w*J;

     // Get local coordinates in bulk element by copy construction
     Vector<double> s_bulk(local_coordinate_in_bulk(s));

     //Call the derivatives of the shape  functions
     //in the bulk -- must do this via s because this point
     //is not an integration point the bulk element!
     (void)bulk_elem_pt->dshape_eulerian(s_bulk,psi_bulk,dpsi_bulk_dx);
     this->shape(s,psi);

     // Derivs of Eulerian coordinates w.r.t. local coordinates
     std::complex<double>  dphi_dn(0.0,0.0);
     Vector<std::complex <double> > interpolated_dphidx(bulk_dim);
     std::complex<double> interpolated_phi(0.0,0.0);
     Vector<double> x(bulk_dim);

     //Calculate function value and derivatives:
     //-----------------------------------------
     // Loop over nodes
     for(unsigned l=0;l<nnode_bulk;l++)
      {
       //Get the nodal value of the helmholtz unknown
       const std::complex<double> phi_value(
        bulk_elem_pt->nodal_value(
         l,bulk_elem_pt->
         u_index_pml_fourier_decomposed_helmholtz().real()),
        bulk_elem_pt->nodal_value(
         l,bulk_elem_pt->
         u_index_pml_fourier_decomposed_helmholtz().imag())
        );

       //Loop over directions
       for(unsigned i=0;i<bulk_dim;i++)
        {
         interpolated_dphidx[i] += phi_value*dpsi_bulk_dx(l,i);
        }
      } // End of loop over the bulk_nodes

     for(unsigned l=0;l<n_node_local;l++)
      {
       //Get the nodal value of the Helmholtz unknown
       const std::complex<double> phi_value(
        nodal_value
        (l,u_index_pml_fourier_decomposed_helmholtz().real()),
        nodal_value
        (l,u_index_pml_fourier_decomposed_helmholtz().imag()));

       interpolated_phi += phi_value*psi(l);
      }

     //define dphi_dn
     for(unsigned i=0;i<bulk_dim;i++)
      {
       dphi_dn += interpolated_dphidx[i]*unit_normal[i];
      }

     // Power density
     double integrand=
      (interpolated_phi.real()*dphi_dn.imag()-
       interpolated_phi.imag()*dphi_dn.real());

     interpolated_x(s,x);
     double theta=atan2(x[0],x[1]);
     // Output?
     if (outfile.is_open())
      {
       outfile << x[0] << " "
               << x[1] << " "
               << theta << " "
               << integrand << "\n";
      }

     // ...add to integral
     power+=MathematicalConstants::Pi*x[0]*integrand*W;
    }

   return  power;
  }

   protected:

  /// \short Function to compute the test functions and to return
  /// the Jacobian of mapping between local and global (Eulerian)
  /// coordinates
  inline double shape_and_test(const Vector<double> &s,
                               Shape& psi, Shape &test) const
  {
   //Get the shape functions
   shape(s,test);

   unsigned nnod=nnode();
   for (unsigned i=0;i<nnod;i++)
    {
     psi[i]=test[i];
    }

   //Return the value of the jacobian
   return J_eulerian(s);
  }

  /// \short Function to compute the shape, test functions and derivates
  /// and to return
  /// the Jacobian of mapping between local and global (Eulerian)
  /// coordinates
  inline double d_shape_and_test_local(const Vector<double> &s, Shape &psi,
                                       Shape &test,
                                       DShape &dpsi_ds,DShape &dtest_ds)
   const
  {
   //Find number of nodes
   unsigned n_node = nnode();

   //Get the shape functions
   dshape_local(s,psi,dpsi_ds);

   //Set the test functions to be the same as the shape functions
   for(unsigned i=0;i<n_node;i++)
    {
     for(unsigned j=0;j<1;j++)
      {
       test[i] = psi[i];
       dtest_ds(i,j)= dpsi_ds(i,j);
      }
    }
   //Return the value of the jacobian
   return J_eulerian(s);
  }

  /// \short The index at which the real and imag part of the unknown
  /// is stored  at the nodes
  std::complex<unsigned> U_index_pml_fourier_decomposed_helmholtz;

 };


//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////


//===========================================================================
/// Constructor, takes the pointer to the "bulk" element and the face index.
//===========================================================================
template<class ELEMENT>
PMLFourierDecomposedHelmholtzPowerMonitorElement<ELEMENT>::
PMLFourierDecomposedHelmholtzPowerMonitorElement
 (FiniteElement* const &bulk_el_pt,
  const int &face_index) :
  FaceGeometry<ELEMENT>(), FaceElement()
  {
   // Let the bulk element build the FaceElement, i.e. setup the pointers
   // to its nodes (by referring to the appropriate nodes in the bulk
   // element), etc.
   bulk_el_pt->build_face_element(face_index,this);

   //Set up U_index_pml_fourier_decomposedhelmholtz.
   U_index_pml_fourier_decomposed_helmholtz =
    std::complex<unsigned>(0,1);

   // Cast to the appropriate PMLFourierDecomposedHelmholtzEquation
   // so that we can find the index at which the variable is stored
   // We assume that the dimension of the full problem is the same
   // as the dimension of the node, if this is not the case you will have
   // to write custom elements, sorry
   PMLFourierDecomposedHelmholtzEquationsBase* eqn_pt =
   dynamic_cast<PMLFourierDecomposedHelmholtzEquationsBase*>(bulk_el_pt);
  if(eqn_pt==0)
   {
    std::string error_string =
     "Bulk element must inherit from PMLFourierDecomposedHelmholtzEquationsBase.";
    throw OomphLibError(
     error_string,
     OOMPH_CURRENT_FUNCTION,
     OOMPH_EXCEPTION_LOCATION);
   }
  //Otherwise read out the value
  else
   {
    //Read the index from the (cast) bulk element
    U_index_pml_fourier_decomposed_helmholtz =
     eqn_pt->u_index_pml_fourier_decomposed_helmholtz();
   }
 }

}

#endif