FractureMechanics::GetSmoothingElementsSkin Struct Reference

Collaboration diagram for FractureMechanics::GetSmoothingElementsSkin:

Public Member Functions
	GetSmoothingElementsSkin (CrackPropagation &cp)
MoFEMErrorCode	getOptions ()
MoFEMErrorCode	operator() (Range &fix_material_nodes, const bool fix_small_g=true, const bool debug=false) const

Public Attributes
CrackPropagation &	cP
double	gcFixThreshold

Detailed Description

Definition at line 244 of file CrackPropagation.cpp.

Constructor & Destructor Documentation

GetSmoothingElementsSkin()

FractureMechanics::GetSmoothingElementsSkin::GetSmoothingElementsSkin ( CrackPropagation &  cp )

inline

Definition at line 247 of file CrackPropagation.cpp.

                                                 : cP(cp), gcFixThreshold(0.5) {
    ierr = getOptions();
    CHKERRABORT(PETSC_COMM_WORLD, ierr);
  }

Member Function Documentation

getOptions()

MoFEMErrorCode FractureMechanics::GetSmoothingElementsSkin::getOptions ( )

inline

Definition at line 252 of file CrackPropagation.cpp.

                              {
    MoFEMFunctionBegin;
    ierr =
        PetscOptionsBegin(PETSC_COMM_WORLD, "", "Fixing nodes options", "none");
    CHKERRG(ierr);
    CHKERR PetscOptionsScalar("-gc_fix_threshold",
                              "fix nodes below given threshold", "",
                              gcFixThreshold, &gcFixThreshold, PETSC_NULL);
    CHKERR PetscPrintf(PETSC_COMM_WORLD,
                       "### Input parameter: -gc_fix_threshold %6.4e \n",
                       gcFixThreshold);
 
    ierr = PetscOptionsEnd();
    CHKERRG(ierr);
    MoFEMFunctionReturn(0);
  }

operator()()

MoFEMErrorCode FractureMechanics::GetSmoothingElementsSkin::operator() ( Range &  fix_material_nodes, const bool  fix_small_g = true, const bool  debug = false  ) const

inline

