GeometricCutUserObject.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
 
// MOOSE includes
#include "CrackFrontPointsProvider.h"
#include "XFEMAppTypes.h"
#include "SolidMechanicsAppTypes.h"
 
#include "libmesh/libmesh_common.h"
#include "libmesh/libmesh.h" // libMesh::invalid_uint
#include "libmesh/elem.h"
 
class XFEM;
 
namespace Xfem
{
struct CutEdge
{
  unsigned int _id1;
  unsigned int _id2;
  Real _distance;
  unsigned int _host_side_id;
};
 
inline bool
operator<(const CutEdge & lhs, const CutEdge & rhs)
{
  if (lhs._id1 != rhs._id1)
    return lhs._id1 < rhs._id1;
  else
    return lhs._id2 < rhs._id2;
}
 
struct CutNode
{
  unsigned int _id;
  unsigned int _host_id;
};
 
struct CutFace
{
  unsigned int _face_id;
  std::vector<unsigned int> _face_edge;
  std::vector<Real> _position;
};
 
struct GeomMarkedElemInfo2D
{
  std::vector<CutEdge> _elem_cut_edges;
  std::vector<CutNode> _elem_cut_nodes;
  std::vector<CutEdge> _frag_cut_edges;
  std::vector<std::vector<Point>> _frag_edges;
};
 
struct GeomMarkedElemInfo3D
{
  std::vector<CutFace> _elem_cut_faces;
  std::vector<CutFace> _frag_cut_faces;
  std::vector<std::vector<Point>> _frag_faces;
};
 
} // namespace Xfem
 
class GeometricCutUserObject : public CrackFrontPointsProvider
{
public:
  static InputParameters validParams();
 
  GeometricCutUserObject(const InputParameters & parameters, const bool uses_mesh = false);
 
  virtual void initialize() override;
  virtual void execute() override;
  virtual void threadJoin(const UserObject & y) override;
  virtual void finalize() override;
 
  virtual unsigned int getNumberOfCrackFrontPoints() const override
  {
    mooseError("getNumberOfCrackFrontPoints() is not implemented for this object.");
  }
 
  virtual bool cutElementByGeometry(const Elem * elem,
                                    std::vector<Xfem::CutEdge> & cut_edges,
                                    std::vector<Xfem::CutNode> & cut_nodes) const = 0;
 
  virtual bool cutElementByGeometry(const Elem * elem,
                                    std::vector<Xfem::CutFace> & cut_faces) const = 0;
 
  virtual bool cutFragmentByGeometry(std::vector<std::vector<Point>> & frag_edges,
                                     std::vector<Xfem::CutEdge> & cut_edges) const = 0;
 
  virtual bool cutFragmentByGeometry(std::vector<std::vector<Point>> & frag_faces,
                                     std::vector<Xfem::CutFace> & cut_faces) const = 0;
 
  unsigned int getInterfaceID() const { return _interface_id; };
 
  void setInterfaceID(unsigned int interface_id) { _interface_id = interface_id; };
 
  bool shouldHealMesh() const { return _heal_always; };
 
  virtual CutSubdomainID getCutSubdomainID(const Node * /*node*/) const
  {
    mooseError("Objects that inherit from GeometricCutUserObject should override the "
               "getCutSubdomainID method");
    return 0;
  }
 
  CutSubdomainID getCutSubdomainID(const Elem * elem) const;
 
protected:
  std::shared_ptr<XFEM> _xfem;
 
  unsigned int _interface_id;
 
  bool _heal_always;
 
  int _last_step_initialized;
 
  std::map<unsigned int, std::vector<Xfem::GeomMarkedElemInfo2D>> _marked_elems_2d;
  std::map<unsigned int, std::vector<Xfem::GeomMarkedElemInfo3D>> _marked_elems_3d;
 
  void serialize(std::string & serialized_buffer);
  void deserialize(std::vector<std::string> & serialized_buffers);
};