GeometricCutUserObject.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* 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 "libmesh/libmesh_common.h"
#include "libmesh/libmesh.h" // libMesh::invalid_uint
#include "libmesh/elem.h"
 
using namespace libMesh;
 
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
 
// Forward declarations
class GeometricCutUserObject;
 
template <>
InputParameters validParams<GeometricCutUserObject>();
 
class GeometricCutUserObject : public CrackFrontPointsProvider
{
public:
  GeometricCutUserObject(const InputParameters & parameters);
 
  virtual void initialize() override;
  virtual void execute() override;
  virtual void threadJoin(const UserObject & y) override;
  virtual void finalize() override;
 
  virtual bool cutElementByGeometry(const Elem * elem,
                                    std::vector<Xfem::CutEdge> & cut_edges,
                                    std::vector<Xfem::CutNode> & cut_nodes,
                                    Real time) const = 0;
 
  virtual bool cutElementByGeometry(const Elem * elem,
                                    std::vector<Xfem::CutFace> & cut_faces,
                                    Real time) const = 0;
 
  virtual bool cutFragmentByGeometry(std::vector<std::vector<Point>> & frag_edges,
                                     std::vector<Xfem::CutEdge> & cut_edges,
                                     Real time) const = 0;
 
  virtual bool cutFragmentByGeometry(std::vector<std::vector<Point>> & frag_faces,
                                     std::vector<Xfem::CutFace> & cut_faces,
                                     Real time) 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; };
 
protected:
  std::shared_ptr<XFEM> _xfem;
 
  unsigned int _interface_id;
 
  bool _heal_always;
 
  unsigned 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);
};