Definition at line 269 of file CrackPropagation.cpp.

                                                            {
    MoFEM::Interface &m_field = cP.mField;
    MoFEMFunctionBegin;
 
    Skinner skin(&m_field.get_moab());
    Range tets_level, prisms_level;
    CHKERR m_field.getInterface<BitRefManager>()->getEntitiesByTypeAndRefLevel(
        cP.mapBitLevel["material_domain"], BitRefLevel().set(), MBTET,
        tets_level);
    CHKERR m_field.getInterface<BitRefManager>()->getEntitiesByTypeAndRefLevel(
        cP.mapBitLevel["material_domain"], BitRefLevel().set(), MBPRISM,
        prisms_level);
 
    prisms_level = intersect(prisms_level, cP.contactElements);
    tets_level.merge(prisms_level);
 
    Range mesh_skin;
    CHKERR skin.find_skin(0, tets_level, false, mesh_skin);
 
    mesh_skin = mesh_skin.subset_by_type(MBTRI);
 
    Range faces_to_remove, contact_faces;
    faces_to_remove = unite(cP.crackFaces, cP.bodySkin);
    contact_faces = unite(cP.contactMasterFaces, cP.contactSlaveFaces);
    faces_to_remove = subtract(faces_to_remove, contact_faces);
 
    mesh_skin = subtract(mesh_skin, faces_to_remove);
 
    CHKERR m_field.get_moab().get_connectivity(mesh_skin, fix_material_nodes);
    // fix fixed edges nodes
    Range fixed_edges = cP.getInterface<CPMeshCut>()->getFixedEdges();
    Range fixed_edges_nodes;
    CHKERR m_field.get_moab().get_connectivity(fixed_edges, fixed_edges_nodes,
                                               true);
 
    Range crack_faces_and_fixed_edges_nodes;
    CHKERR m_field.get_moab().get_connectivity(
        cP.crackFaces, crack_faces_and_fixed_edges_nodes, true);
    crack_faces_and_fixed_edges_nodes =
        intersect(crack_faces_and_fixed_edges_nodes, fixed_edges_nodes);
 
    Range crack_faces_edges;
    CHKERR m_field.get_moab().get_adjacencies(
        cP.crackFaces, 1, false, crack_faces_edges, moab::Interface::UNION);
    Range not_fixed_edges = intersect(crack_faces_edges, fixed_edges);
    Range not_fixed_edges_nodes;
    CHKERR m_field.get_moab().get_connectivity(not_fixed_edges,
                                               not_fixed_edges_nodes, true);
    crack_faces_and_fixed_edges_nodes =
        subtract(crack_faces_and_fixed_edges_nodes, not_fixed_edges_nodes);
    fix_material_nodes.merge(crack_faces_and_fixed_edges_nodes);
 
    Range not_fixed_edges_skin;
    CHKERR skin.find_skin(0, not_fixed_edges, false, not_fixed_edges_skin);
    fix_material_nodes.merge(
        subtract(not_fixed_edges_skin, cP.crackFrontNodes));
    if (debug && !m_field.get_comm_rank()) {
      EntityHandle meshset;
      CHKERR m_field.get_moab().create_meshset(MESHSET_SET, meshset);
      CHKERR m_field.get_moab().add_entities(meshset, mesh_skin);
      CHKERR m_field.get_moab().write_file("fixed_faces.vtk", "VTK", "",
                                           &meshset, 1);
      CHKERR m_field.get_moab().delete_entities(&meshset, 1);
    }
 
    // fix corner nodes
    fix_material_nodes.merge(cP.getInterface<CPMeshCut>()->getCornerNodes());
 
    // fix nodes on kinematic and static boundary conditions
    auto bc_fix_nodes = [&m_field,
                         &fix_material_nodes](const EntityHandle meshset) {
      MoFEMFunctionBegin;
      Range ents;
      CHKERR m_field.get_moab().get_entities_by_handle(meshset, ents, true);
      Range nodes;
      CHKERR m_field.get_moab().get_connectivity(ents, nodes);
      fix_material_nodes.merge(nodes);
      MoFEMFunctionReturn(0);
    };
    for (_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(
             m_field, NODESET | DISPLACEMENTSET, it)) {
      CHKERR bc_fix_nodes(it->getMeshset());
    }
 
    if (!cP.isSurfaceForceAle) {
      for (_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(m_field,
                                                      NODESET | FORCESET, it)) {
        CHKERR bc_fix_nodes(it->getMeshset());
      }
    }
 
    if (!cP.isPressureAle) {
      // fix nodes on surfaces under pressure
      for (_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(
               m_field, SIDESET | PRESSURESET, it)) {
        CHKERR bc_fix_nodes(it->getMeshset());
      }
    }
 
    // fix nodes on contact surfaces
    if (cP.fixContactNodes) {
      Range contact_nodes;
      CHKERR m_field.get_moab().get_connectivity(cP.contactElements,
                                                 contact_nodes);
      fix_material_nodes.merge(contact_nodes);
    }
 
    if (!cP.areSpringsAle) {
      // fix nodes on spring nodes
      for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(m_field, BLOCKSET, bit)) {
        if (bit->getName().compare(0, 9, "SPRING_BC") == 0) {
          CHKERR bc_fix_nodes(bit->meshset);
        }
      }
    }
 
    {
      Range contact_nodes;
      CHKERR m_field.get_moab().get_connectivity(cP.mortarContactElements,
                                                 contact_nodes);
      fix_material_nodes.merge(contact_nodes);
    }
 
    // fix nodes on the constrained interface
    if (!cP.constrainedInterface.empty()) {
      Range interface_nodes;
      CHKERR m_field.get_moab().get_connectivity(cP.constrainedInterface,
                                                 interface_nodes);
      fix_material_nodes.merge(interface_nodes);
    }
 
    auto add_nodes_on_opposite_side_of_prism = [&m_field, &fix_material_nodes,
                                                this](bool only_contact_prisms =
                                                          false) {
      MoFEMFunctionBegin;
      Range adj_prisms;
      CHKERR m_field.get_moab().get_adjacencies(
          fix_material_nodes, 3, false, adj_prisms, moab::Interface::UNION);
      adj_prisms = adj_prisms.subset_by_type(MBPRISM);
      if (only_contact_prisms) {
        adj_prisms = intersect(adj_prisms, cP.contactElements);
      }
      for (auto p : adj_prisms) {
        int num_nodes;
        const EntityHandle *conn;
        CHKERR m_field.get_moab().get_connectivity(p, conn, num_nodes, false);
        Range add_nodes;
        for (int n = 0; n != 3; ++n) {
          if (fix_material_nodes.find(conn[n]) != fix_material_nodes.end()) {
            add_nodes.insert(conn[3 + n]);
          }
          if (fix_material_nodes.find(conn[3 + n]) !=
              fix_material_nodes.end()) {
            add_nodes.insert(conn[n]);
          }
        }
        fix_material_nodes.merge(add_nodes);
      }
      MoFEMFunctionReturn(0);
    };
 
    CHKERR add_nodes_on_opposite_side_of_prism();
 
    cP.fractionOfFixedNodes = 0;
    if (fix_small_g) {
 
      if (!cP.mField.get_comm_rank()) {
        auto copy_map = [&fix_material_nodes](const auto &map) {
          std::map<EntityHandle, double> map_copy;
          for (auto &m : map) {
            if (fix_material_nodes.find(m.first) == fix_material_nodes.end()) {
              map_copy[m.first] = m.second;
            }
          }
          return map_copy;
        };
 
        const std::map<EntityHandle, double> map_j = copy_map(cP.mapJ);
        const std::map<EntityHandle, double> map_g1 = copy_map(cP.mapG1);
 
        auto find_max = [](const auto &map) {
          double max = 0;
          for (auto &m : map)
            max = fmax(m.second, max);
          return max;
        };
 
        const double max_j = find_max(map_j);
        const double max_g1 = find_max(map_g1);
 
        for (auto &m : map_j) {
          if ((m.second < gcFixThreshold * max_j) &&
              (map_g1.at(m.first) < gcFixThreshold * max_g1)) {
            fix_material_nodes.insert(m.first);
          } else {
            cP.fractionOfFixedNodes += 1;
          }
        }
 
        if (map_j.empty() || map_g1.empty() || cP.fractionOfFixedNodes == 0) {
          SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                  "No points to move on crack front");
        }
 
        cP.fractionOfFixedNodes /= map_j.size();
      }
 
      Vec vec;
      CHKERR VecCreateMPI(cP.mField.get_comm(), PETSC_DETERMINE, 1, &vec);
      if (!cP.mField.get_comm_rank()) {
        CHKERR VecSetValue(vec, cP.mField.get_comm_rank(),
                           cP.fractionOfFixedNodes, INSERT_VALUES);
      }
      CHKERR VecMax(vec, PETSC_NULL, &cP.fractionOfFixedNodes);
      CHKERR VecDestroy(&vec);
    }
 
    CHKERR add_nodes_on_opposite_side_of_prism(true);
 
    MoFEMFunctionReturn(0);
  }

Member Data Documentation

cP

CrackPropagation& FractureMechanics::GetSmoothingElementsSkin::cP

Definition at line 245 of file CrackPropagation.cpp.

gcFixThreshold

double FractureMechanics::GetSmoothingElementsSkin::gcFixThreshold

Definition at line 246 of file CrackPropagation.cpp.

---

The documentation for this struct was generated from the following file:

• users_modules/fracture_mechanics/src/impl/CrackPropagation.cpp