PolycrystalICTools Namespace Reference

Classes
class	AdjacencyMatrix
	Simple 2D block matrix indicating graph adjacency. More...

Functions
std::vector< unsigned int >	assignPointsToVariables (const std::vector< Point > &centerpoints, const Real op_num, const MooseMesh &mesh, const MooseVariable &var)
unsigned int	assignPointToGrain (const Point &p, const std::vector< Point > &centerpoints, const MooseMesh &mesh, const MooseVariable &var, const Real maxsize)
AdjacencyMatrix< Real >	buildGrainAdjacencyMatrix (const std::map< dof_id_type, unsigned int > &entity_to_grain, MooseMesh &mesh, const libMesh::PeriodicBoundaries *pb, unsigned int n_grains, bool is_elemental)
AdjacencyMatrix< Real >	buildElementalGrainAdjacencyMatrix (const std::map< dof_id_type, unsigned int > &element_to_grain, MooseMesh &mesh, const libMesh::PeriodicBoundaries *pb, unsigned int n_grains)
AdjacencyMatrix< Real >	buildNodalGrainAdjacencyMatrix (const std::map< dof_id_type, unsigned int > &node_to_grain, MooseMesh &mesh, const libMesh::PeriodicBoundaries *pb, unsigned int n_grains)
std::vector< unsigned int >	assignOpsToGrains (AdjacencyMatrix< Real > &adjacency_matrix, unsigned int n_grains, unsigned int n_ops, const MooseEnum &coloring_algorithm)
MooseEnum	coloringAlgorithms ()
std::string	coloringAlgorithmDescriptions ()

Variables
const unsigned int	HALO_THICKNESS = 4

Function Documentation

assignOpsToGrains()

std::vector< unsigned int > PolycrystalICTools::assignOpsToGrains	(	AdjacencyMatrix< Real > &	adjacency_matrix,
		unsigned int	n_grains,
		unsigned int	n_ops,
		const MooseEnum &	coloring_algorithm
	)

Definition at line 322 of file PolycrystalICTools.C.

{
  std::vector<unsigned int> grain_to_op(n_grains, GraphColoring::INVALID_COLOR);

  // Use a simple backtracking coloring algorithm
  if (coloring_algorithm == "bt")
  {
    if (!colorGraph(adjacency_matrix, grain_to_op, n_grains, n_ops, 0))
      mooseError(
          "Unable to find a valid Grain to op configuration, do you have enough op variables?");
  }
  else // PETSc Coloring algorithms
  {
    const std::string & ca_str = coloring_algorithm;
    Real * am_data = adjacency_matrix.rawDataPtr();
    Moose::PetscSupport::colorAdjacencyMatrix(
        am_data, n_grains, n_ops, grain_to_op, ca_str.c_str());
  }

  return grain_to_op;
}

assignPointsToVariables()

std::vector<unsigned int> PolycrystalICTools::assignPointsToVariables	(	const std::vector< Point > &	centerpoints,
		const Real	op_num,
		const MooseMesh &	mesh,
		const MooseVariable &	var
	)

assignPointToGrain()

unsigned int PolycrystalICTools::assignPointToGrain	(	const Point &	p,
		const std::vector< Point > &	centerpoints,
		const MooseMesh &	mesh,
		const MooseVariable &	var,
		const Real	maxsize
	)

buildElementalGrainAdjacencyMatrix()

PolycrystalICTools::AdjacencyMatrix< Real > PolycrystalICTools::buildElementalGrainAdjacencyMatrix	(	const std::map< dof_id_type, unsigned int > &	element_to_grain,
		MooseMesh &	mesh,
		const libMesh::PeriodicBoundaries *	pb,
		unsigned int	n_grains
	)

We've found a grain neighbor interface. In order to assign order parameters though, we need to make sure that we build out a small buffer region to avoid literal "corner cases" where nodes on opposite corners of a QUAD end up with the same OP because those nodes are not nodal neighbors. To do that we'll build a halo region based on these interface nodes. For now, we need to record the nodes inside of the grain and those outside of the grain.

Definition at line 150 of file PolycrystalICTools.C.

Referenced by buildGrainAdjacencyMatrix().

