boundaryFace.hh

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                                                           */
/*  This file is part of the library KASKADE 7                               */
/*  https://www.zib.de/research/projects/kaskade7-finite-element-toolbox     */
/*                                                                           */
/*  Copyright (C) 2020-2023 Zuse Institute Berlin                            */
/*                                                                           */
/*  KASKADE 7 is distributed under the terms of the ZIB Academic License.    */
/*    see $KASKADE/academic.txt                                              */
/*                                                                           */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
#ifndef BOUNDARYFACE_HH
#define BOUNDARYFACE_HH
 
#include <memory>
#include <optional>
#include <utility>
 
#include "dune/common/fvector.hh"
#include "dune/geometry/type.hh"
 
 
namespace Kaskade
{
  template <class Grid, class Face, class Displacement, int dimw=Face::dimensionworld>
  class BoundaryFace
  {
  public:
    static int const facedimension = Face::mydimension;
    static int const celldimension = Grid::dimension;
    static int const griddimension = Face::dimensionworld;
    static int const worlddimension = dimw;
 
    using ctype = typename Face::ctype;
    using Cell = typename Grid::Codim<0>::Entity;
 
  private:
    enum Kind { VOLUMEMESH, SURFACEMESH, PLANARMESH };
    static Kind const kind = facedimension==celldimension-1? VOLUMEMESH
                           : griddimension==worlddimension?  SURFACEMESH
                           :                                 PLANARMESH;
 
    using PositionExtension = Dune::FieldVector<ctype,worlddimension-celldimension>;
 
  public:
    using LocalPosition = Dune::FieldVector<ctype,facedimension>;
 
    using GlobalPosition = Dune::FieldVector<ctype,worlddimension>;
 
    using CellLocalPosition = Dune::FieldVector<ctype,celldimension>;
 
    using CellGlobalPosition = Dune::FieldVector<ctype,griddimension>;
 
    BoundaryFace(Face const& f, Displacement const* d = nullptr);
 
    ~BoundaryFace();
 
    Face const& gridFace() const
    {
      return *face;
    }
 
    std::pair<GlobalPosition,GlobalPosition> boundingBox() const;
 
    Dune::GeometryType type() const
    {
      return gt;
    }
 
    ctype volume() const
    {
      return vol;
    }
 
    GlobalPosition global(LocalPosition const& xi) const;
 
 
    GlobalPosition unitOuterNormal(LocalPosition const& xi) const;
 
    std::optional<std::pair<LocalPosition,ctype>> intersection(GlobalPosition const& a,
                                                               GlobalPosition const& b) const;
 
 
  private:
    // In planar meshes, the grid-global coordinates as returned by mesh functions are "too short".
    // We extend the missing entries by the given values in z.
    static GlobalPosition extend(CellGlobalPosition const& x,
                                 PositionExtension const& z);
 
    // Get the cell corresponding to the face. In surface and embedded meshes, this is
    // the face itself.
    Cell cell() const;
 
    GlobalPosition globalUncached(LocalPosition const& xi) const;
    GlobalPosition unitOuterNormalUncached(LocalPosition const& xi) const;
 
 
    using DeformationJacobian = Dune::FieldMatrix<ctype,worlddimension,facedimension>;
    using GridJacobian = Dune::FieldMatrix<ctype,griddimension,facedimension>;
 
    // Compute the Jacobian of the deformation at given local position.
    std::pair<DeformationJacobian,GridJacobian> jacobians(LocalPosition const& xi) const;
    std::pair<DeformationJacobian,GridJacobian> jacobiansUncached(LocalPosition const& xi) const;
 
    std::shared_ptr<Face> face;
    Dune::GeometryType gt;    // geometry type
    bool faceAffine;
 
    Displacement const* disp;
    bool displacementAffine;
    ctype vol;                // deformed face's area
 
    // Precomputed (because of being constant) values in case of affine displacement and affine face
    // (implying that the deformed face is affine).
    DeformationJacobian deformationJacobian;    // grid -> world
    GridJacobian gridJacobian;                  // reference -> grid
    GlobalPosition origin;                      // world position of reference origin
    GlobalPosition normal;
  };
 
  // ----------------------------------------------------------------------------------------------
}
 
 
#endif