fe_abstract.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2014 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner

// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA



#ifndef LIBMESH_FE_ABSTRACT_H
#define LIBMESH_FE_ABSTRACT_H

// Local includes
#include "libmesh/reference_counted_object.h"
#include "libmesh/point.h"
#include "libmesh/vector_value.h"
#include "libmesh/enum_elem_type.h"
#include "libmesh/fe_type.h"
#include "libmesh/auto_ptr.h"
#include "libmesh/fe_map.h"

// C++ includes
#include <cstddef>
#include <vector>

#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
#include "libmesh/tensor_value.h"
#endif

namespace libMesh
{


// forward declarations
template <typename T> class DenseMatrix;
template <typename T> class DenseVector;
class BoundaryInfo;
class DofConstraints;
class DofMap;
class Elem;
class MeshBase;
template <typename T> class NumericVector;
class QBase;

#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
class NodeConstraints;
#endif

#ifdef LIBMESH_ENABLE_PERIODIC
class PeriodicBoundaries;
class PointLocatorBase;
#endif

#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
template <unsigned int Dim, FEFamily T_radial, InfMapType T_map>
class InfFE;
#endif



// ------------------------------------------------------------
// FEAbstract class definition
class FEAbstract : public ReferenceCountedObject<FEAbstract>
{
protected:

  FEAbstract (const unsigned int dim,
              const FEType& fet);

public:

  virtual ~FEAbstract();

  static UniquePtr<FEAbstract> build (const unsigned int dim,
                                      const FEType& type);

  virtual void reinit (const Elem* elem,
                       const std::vector<Point>* const pts = NULL,
                       const std::vector<Real>* const weights = NULL) = 0;

  virtual void reinit (const Elem* elem,
                       const unsigned int side,
                       const Real tolerance = TOLERANCE,
                       const std::vector<Point>* const pts = NULL,
                       const std::vector<Real>* const weights = NULL) = 0;

  virtual void edge_reinit (const Elem* elem,
                            const unsigned int edge,
                            const Real tolerance = TOLERANCE,
                            const std::vector<Point>* pts = NULL,
                            const std::vector<Real>* weights = NULL) = 0;

  virtual void side_map (const Elem* elem,
                         const Elem* side,
                         const unsigned int s,
                         const std::vector<Point>& reference_side_points,
                         std::vector<Point>&       reference_points) = 0;

  static bool on_reference_element(const Point& p,
                                   const ElemType t,
                                   const Real eps = TOLERANCE);
  static void get_refspace_nodes(const ElemType t,
                                 std::vector<Point>& nodes);


#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS

  static void compute_node_constraints (NodeConstraints &constraints,
                                        const Elem* elem);
#endif // LIBMESH_ENABLE_NODE_CONSTRAINTS

#ifdef LIBMESH_ENABLE_PERIODIC

#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS

  static void compute_periodic_node_constraints (NodeConstraints &constraints,
                                                 const PeriodicBoundaries &boundaries,
                                                 const MeshBase& mesh,
                                                 const PointLocatorBase* point_locator,
                                                 const Elem* elem);
#endif // LIBMESH_ENABLE_NODE_CONSTRAINTS

#endif // LIBMESH_ENABLE_PERIODIC

  const std::vector<Point>& get_xyz() const
  { return this->_fe_map->get_xyz(); }

  const std::vector<Real>& get_JxW() const
  { return this->_fe_map->get_JxW(); }

  const std::vector<RealGradient>& get_dxyzdxi() const
  { return this->_fe_map->get_dxyzdxi(); }

  const std::vector<RealGradient>& get_dxyzdeta() const
  { return this->_fe_map->get_dxyzdeta(); }

  const std::vector<RealGradient>& get_dxyzdzeta() const
  { return _fe_map->get_dxyzdzeta(); }

  const std::vector<RealGradient>& get_d2xyzdxi2() const
  { return this->_fe_map->get_d2xyzdxi2(); }

  const std::vector<RealGradient>& get_d2xyzdeta2() const
  { return this->_fe_map->get_d2xyzdeta2(); }

#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES

  const std::vector<RealGradient>& get_d2xyzdzeta2() const
  { return this->_fe_map->get_d2xyzdzeta2(); }

#endif