{
  AdjacencyMatrix<Real> adjacency_matrix(n_grains);

  // We can't call this in the constructor, it appears that _mesh_ptr is always NULL there.
  mesh.errorIfDistributedMesh("advanced_op_assignment = true");

  std::vector<const Elem *> all_active_neighbors;

  std::vector<std::set<dof_id_type>> local_ids(n_grains);
  std::vector<std::set<dof_id_type>> halo_ids(n_grains);

  std::unique_ptr<PointLocatorBase> point_locator = mesh.getMesh().sub_point_locator();
  for (const auto & elem : mesh.getMesh().active_element_ptr_range())
  {
    std::map<dof_id_type, unsigned int>::const_iterator grain_it =
        element_to_grain.find(elem->id());
    mooseAssert(grain_it != element_to_grain.end(), "Element not found in map");
    unsigned int my_grain = grain_it->second;

    all_active_neighbors.clear();
    // Loop over all neighbors (at the the same level as the current element)
    for (unsigned int i = 0; i < elem->n_neighbors(); ++i)
    {
      const Elem * neighbor_ancestor = elem->topological_neighbor(i, mesh, *point_locator, pb);
      if (neighbor_ancestor)
        // Retrieve only the active neighbors for each side of this element, append them to the list
        // of active neighbors
        neighbor_ancestor->active_family_tree_by_topological_neighbor(
            all_active_neighbors, elem, mesh, *point_locator, pb, false);
    }

    // Loop over all active element neighbors
    for (std::vector<const Elem *>::const_iterator neighbor_it = all_active_neighbors.begin();
         neighbor_it != all_active_neighbors.end();
         ++neighbor_it)
    {
      const Elem * neighbor = *neighbor_it;
      std::map<dof_id_type, unsigned int>::const_iterator grain_it2 =
          element_to_grain.find(neighbor->id());
      mooseAssert(grain_it2 != element_to_grain.end(), "Element not found in map");
      unsigned int their_grain = grain_it2->second;

      if (my_grain != their_grain)
      {
        // First add corresponding element and grain information
        local_ids[my_grain].insert(elem->id());
        local_ids[their_grain].insert(neighbor->id());

        // Now add opposing element and grain information
        halo_ids[my_grain].insert(neighbor->id());
        halo_ids[their_grain].insert(elem->id());
      }
      //  adjacency_matrix[my_grain][their_grain] = 1;
    }
  }

  // Build up the halos
  std::set<dof_id_type> set_difference;
  for (unsigned int i = 0; i < n_grains; ++i)
  {
    std::set<dof_id_type> orig_halo_ids(halo_ids[i]);

    for (unsigned int halo_level = 0; halo_level < PolycrystalICTools::HALO_THICKNESS; ++halo_level)
    {
      for (std::set<dof_id_type>::iterator entity_it = orig_halo_ids.begin();
           entity_it != orig_halo_ids.end();
           ++entity_it)
      {
        if (true)
          visitElementalNeighbors(
              mesh.elemPtr(*entity_it), mesh.getMesh(), *point_locator, pb, halo_ids[i]);
        else
          mooseError("Unimplemented");
      }

      set_difference.clear();
      std::set_difference(
          halo_ids[i].begin(),
          halo_ids[i].end(),
          local_ids[i].begin(),
          local_ids[i].end(),
          std::insert_iterator<std::set<dof_id_type>>(set_difference, set_difference.begin()));

      halo_ids[i].swap(set_difference);
    }
  }

  // Finally look at the halo intersections to build the connectivity graph
  std::set<dof_id_type> set_intersection;
  for (unsigned int i = 0; i < n_grains; ++i)
    for (unsigned int j = i + 1; j < n_grains; ++j)
    {
      set_intersection.clear();
      std::set_intersection(
          halo_ids[i].begin(),
          halo_ids[i].end(),
          halo_ids[j].begin(),
          halo_ids[j].end(),
          std::insert_iterator<std::set<dof_id_type>>(set_intersection, set_intersection.begin()));

      if (!set_intersection.empty())
      {
        adjacency_matrix(i, j) = 1.;
        adjacency_matrix(j, i) = 1.;
      }
    }

  return adjacency_matrix;
}

