CrackMeshCut3DUserObject.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 "MeshCutUserObjectBase.h"
#include "CrackFrontDefinition.h"
 
#include <array>
 
class Function;
 
class CrackMeshCut3DUserObject : public MeshCutUserObjectBase
{
public:
  static InputParameters validParams();
 
  CrackMeshCut3DUserObject(const InputParameters & parameters);
 
  virtual void initialSetup() override;
  virtual void initialize() override;
 
  virtual const std::vector<Point>
  getCrackFrontPoints(unsigned int num_crack_front_points) const override;
  virtual const std::vector<RealVectorValue>
  getCrackPlaneNormals(unsigned int num_crack_front_points) const override;
 
  virtual bool cutElementByGeometry(const Elem * elem,
                                    std::vector<Xfem::CutEdge> & cut_edges,
                                    std::vector<Xfem::CutNode> & cut_nodes) const override;
  virtual bool cutElementByGeometry(const Elem * elem,
                                    std::vector<Xfem::CutFace> & cut_faces) const override;
  virtual bool cutFragmentByGeometry(std::vector<std::vector<Point>> & frag_edges,
                                     std::vector<Xfem::CutEdge> & cut_edges) const override;
  virtual bool cutFragmentByGeometry(std::vector<std::vector<Point>> & frag_faces,
                                     std::vector<Xfem::CutFace> & cut_faces) const override;
 
  void findActiveBoundaryNodes();
 
  std::vector<int> getFrontPointsIndex() const;
 
  virtual unsigned int getNumberOfCrackFrontPoints() const override;
 
protected:
  const unsigned int _cut_elem_nnode = 3;
  const unsigned int _cut_elem_dim = 2;
 
  MooseMesh & _mesh;
 
  CrackFrontDefinition * _crack_front_definition;
 
  std::vector<dof_id_type> _crack_front_points;
 
  enum class GrowthDirectionEnum
  {
    MAX_HOOP_STRESS,
    FUNCTION
  };
  const GrowthDirectionEnum _growth_dir_method;
 
  enum class GrowthRateEnum
  {
    REPORTER,
    FUNCTION
  };
  const GrowthRateEnum _growth_increment_method;
 
  const unsigned int _elem_dim = 3;
 
  const Real _const_intersection = 0.01;
 
  Real _size_control;
 
  unsigned int _n_step_growth;
 
  bool _stop;
  bool _grow;
 
  std::vector<dof_id_type> _boundary;
 
  std::vector<std::vector<dof_id_type>> _active_boundary;
 
  std::vector<unsigned int> _inactive_boundary_pos;
 
  std::vector<dof_id_type> _tracked_crack_front_points;
 
  bool _cfd;
 
  std::set<Xfem::CutEdge> _boundary_edges;
 
  std::map<dof_id_type, std::vector<dof_id_type>> _boundary_map;
 
  std::vector<std::vector<Point>> _active_direction;
 
  std::vector<std::vector<dof_id_type>> _front;
 
  bool _is_mesh_modified;
 
  unsigned int _num_crack_front_points;
 
  virtual bool intersectWithEdge(const Point & p1,
                                 const Point & p2,
                                 const std::vector<Point> & _vertices,
                                 Point & point) const;
 
  bool findIntersection(const Point & p1,
                        const Point & p2,
                        const std::vector<Point> & vertices,
                        Point & point) const;
 
  bool isInsideEdge(const Point & p1, const Point & p2, const Point & p) const;
 
  Real getRelativePosition(const Point & p1, const Point & p2, const Point & p) const;
 
  bool isInsideCutPlane(const std::vector<Point> & _vertices, const Point & p) const;
 
  void findBoundaryNodes();
 
  void findBoundaryEdges();
 
  void sortBoundaryNodes();
 
  Real findDistance(dof_id_type node1, dof_id_type node2);
 
  void refineBoundary();
 
  void findActiveBoundaryDirection();
 
  void growFront();
 
  void sortFrontNodes();
 
  void findFrontIntersection();
 
  void refineFront();
 
  void triangulation();
 
  void joinBoundary();
 
  void initializeCrackFrontNodes();
 
  const Function * _func_x;
  const Function * _func_y;
  const Function * _func_z;
  const Function * _func_v;
 
  const std::vector<Real> * const _ki_vpp;
  const std::vector<Real> * const _kii_vpp;
  const std::vector<Real> * const _growth_inc_reporter;
};