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 "GeometricCutUserObject.h"
#include "CrackFrontDefinition.h"

#include <array>

class Function;

class CrackMeshCut3DUserObject : public GeometricCutUserObject
{
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();

  void setSubCriticalGrowthSize(std::vector<Real> & growth_size);

  unsigned int getNumberOfCrackFrontPoints() const;

protected:
  std::unique_ptr<MeshBase> _cut_mesh;

  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
  {
    FATIGUE,
    FUNCTION
  };
  const GrowthRateEnum _growth_rate_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<Real> _growth_size;

  std::vector<unsigned long int> _dn;
  std::vector<unsigned long int> _n;

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

  const Function * _func_x;
  const Function * _func_y;
  const Function * _func_z;
  const Function * _func_v;
};