buildGrainAdjacencyMatrix()

PolycrystalICTools::AdjacencyMatrix< Real > PolycrystalICTools::buildGrainAdjacencyMatrix	(	const std::map< dof_id_type, unsigned int > &	entity_to_grain,
		MooseMesh &	mesh,
		const libMesh::PeriodicBoundaries *	pb,
		unsigned int	n_grains,
		bool	is_elemental
	)

Definition at line 136 of file PolycrystalICTools.C.

{
  if (is_elemental)
    return buildElementalGrainAdjacencyMatrix(entity_to_grain, mesh, pb, n_grains);
  else
    return buildNodalGrainAdjacencyMatrix(entity_to_grain, mesh, pb, n_grains);
}

buildNodalGrainAdjacencyMatrix()

PolycrystalICTools::AdjacencyMatrix< Real > PolycrystalICTools::buildNodalGrainAdjacencyMatrix	(	const std::map< dof_id_type, unsigned int > &	node_to_grain,
		MooseMesh &	mesh,
		const libMesh::PeriodicBoundaries *	pb,
		unsigned int	n_grains
	)

We've found a grain neighbor interface. In order to assign order parameters though, we need to make sure that we build out a small buffer region to avoid literal "corner cases" where nodes on opposite corners of a QUAD end up with the same OP because those nodes are not nodal neighbors. To do that we'll build a halo region based on these interface nodes. For now, we need to record the nodes inside of the grain and those outside of the grain.

Definition at line 274 of file PolycrystalICTools.C.

Referenced by buildGrainAdjacencyMatrix().

{
  // Build node to elem map
  std::vector<std::vector<const Elem *>> nodes_to_elem_map;
  MeshTools::build_nodes_to_elem_map(mesh.getMesh(), nodes_to_elem_map);

  AdjacencyMatrix<Real> adjacency_matrix(n_grains);

  const auto end = mesh.getMesh().active_nodes_end();
  for (auto nl = mesh.getMesh().active_nodes_begin(); nl != end; ++nl)
  {
    const Node * node = *nl;
    std::map<dof_id_type, unsigned int>::const_iterator grain_it = node_to_grain.find(node->id());
    mooseAssert(grain_it != node_to_grain.end(), "Node not found in map");
    unsigned int my_grain = grain_it->second;

    std::vector<const Node *> nodal_neighbors;
    MeshTools::find_nodal_neighbors(mesh.getMesh(), *node, nodes_to_elem_map, nodal_neighbors);

    // Loop over all nodal neighbors
    for (unsigned int i = 0; i < nodal_neighbors.size(); ++i)
    {
      const Node * neighbor_node = nodal_neighbors[i];
      std::map<dof_id_type, unsigned int>::const_iterator grain_it2 =
          node_to_grain.find(neighbor_node->id());
      mooseAssert(grain_it2 != node_to_grain.end(), "Node not found in map");
      unsigned int their_grain = grain_it2->second;

      if (my_grain != their_grain)
        adjacency_matrix(my_grain, their_grain) = 1.;
    }
  }

  return adjacency_matrix;
}

coloringAlgorithmDescriptions()

std::string PolycrystalICTools::coloringAlgorithmDescriptions

(

)

Definition at line 354 of file PolycrystalICTools.C.

{
  return "The grain neighbor graph coloring algorithm to use. \"legacy\" is the original "
         "algorithm "
         "which does not guarantee a valid coloring. \"bt\" is a simple backtracking algorithm "
         "which will produce a valid coloring but has potential exponential run time. The "
         "remaining algorithms require PETSc but are recommended for larger problems (See "
         "MatColoringType)";
}

coloringAlgorithms()

MooseEnum PolycrystalICTools::coloringAlgorithms

(

)

Definition at line 348 of file PolycrystalICTools.C.

{
  return MooseEnum("legacy bt jp power greedy", "legacy");
}

Variable Documentation

HALO_THICKNESS

const unsigned int PolycrystalICTools::HALO_THICKNESS = 4

Definition at line 30 of file PolycrystalICTools.C.

Referenced by buildElementalGrainAdjacencyMatrix().