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 319 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
	)

Definition at line 49 of file PolycrystalICTools.C.

{
  Real grain_num = centerpoints.size();
 
  std::vector<unsigned int> assigned_op(grain_num);
  std::vector<int> min_op_ind(op_num);
  std::vector<Real> min_op_dist(op_num);
 
  // Assign grains to specific order parameters in a way that maximizes the distance
  for (unsigned int grain = 0; grain < grain_num; grain++)
  {
    // Determine the distance to the closest center assigned to each order parameter
    if (grain >= op_num)
    {
      // We can set the array to the distances to the grains 0..op_num-1 (see assignment in the else
      // case)
      for (unsigned int i = 0; i < op_num; ++i)
      {
        min_op_dist[i] = mesh.minPeriodicDistance(var, centerpoints[grain], centerpoints[i]);
        min_op_ind[assigned_op[i]] = i;
      }
 
      // Now check if any of the extra grains are even closer
      for (unsigned int i = op_num; i < grain; ++i)
      {
        Real dist = mesh.minPeriodicDistance(var, centerpoints[grain], centerpoints[i]);
        if (min_op_dist[assigned_op[i]] > dist)
        {
          min_op_dist[assigned_op[i]] = dist;
          min_op_ind[assigned_op[i]] = i;
        }
      }
    }
    else
    {
      assigned_op[grain] = grain;
      continue;
    }
 
    // Assign the current center point to the order parameter that is furthest away.
    unsigned int mx_ind = 0;
    for (unsigned int i = 1; i < op_num; ++i) // Find index of max
      if (min_op_dist[mx_ind] < min_op_dist[i])
        mx_ind = i;
 
    assigned_op[grain] = mx_ind;
  }
 
  return assigned_op;
}

assignPointToGrain()

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

Definition at line 104 of file PolycrystalICTools.C.

{
  unsigned int grain_num = centerpoints.size();
 
  Real min_distance = maxsize;
  unsigned int min_index = grain_num;
  // Loops through all of the grain centers and finds the center that is closest to the point p
  for (unsigned int grain = 0; grain < grain_num; grain++)
  {
    Real distance = mesh.minPeriodicDistance(var, centerpoints[grain], p);
 
    if (min_distance > distance)
    {
      min_distance = distance;
      min_index = grain;
    }
  }
 
  if (min_index >= grain_num)
    mooseError("ERROR in PolycrystalVoronoiVoidIC: didn't find minimum values in grain_value_calc");
 
  return min_index;
}

buildElementalGrainAdjacencyMatrix()

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
	)

buildGrainAdjacencyMatrix()

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
	)

buildNodalGrainAdjacencyMatrix()

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
	)

coloringAlgorithmDescriptions()

std::string PolycrystalICTools::coloringAlgorithmDescriptions

(

)

Definition at line 351 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 345 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 28 of file PolycrystalICTools.C.