XFEMCutElem.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include <vector>
 
#include "MooseTypes.h"
#include "XFEM.h"
 
using namespace libMesh;
 
namespace libMesh
{
class MeshBase;
class Elem;
class Node;
class QBase;
}
class EFANode;
class EFAElement;
 
class XFEMCutElem
{
public:
  XFEMCutElem(Elem * elem, unsigned int n_qpoints, unsigned int n_sides);
  virtual ~XFEMCutElem();
 
protected:
  unsigned int _n_nodes;
  unsigned int _n_qpoints;
  unsigned int _n_sides;
  std::vector<Node *> _nodes;
  std::vector<Point> _qp_points;
  std::vector<Real> _qp_weights;
  Real _elem_volume;
  std::vector<Real> _elem_side_area;
  Real _physical_volfrac;
  std::vector<Real> _physical_areafrac;
  bool _have_weights;
  std::vector<bool> _have_face_weights;
  std::vector<Real> _new_weights;
  std::vector<std::vector<Real>> _new_face_weights;
  virtual Point getNodeCoordinates(EFANode * node, MeshBase * displaced_mesh = nullptr) const = 0;
 
public:
  void setQuadraturePointsAndWeights(const std::vector<Point> & qp_points,
                                     const std::vector<Real> & qp_weights);
  virtual void computePhysicalVolumeFraction() = 0;
 
  Real getPhysicalVolumeFraction() const;
 
  virtual void computePhysicalFaceAreaFraction(unsigned int side) = 0;
 
  Real getPhysicalFaceAreaFraction(unsigned int side) const;
 
  virtual void computeMomentFittingWeights() = 0;
  Real getMomentFittingWeight(unsigned int i_qp) const;
  virtual Point getCutPlaneOrigin(unsigned int plane_id,
                                  MeshBase * displaced_mesh = nullptr) const = 0;
  virtual Point getCutPlaneNormal(unsigned int plane_id,
                                  MeshBase * displaced_mesh = nullptr) const = 0;
  virtual void
  getCrackTipOriginAndDirection(unsigned tip_id, Point & origin, Point & direction) const = 0;
  virtual void getFragmentFaces(std::vector<std::vector<Point>> & frag_faces,
                                MeshBase * displaced_mesh = nullptr) const = 0;
  virtual const EFAElement * getEFAElement() const = 0;
  virtual unsigned int numCutPlanes() const = 0;
  void getWeightMultipliers(MooseArray<Real> & weights,
                            QBase * qrule,
                            Xfem::XFEM_QRULE xfem_qrule,
                            const MooseArray<Point> & q_points);
  void getFaceWeightMultipliers(MooseArray<Real> & face_weights,
                                QBase * qrule,
                                Xfem::XFEM_QRULE xfem_qrule,
                                const MooseArray<Point> & q_points,
                                unsigned int side);
 
  void computeXFEMWeights(QBase * qrule,
                          Xfem::XFEM_QRULE xfem_qrule,
                          const MooseArray<Point> & q_points);
 
  void computeXFEMFaceWeights(QBase * qrule,
                              Xfem::XFEM_QRULE xfem_qrule,
                              const MooseArray<Point> & q_points,
                              unsigned int side);
  bool isPointPhysical(const Point & p) const;
  virtual void getIntersectionInfo(unsigned int plane_id,
                                   Point & normal,
                                   std::vector<Point> & intersectionPoints,
                                   MeshBase * displaced_mesh = nullptr) const = 0;
};