CrackFrontDefinition.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 "GeneralUserObject.h"
#include "CrackFrontPointsProvider.h"
#include "BoundaryRestrictable.h"
#include <set>
#include "ADRankTwoTensorForward.h"

class AuxiliarySystem;

// libMesh forward declarations
namespace libMesh
{
class QBase;
}

// fixme lynn this needs to be removed from the globalname space in a seperate commit after Grizzly
// is fixed to use includeCrackFrontDefinitionParams
void addCrackFrontDefinitionParams(InputParameters & params);
class CrackFrontDefinition : public GeneralUserObject, public BoundaryRestrictable
{
public:
  static InputParameters validParams();

  CrackFrontDefinition(const InputParameters & parameters);

  virtual void initialSetup() override;
  virtual void initialize() override;
  virtual void finalize() override;
  virtual void execute() override;

  static void includeCrackFrontDefinitionParams(InputParameters & params);

  void updateNumberOfCrackFrontPoints(const std::size_t num_points);

  const Node * getCrackFrontNodePtr(const std::size_t node_index) const;

  const Point * getCrackFrontPoint(const std::size_t point_index) const;

  const RealVectorValue & getCrackFrontTangent(const std::size_t point_index) const;

  const RealVectorValue & getCrackFrontNormal(const std::size_t point_index) const;

  Real getCrackFrontForwardSegmentLength(const std::size_t point_index) const;

  Real getCrackFrontBackwardSegmentLength(const std::size_t point_index) const;

  const RealVectorValue & getCrackDirection(const std::size_t point_index) const;

  Real getDistanceAlongFront(const std::size_t point_index) const;

  bool hasAngleAlongFront() const;

  Real getAngleAlongFront(const std::size_t point_index) const;

  std::size_t getNumCrackFrontPoints() const;

  bool treatAs2D() const { return _treat_as_2d; }

  bool usingMeshCutter() const { return _use_mesh_cutter; }

  RealVectorValue rotateToCrackFrontCoords(const RealVectorValue vector,
                                           const std::size_t point_index) const;
  RankTwoTensor rotateToCrackFrontCoords(const RankTwoTensor tensor,
                                         const std::size_t point_index) const;

  RealVectorValue rotateFromCrackFrontCoordsToGlobal(const RealVectorValue vector,
                                                     const std::size_t point_index) const;

  void calculateRThetaToCrackFront(const Point qp,
                                   const std::size_t point_index,
                                   Real & r,
                                   Real & theta) const;

  std::size_t calculateRThetaToCrackFront(const Point qp, Real & r, Real & theta) const;

  bool isNodeOnIntersectingBoundary(const Node * const node) const;

  bool isPointWithIndexOnIntersectingBoundary(const std::size_t point_index) const;

  Real getCrackFrontTangentialStrain(const std::size_t node_index) const;

  bool hasCrackFrontNodes() const
  {
    return _geom_definition_method == CRACK_GEOM_DEFINITION::CRACK_FRONT_NODES;
  }

  bool isNodeInRing(const std::size_t ring_index,
                    const dof_id_type connected_node_id,
                    const std::size_t node_index) const;

  Real DomainIntegralQFunction(std::size_t crack_front_point_index,
                               std::size_t ring_index,
                               const Node * const current_node) const;

  Real DomainIntegralTopologicalQFunction(std::size_t crack_front_point_index,
                                          std::size_t ring_index,
                                          const Node * const current_node) const;

  void isCutterModified(const bool is_cutter_modified);

protected:
  const enum class DIRECTION_METHOD {
    CRACK_DIRECTION_VECTOR,
    CRACK_MOUTH,
    CURVED_CRACK_FRONT
  } _direction_method;

  const enum class END_DIRECTION_METHOD {
    NO_SPECIAL_TREATMENT,
    END_CRACK_DIRECTION_VECTOR,
    END_CRACK_TANGENT_VECTOR
  } _end_direction_method;

  enum CRACK_NODE_TYPE
  {
    MIDDLE_NODE,
    END_1_NODE,
    END_2_NODE
  };

