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 "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

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 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);
};