  const std::vector<RealGradient>& get_d2xyzdxideta() const
  { return this->_fe_map->get_d2xyzdxideta(); }

#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES

  const std::vector<RealGradient>& get_d2xyzdxidzeta() const
  { return this->_fe_map->get_d2xyzdxidzeta(); }

  const std::vector<RealGradient>& get_d2xyzdetadzeta() const
  { return this->_fe_map->get_d2xyzdetadzeta(); }

#endif

  const std::vector<Real>& get_dxidx() const
  { return this->_fe_map->get_dxidx(); }

  const std::vector<Real>& get_dxidy() const
  { return this->_fe_map->get_dxidy(); }

  const std::vector<Real>& get_dxidz() const
  { return this->_fe_map->get_dxidz(); }

  const std::vector<Real>& get_detadx() const
  { return this->_fe_map->get_detadx(); }

  const std::vector<Real>& get_detady() const
  { return this->_fe_map->get_detady(); }

  const std::vector<Real>& get_detadz() const
  { return this->_fe_map->get_detadz(); }

  const std::vector<Real>& get_dzetadx() const
  { return this->_fe_map->get_dzetadx(); }

  const std::vector<Real>& get_dzetady() const
  { return this->_fe_map->get_dzetady(); }

  const std::vector<Real>& get_dzetadz() const
  { return this->_fe_map->get_dzetadz(); }

  const std::vector<std::vector<Point> >& get_tangents() const
  { return this->_fe_map->get_tangents(); }

  const std::vector<Point>& get_normals() const
  { return this->_fe_map->get_normals(); }

  const std::vector<Real>& get_curvatures() const
  { return this->_fe_map->get_curvatures();}

  virtual void attach_quadrature_rule (QBase* q) = 0;

  virtual unsigned int n_shape_functions () const = 0;

  virtual unsigned int n_quadrature_points () const = 0;

  ElemType get_type()  const { return elem_type; }

  unsigned int get_p_level() const { return _p_level; }

  FEType get_fe_type()  const { return fe_type; }

  Order get_order()  const { return static_cast<Order>(fe_type.order + _p_level); }

  virtual FEContinuity get_continuity() const = 0;

  virtual bool is_hierarchic() const = 0;

  FEFamily get_family()  const { return fe_type.family; }

  const FEMap& get_fe_map() const { return *_fe_map.get(); }

  void print_JxW(std::ostream& os) const;

  virtual void print_phi(std::ostream& os) const =0;

  virtual void print_dphi(std::ostream& os) const =0;

#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES

  virtual void print_d2phi(std::ostream& os) const =0;

#endif

  void print_xyz(std::ostream& os) const;

  void print_info(std::ostream& os) const;

  friend std::ostream& operator << (std::ostream& os, const FEAbstract& fe);


protected:

  virtual void compute_shape_functions(const Elem*, const std::vector<Point>& ) =0;

  UniquePtr<FEMap> _fe_map;


  const unsigned int dim;

  mutable bool calculations_started;

  mutable bool calculate_phi;

  mutable bool calculate_dphi;

  mutable bool calculate_d2phi;

  mutable bool calculate_curl_phi;

  mutable bool calculate_div_phi;

  mutable bool calculate_dphiref;


  const FEType fe_type;

  ElemType elem_type;

  unsigned int _p_level;

  QBase* qrule;

  bool shapes_on_quadrature;

  virtual bool shapes_need_reinit() const = 0;

};




// ------------------------------------------------------------
// FEAbstract class inline members
inline
FEAbstract::FEAbstract(const unsigned int d,
                       const FEType& fet) :
  _fe_map( FEMap::build(fet) ),
  dim(d),
  calculations_started(false),
  calculate_phi(false),
  calculate_dphi(false),
  calculate_d2phi(false),
  calculate_curl_phi(false),
  calculate_div_phi(false),
  calculate_dphiref(false),
  fe_type(fet),
  elem_type(INVALID_ELEM),
  _p_level(0),
  qrule(NULL),
  shapes_on_quadrature(false)
{
}


inline
FEAbstract::~FEAbstract()
{
}

} // namespace libMesh

#endif // LIBMESH_FE_ABSTRACT_H