  enum class CRACK_GEOM_DEFINITION
  {
    CRACK_FRONT_NODES,
    CRACK_FRONT_POINTS
  } _geom_definition_method;

  AuxiliarySystem & _aux;
  MooseMesh & _mesh;

  std::vector<dof_id_type> _ordered_crack_front_nodes;
  std::vector<Point> _crack_front_points;
  std::vector<RealVectorValue> _tangent_directions;
  std::vector<RealVectorValue> _crack_directions;
  std::vector<std::pair<Real, Real>> _segment_lengths;
  std::vector<Real> _distances_along_front;
  std::vector<Real> _angles_along_front;
  std::vector<Real> _strain_along_front;
  std::vector<RankTwoTensor> _rot_matrix;
  Real _overall_length;
  RealVectorValue _crack_direction_vector;
  RealVectorValue _crack_direction_vector_end_1;
  RealVectorValue _crack_direction_vector_end_2;
  RealVectorValue _crack_tangent_vector_end_1;
  RealVectorValue _crack_tangent_vector_end_2;
  std::vector<BoundaryName> _crack_mouth_boundary_names;
  std::vector<BoundaryID> _crack_mouth_boundary_ids;
  std::vector<BoundaryName> _intersecting_boundary_names;
  std::vector<BoundaryID> _intersecting_boundary_ids;
  RealVectorValue _crack_mouth_coordinates;
  std::vector<RealVectorValue> _crack_plane_normals;
  bool _treat_as_2d;
  bool _use_mesh_cutter;
  bool _is_cutter_modified;
  bool _closed_loop;
  unsigned int _axis_2d;
  bool _has_symmetry_plane;
  unsigned int _symmetry_plane;
  std::string _disp_x_var_name;
  std::string _disp_y_var_name;
  std::string _disp_z_var_name;
  bool _t_stress;
  bool _q_function_rings;
  std::size_t _last_ring;
  std::size_t _first_ring;
  std::map<std::pair<dof_id_type, std::size_t>, std::set<dof_id_type>>
      _crack_front_node_to_node_map;
  MooseEnum _q_function_type;
  std::vector<bool> _is_point_on_intersecting_boundary;
  std::vector<Real> _j_integral_radius_inner;
  std::vector<Real> _j_integral_radius_outer;
  const CrackFrontPointsProvider * _crack_front_points_provider;
  std::size_t _num_points_from_provider;
  const Real _tol;

  void getCrackFrontNodes(std::set<dof_id_type> & nodes);

  void orderCrackFrontNodes(std::set<dof_id_type> & nodes);

  void orderEndNodes(std::vector<dof_id_type> & end_nodes);

  void
  pickLoopCrackEndNodes(std::vector<dof_id_type> & end_nodes,
                        std::set<dof_id_type> & nodes,
                        std::map<dof_id_type, std::vector<dof_id_type>> & node_to_line_elem_map,
                        std::vector<std::vector<dof_id_type>> & line_elems);
  dof_id_type maxNodeCoor(std::vector<Node *> & nodes, unsigned int dir0 = 0);

  void updateCrackFrontGeometry();

  void computeCrackMouthNodes();

  void computeCurvedCrackFrontCrackPlaneNormals();

  RealVectorValue calculateCrackFrontDirection(const Point & crack_front_point,
                                               const RealVectorValue & tangent_direction,
                                               const CRACK_NODE_TYPE ntype,
                                               const std::size_t crack_front_point_index = 0) const;

  void calculateTangentialStrainAlongFront();

  void createQFunctionRings();

  void addNodesToQFunctionRing(std::set<dof_id_type> & nodes_new_ring,
                               const std::set<dof_id_type> & nodes_old_ring,
                               const std::set<dof_id_type> & nodes_all_rings,
                               const std::set<dof_id_type> & nodes_neighbor1,
                               const std::set<dof_id_type> & nodes_neighbor2,
                               std::vector<std::vector<const Elem *>> & nodes_to_elem_map);

  void projectToFrontAtPoint(Real & dist_to_front,
                             Real & dist_along_tangent,
                             std::size_t crack_front_point_index,
                             const Node * const current_node) const;
};