flux_transport_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-2022 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 flux transport elements base class
 
#ifndef OOMPH_FLUX_TRANSPORT_ELEMENTS_HEADER
#define OOMPH_FLUX_TRANSPORT_ELEMENTS_HEADER
 
// Config header generated by autoconfig
#ifdef HAVE_CONFIG_H
#include <oomph-lib-config.h>
#endif
 
#include "../generic/elements.h"
 
 
namespace oomph
{
  //==================================================================
  //==================================================================
  template<unsigned DIM>
  class FluxTransportEquations : public virtual FiniteElement
  {
  protected:
    virtual inline unsigned nflux() const
    {
      return 0;
    }
 
    virtual inline unsigned u_index_flux_transport(const unsigned& i) const
    {
      return i;
    }
 
    virtual void flux(const Vector<double>& u, DenseMatrix<double>& f)
    {
      std::ostringstream error_stream;
      error_stream
        << "Default empty flux function called\n"
        << "This should be overloaded with a specific flux function\n"
        << "in a derived class\n";
      throw OomphLibError(
        error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
 
    virtual void dflux_du(const Vector<double>& u,
                          RankThreeTensor<double>& df_du);
 
    virtual double dshape_and_dtest_eulerian_flux_transport(
      const Vector<double>& s,
      Shape& psi,
      DShape& dpsidx,
      Shape& test,
      DShape& dtestdx) const = 0;
 
    virtual double dshape_and_dtest_eulerian_at_knot_flux_transport(
      const unsigned& ipt,
      Shape& psi,
      DShape& dpsidx,
      Shape& test,
      DShape& dtestdx) const = 0;
 
 
  public:
    FluxTransportEquations() : FiniteElement() {}
 
    virtual ~FluxTransportEquations() {}
 
    void fill_in_contribution_to_residuals(Vector<double>& residuals)
    {
      // Call the generic residuals function with flag set to 0
      // and using a dummy matrix argument
      fill_in_generic_residual_contribution_flux_transport(
        residuals,
        GeneralisedElement::Dummy_matrix,
        GeneralisedElement::Dummy_matrix,
        0);
    }
 
    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_flux_transport(
        residuals, jacobian, GeneralisedElement::Dummy_matrix, 1);
    }
 
    void fill_in_contribution_to_jacobian_and_mass_matrix(
      Vector<double>& residuals,
      DenseMatrix<double>& jacobian,
      DenseMatrix<double>& mass_matrix)
    {
      // Call the generic routine with the flag set to 2
      fill_in_generic_residual_contribution_flux_transport(
        residuals, jacobian, mass_matrix, 2);
    }
 
    void fill_in_contribution_to_mass_matrix(Vector<double>& residuals,
                                             DenseMatrix<double>& mass_matrix)
    {
      fill_in_generic_residual_contribution_flux_transport(
        residuals, GeneralisedElement::Dummy_matrix, mass_matrix, 3);
    }
 
 
    virtual void fill_in_generic_residual_contribution_flux_transport(
      Vector<double>& residuals,
      DenseMatrix<double>& jacobian,
      DenseMatrix<double>& mass_matrix,
      unsigned flag);
 
    // Get the value of the unknowns
    double interpolated_u_flux_transport(const Vector<double>& s,
                                         const unsigned& i);
 
    double du_dt_flux_transport(const unsigned& n, const unsigned& i) const;
 
    void calculate_element_averages(double*& average_values);
 
    // Default output function
    void output(std::ostream& outfile)
    {
      unsigned nplot = 5;
      output(outfile, nplot);
    }
 
    void output(std::ostream& outfile, const unsigned& nplot);
  };
 
} // namespace oomph
 
#endif