void
createNewElements(percept::PerceptMesh& eMesh, NodeRegistry& nodeRegistry,
stk_classic::mesh::Entity& element, NewSubEntityNodesType& new_sub_entity_nodes, vector<stk_classic::mesh::Entity *>::iterator& element_pool,
stk_classic::mesh::FieldBase *proc_rank_field=0)
{
const CellTopologyData * const cell_topo_data = stk_classic::percept::PerceptMesh::get_cell_topology(element);
typedef boost::tuple<stk_classic::mesh::EntityId, stk_classic::mesh::EntityId, stk_classic::mesh::EntityId> tri_tuple_type;
static vector<tri_tuple_type> elems(6);
CellTopology cell_topo(cell_topo_data);
const stk_classic::mesh::PairIterRelation elem_nodes = element.relations(stk_classic::mesh::fem::FEMMetaData::NODE_RANK);
//stk_classic::mesh::Part & active = mesh->ActivePart();
//stk_classic::mesh::Part & quad4 = mesh->QuadPart();
std::vector<stk_classic::mesh::Part*> add_parts;
std::vector<stk_classic::mesh::Part*> remove_parts;
//add_parts.push_back( &active );
//FIXME
//add_parts.push_back( const_cast<mesh::Part*>( eMesh.getPart(m_toTopoPartName) ));
add_parts = m_toParts;
/**
\node[above] at (p4.side 1){2};
\node[left] at (p4.side 2){3};
\node[below] at (p4.side 3){0};
\node[right] at (p4.side 4){1};
*/
double tmp_x[3];
for (int iedge = 0; iedge < 4; iedge++)
{
double * mp = midPoint(EDGE_COORD(iedge,0), EDGE_COORD(iedge,1), eMesh.get_spatial_dim(), tmp_x);
if (!EDGE_N(iedge))
{
std::cout << "P[" << eMesh.get_rank() << " nid ## = 0 << " << std::endl;
}
eMesh.createOrGetNode(EDGE_N(iedge), mp);
}
elems[0] = tri_tuple_type(VERT_N(0), EDGE_N(0), EDGE_N(3));
elems[1] = tri_tuple_type(VERT_N(1), EDGE_N(1), EDGE_N(0));
elems[2] = tri_tuple_type(EDGE_N(0), EDGE_N(1), EDGE_N(3));
elems[3] = tri_tuple_type(VERT_N(2), EDGE_N(2), EDGE_N(1));
elems[4] = tri_tuple_type(VERT_N(3), EDGE_N(3), EDGE_N(2));
elems[5] = tri_tuple_type(EDGE_N(2), EDGE_N(3), EDGE_N(1));
// write a diagram of the refinement pattern as a vtk file, or a latex/tikz/pgf file
#define WRITE_DIAGRAM 0
#if WRITE_DIAGRAM
#endif
for (unsigned ielem=0; ielem < elems.size(); ielem++)
{
//stk_classic::mesh::Entity& newElement = eMesh.get_bulk_data()->declare_entity(Element, *element_id_pool, eMesh.getPart(interface_table::shards_Triangle_3) );
//stk_classic::mesh::Entity& newElement = eMesh.get_bulk_data()->declare_entity(Element, *element_id_pool, eMesh.getPart(interface_table::shards_Triangle_3) );
stk_classic::mesh::Entity& newElement = *(*element_pool);
if (proc_rank_field)
{
double *fdata = stk_classic::mesh::field_data( *static_cast<const ScalarFieldType *>(proc_rank_field) , newElement );
//fdata[0] = double(m_eMesh.get_rank());
fdata[0] = double(newElement.owner_rank());
}
//eMesh.get_bulk_data()->change_entity_parts( newElement, add_parts, remove_parts );
change_entity_parts(eMesh, element, newElement);
{
if (!elems[ielem].get<0>())
{
std::cout << "P[" << eMesh.get_rank() << " nid = 0 << " << std::endl;
exit(1);
}
}
eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<0>()), 0);
eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<1>()), 1);
eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<2>()), 2);
set_parent_child_relations(eMesh, element, newElement, ielem);
element_pool++;
}
}
void
createNewElements(percept::PerceptMesh& eMesh, NodeRegistry& nodeRegistry,
stk::mesh::Entity& element, NewSubEntityNodesType& new_sub_entity_nodes, vector<stk::mesh::Entity *>::iterator& element_pool,
stk::mesh::FieldBase *proc_rank_field=0)
{
const CellTopologyData * const cell_topo_data = stk::percept::PerceptMesh::get_cell_topology(element);
typedef boost::tuple<stk::mesh::EntityId, stk::mesh::EntityId> line_tuple_type;
static vector<line_tuple_type> elems(2);
CellTopology cell_topo(cell_topo_data);
const stk::mesh::PairIterRelation elem_nodes = element.relations(stk::mesh::fem::FEMMetaData::NODE_RANK);
std::vector<stk::mesh::Part*> add_parts;
std::vector<stk::mesh::Part*> remove_parts;
add_parts = m_toParts;
unsigned num_nodes_on_edge = new_sub_entity_nodes[m_eMesh.edge_rank()][0].size();
if (!num_nodes_on_edge)
return;
double coord_x[3];
for (int iedge = 0; iedge < 1; iedge++)
{
//double * mp = midPoint(EDGE_COORD(iedge,0), EDGE_COORD(iedge,1), eMesh.get_spatial_dim(), coord_x);
//double * mp = midPoint(FACE_COORD(iedge,0), FACE_COORD(iedge,1), eMesh.get_spatial_dim(), coord_x);
double * mp = midPoint(VERT_COORD(0), VERT_COORD(1), eMesh.get_spatial_dim(), coord_x);
if (!EDGE_N(iedge))
{
std::cout << "P[" << eMesh.get_rank() << " nid ## = 0 " << std::endl;
}
eMesh.createOrGetNode(EDGE_N(iedge), mp);
}
// FIXME
nodeRegistry.makeCentroidCoords(*const_cast<stk::mesh::Entity *>(&element), m_primaryEntityRank, 0u);
nodeRegistry.addToExistingParts(*const_cast<stk::mesh::Entity *>(&element), m_primaryEntityRank, 0u);
nodeRegistry.interpolateFields(*const_cast<stk::mesh::Entity *>(&element), m_primaryEntityRank, 0u);
Elem::CellTopology elem_celltopo = Elem::getCellTopology< FromTopology >();
const Elem::RefinementTopology* ref_topo_p = Elem::getRefinementTopology(elem_celltopo);
const Elem::RefinementTopology& ref_topo = *ref_topo_p;
#ifndef NDEBUG
unsigned num_child = ref_topo.num_child();
VERIFY_OP(num_child, == , 2, "createNewElements num_child problem");
bool homogeneous_child = ref_topo.homogeneous_child();
VERIFY_OP(homogeneous_child, ==, true, "createNewElements homogeneous_child");
#endif
// new_sub_entity_nodes[i][j]
//const UInt * const * child_nodes() const {
//const UInt * child_node_0 = ref_topo.child_node(0);
typedef Elem::StdMeshObjTopologies::RefTopoX RefTopoX;
RefTopoX& l2 = Elem::StdMeshObjTopologies::RefinementTopologyExtra< FromTopology > ::refinement_topology;
#define CENTROID_N NN(m_primaryEntityRank,0)
for (unsigned iChild = 0; iChild < 2; iChild++)
{
unsigned EN[2];
for (unsigned jNode = 0; jNode < 2; jNode++)
{
unsigned childNodeIdx = ref_topo.child_node(iChild)[jNode];
#ifndef NDEBUG
unsigned childNodeIdxCheck = l2[childNodeIdx].ordinal_of_node;
VERIFY_OP(childNodeIdx, ==, childNodeIdxCheck, "childNodeIdxCheck");
#endif
unsigned inode=0;
if (l2[childNodeIdx].rank_of_subcell == 0)
inode = VERT_N(l2[childNodeIdx].ordinal_of_subcell);
else if (l2[childNodeIdx].rank_of_subcell == 1)
inode = EDGE_N(l2[childNodeIdx].ordinal_of_subcell);
// else if (l2[childNodeIdx].rank_of_subcell == 2)
// inode = CENTROID_N;
EN[jNode] = inode;
}
elems[iChild] = line_tuple_type(EN[0], EN[1]);
}
#undef CENTROID_N
for (unsigned ielem=0; ielem < elems.size(); ielem++)
{
stk::mesh::Entity& newElement = *(*element_pool);
#if 0
if (proc_rank_field && proc_rank_field->rank() == m_eMesh.edge_rank()) //&& m_eMesh.get_spatial_dim()==1)
{
double *fdata = stk::mesh::field_data( *static_cast<const ScalarFieldType *>(proc_rank_field) , newElement );
//fdata[0] = double(m_eMesh.get_rank());
fdata[0] = double(newElement.owner_rank());
}
#endif
stk::mesh::FieldBase * proc_rank_field_edge = m_eMesh.get_field("proc_rank_edge");
if (proc_rank_field_edge)
{
double *fdata = stk::mesh::field_data( *static_cast<const ScalarFieldType *>(proc_rank_field_edge) , newElement );
fdata[0] = double(newElement.owner_rank());
//fdata[0] = 1234.56;
if (0)
std::cout << "P[" << m_eMesh.get_rank() << "] tmp set proc_rank_field_edge to value = " << newElement.owner_rank()
<< " for side element = " << newElement.identifier()
<< std::endl;
}
//eMesh.get_bulk_data()->change_entity_parts( newElement, add_parts, remove_parts );
change_entity_parts(eMesh, element, newElement);
{
if (!elems[ielem].get<0>())
{
std::cout << "P[" << eMesh.get_rank() << " nid = 0 " << std::endl;
exit(1);
}
}
eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<0>()), 0);
eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<1>()), 1);
set_parent_child_relations(eMesh, element, newElement, ielem);
element_pool++;
}
}
void
createNewElements(percept::PerceptMesh& eMesh, NodeRegistry& nodeRegistry,
stk::mesh::Entity& element, NewSubEntityNodesType& new_sub_entity_nodes, vector<stk::mesh::Entity *>::iterator& element_pool,
stk::mesh::FieldBase *proc_rank_field=0)
{
const CellTopologyData * const cell_topo_data = stk::percept::PerceptMesh::get_cell_topology(element);
typedef boost::tuple<stk::mesh::EntityId, stk::mesh::EntityId, stk::mesh::EntityId, stk::mesh::EntityId> quad_tuple_type;
static vector<quad_tuple_type> elems(4);
CellTopology cell_topo(cell_topo_data);
const stk::mesh::PairIterRelation elem_nodes = element.relations(stk::mesh::fem::FEMMetaData::NODE_RANK);
//stk::mesh::Part & active = mesh->ActivePart();
//stk::mesh::Part & quad4 = mesh->QuadPart();
std::vector<stk::mesh::Part*> add_parts;
std::vector<stk::mesh::Part*> remove_parts;
//add_parts.push_back( &active );
//FIXME
//add_parts.push_back( const_cast<mesh::Part*>( eMesh.getPart(m_toTopoPartName) ));
add_parts = m_toParts;
double tmp_x[3];
for (int iedge = 0; iedge < 4; iedge++)
{
double * mp = midPoint(EDGE_COORD(iedge,0), EDGE_COORD(iedge,1), eMesh.get_spatial_dim(), tmp_x);
if (!EDGE_N(iedge))
{
std::cout << "P[" << eMesh.get_rank() << " nid ## = 0 << " << std::endl;
}
eMesh.createOrGetNode(EDGE_N(iedge), mp);
}
nodeRegistry.makeCentroidCoords(*const_cast<stk::mesh::Entity *>(&element), m_eMesh.element_rank(), 0u);
// new_sub_entity_nodes[i][j]
#define CENTROID_N NN(m_primaryEntityRank,0)
elems[0] = quad_tuple_type(VERT_N(0), EDGE_N(0), CENTROID_N, EDGE_N(3));
elems[1] = quad_tuple_type(VERT_N(1), EDGE_N(1), CENTROID_N, EDGE_N(0));
elems[2] = quad_tuple_type(VERT_N(2), EDGE_N(2), CENTROID_N, EDGE_N(1));
elems[3] = quad_tuple_type(VERT_N(3), EDGE_N(3), CENTROID_N, EDGE_N(2));
#undef CENTROID_N
// write a diagram of the refinement pattern as a vtk file, or a latex/tikz/pgf file
#define WRITE_DIAGRAM 0
#if WRITE_DIAGRAM
#endif
for (unsigned ielem=0; ielem < elems.size(); ielem++)
{
stk::mesh::Entity& newElement = *(*element_pool);
if (proc_rank_field)
{
double *fdata = stk::mesh::field_data( *static_cast<const ScalarFieldType *>(proc_rank_field) , newElement );
//fdata[0] = double(m_eMesh.get_rank());
fdata[0] = double(newElement.owner_rank());
}
eMesh.get_bulk_data()->change_entity_parts( newElement, add_parts, remove_parts );
{
if (!elems[ielem].get<0>())
{
std::cout << "P[" << eMesh.get_rank() << " nid = 0 << " << std::endl;
exit(1);
}
}
eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<0>()), 0);
eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<1>()), 1);
eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<2>()), 2);
eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<3>()), 3);
set_parent_child_relations(eMesh, element, newElement, ielem);
element_pool++;
}
}
void
createNewElements(percept::PerceptMesh& eMesh, NodeRegistry& nodeRegistry,
stk_classic::mesh::Entity& element, NewSubEntityNodesType& new_sub_entity_nodes, vector<stk_classic::mesh::Entity *>::iterator& element_pool,
stk_classic::mesh::FieldBase *proc_rank_field=0)
{
const CellTopologyData * const cell_topo_data = stk_classic::percept::PerceptMesh::get_cell_topology(element);
typedef boost::tuple<stk_classic::mesh::EntityId, stk_classic::mesh::EntityId, stk_classic::mesh::EntityId> tri_tuple_type;
static vector<tri_tuple_type> elems(4);
CellTopology cell_topo(cell_topo_data);
const stk_classic::mesh::PairIterRelation elem_nodes = element.relations(stk_classic::mesh::fem::FEMMetaData::NODE_RANK);
//stk_classic::mesh::Part & active = mesh->ActivePart();
//stk_classic::mesh::Part & quad4 = mesh->QuadPart();
std::vector<stk_classic::mesh::Part*> add_parts;
std::vector<stk_classic::mesh::Part*> remove_parts;
add_parts = m_toParts;
//std::cout << "P["<< m_eMesh.get_rank() << "] add_parts = " << add_parts << std::endl;
stk_classic::mesh::EntityRank my_rank = m_primaryEntityRank;
nodeRegistry.makeCentroidCoords(*const_cast<stk_classic::mesh::Entity *>(&element), my_rank, 0u);
nodeRegistry.addToExistingParts(*const_cast<stk_classic::mesh::Entity *>(&element), my_rank, 0u);
nodeRegistry.interpolateFields(*const_cast<stk_classic::mesh::Entity *>(&element), my_rank, 0u);
#define CENTROID_N NN(m_primaryEntityRank, 0)
elems[0] = tri_tuple_type(VERT_N(0), VERT_N(1), CENTROID_N);
elems[1] = tri_tuple_type(VERT_N(1), VERT_N(2), CENTROID_N);
elems[2] = tri_tuple_type(VERT_N(2), VERT_N(3), CENTROID_N);
elems[3] = tri_tuple_type(VERT_N(3), VERT_N(0), CENTROID_N);
#undef CENTROID_N
// write a diagram of the refinement pattern as a vtk file, or a latex/tikz/pgf file
#define WRITE_DIAGRAM 0
#if WRITE_DIAGRAM
/**
\node[above] at (p4.side 1){2};
\node[left] at (p4.side 2){3};
\node[below] at (p4.side 3){0};
\node[right] at (p4.side 4){1};
*/
#endif
for (unsigned ielem=0; ielem < elems.size(); ielem++)
{
stk_classic::mesh::Entity& newElement = *(*element_pool);
//std::cout << "P["<< m_eMesh.get_rank() << "] urp tmp 3 " << proc_rank_field << std::endl;
if (proc_rank_field && element.entity_rank() == m_eMesh.element_rank())
{
double *fdata = stk_classic::mesh::field_data( *static_cast<const ScalarFieldType *>(proc_rank_field) , newElement );
fdata[0] = double(newElement.owner_rank());
}
//std::cout << "P["<< m_eMesh.get_rank() << "] urp tmp 4 " << std::endl;
change_entity_parts(eMesh, element, newElement);
//std::cout << "P["<< m_eMesh.get_rank() << "] urp tmp 5 " << std::endl;
{
if (!elems[ielem].get<0>())
{
std::cout << "P[" << eMesh.get_rank() << " nid = 0 << " << std::endl;
exit(1);
}
}
//std::cout << "P["<< m_eMesh.get_rank() << "] urp tmp 6 " << std::endl;
eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<0>()), 0);
eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<1>()), 1);
eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<2>()), 2);
//std::cout << "P["<< m_eMesh.get_rank() << "] urp tmp 7 " << std::endl;
set_parent_child_relations(eMesh, element, newElement, ielem);
element_pool++;
}
}
void Colorer::
color(percept::PerceptMesh& eMesh, unsigned * elementType, stk_classic::mesh::PartVector* fromParts, stk_classic::mesh::FieldBase *element_color_field)
{
const unsigned MAX_COLORS=1000;
vector< ColorerNodeSetType > node_colors(MAX_COLORS+1);
ColorerElementSetType all_elements;
mesh::Selector selector(eMesh.get_fem_meta_data()->universal_part());
if (fromParts)
{
if (0)
{
std::cout << "tmp Colorer::color fromParts= " << *fromParts << std::endl;
std::cout << "tmp Colorer::color elementType= " << *elementType << std::endl;
for (unsigned i_part = 0; i_part < fromParts->size(); i_part++)
{
std::cout << "tmp Colorer::color i_part = " << i_part << " fromParts= " << (*fromParts)[i_part]->name() << std::endl;
}
}
selector = mesh::selectUnion(*fromParts);
}
stk_classic::mesh::BulkData& bulkData = *eMesh.get_bulk_data();
unsigned ncolor = 0;
int nelem = 0;
unsigned num_max_colors = MAX_COLORS;
if (m_noColoring)
num_max_colors = 1;
m_element_colors = vector< ColorerSetType > (num_max_colors+1);
for (unsigned icolor = 0; icolor < num_max_colors; icolor++)
{
int num_colored_this_pass = 0;
for (unsigned irank = 0; irank < m_entityRanks.size(); irank++)
{
const vector<stk_classic::mesh::Bucket*> & buckets = bulkData.buckets( m_entityRanks[irank] );
for ( vector<stk_classic::mesh::Bucket*>::const_iterator k = buckets.begin() ; k != buckets.end() ; ++k )
{
if (selector(**k))
{
stk_classic::mesh::Bucket & bucket = **k ;
bool doThisBucket = true;
const CellTopologyData * const bucket_cell_topo_data = stk_classic::percept::PerceptMesh::get_cell_topology(bucket);
shards::CellTopology topo(bucket_cell_topo_data);
if (elementType && (topo.getKey() != *elementType))
{
doThisBucket = false;
}
if (0 && doThisBucket)
{
std::cout << "tmp color = " << icolor << " bucket topo name= " << topo.getName() << " key= " << topo.getKey()
<< " elementType= " << (elementType? *elementType : 0) << " doThisBucket= " << doThisBucket << std::endl;
}
if (doThisBucket)
{
const unsigned num_elements_in_bucket = bucket.size();
nelem += num_elements_in_bucket;
for (unsigned iElement = 0; iElement < num_elements_in_bucket; iElement++)
{
stk_classic::mesh::Entity& element = bucket[iElement];
if (0)
std::cout << "tmp color = " << icolor << " bucket topo name= " << topo.getName() << " key= " << topo.getKey()
<< " elementId = " << element.identifier() << " element = " << element << std::endl;
stk_classic::mesh::EntityId elem_id = element.identifier();
if (!m_noColoring && contains(all_elements, elem_id))
continue;
bool none_in_this_color = true;
static std::vector<stk_classic::mesh::EntityId> node_ids(100);
unsigned num_node = 0;
if (!m_noColoring)
{
const stk_classic::mesh::PairIterRelation elem_nodes = element.relations( stk_classic::mesh::fem::FEMMetaData::NODE_RANK );
num_node = elem_nodes.size();
node_ids.reserve(num_node);
for (unsigned inode=0; inode < num_node; inode++)
{
stk_classic::mesh::Entity & node = *elem_nodes[ inode ].entity();
stk_classic::mesh::EntityId nid = node.identifier();
node_ids[inode] = nid;
if (contains(node_colors[icolor], nid))
{
none_in_this_color = false;
break;
}
}
}
if (none_in_this_color)
{
++num_colored_this_pass;
if (element_color_field)
{
double *fdata = stk_classic::mesh::field_data( *static_cast<const percept::ScalarFieldType *>(element_color_field) , element );
fdata[0] = double(icolor);
}
#if STK_ADAPT_COLORER_SET_TYPE_USE_VECTOR
m_element_colors[icolor].push_back(&element);
#else
m_element_colors[icolor].insert(&element);
#endif
if (!m_noColoring)
{
all_elements.insert(elem_id);
for (unsigned inode=0; inode < num_node; inode++)
{
node_colors[icolor].insert(node_ids[inode]);
}
}
}
} // elements in bucket
} // doThisBucket
} // selection
} // buckets
} // irank
if (0 == num_colored_this_pass)
{
break;
}
++ncolor;
if (ncolor == num_max_colors-1)
{
throw std::runtime_error("broken algorithm in mesh colorer");
}
} // icolor
//std::cout << "tmp ncolor = " << ncolor << " nelem= " << nelem << std::endl;
m_element_colors.resize(ncolor);
}