/**
* Used to output the results of a relation vector in human
* readable form. This function cannot be used as the default
* output of an IdentProcRelation since it is using knowledge that
* what is really being stored in the IdentProc is stk::mesh
* entity keys.
*/
void print_stk_mesh_relation_map(stk::diag::Writer &writer,
IdentProcRelation relation)
{
static std::vector<std::string> entity_names = stk::mesh::fem_entity_rank_names();
if (writer.shouldPrint()) {
size_t size = relation.size();
writer << "relation [size " << size << "]\n";
for (size_t i=0; i < size; i++) {
IdentProc domain = relation[i].first;
IdentProc range = relation[i].second;
// stk::mesh::EntityKey domain_entity_key;
// stk::mesh::EntityKey range_entity_key;
// domain_entity_key.value(domain.ident);
// range_entity_key.value(range.ident);
stk::mesh::EntityKey domain_entity_key(domain.ident);
stk::mesh::EntityKey range_entity_key(range.ident);
writer << "[" << i << "] ("
<< entity_names[stk::mesh::entity_rank(domain_entity_key)] << " "
<< stk::mesh::entity_id(domain_entity_key)
<< ", proc " << domain.proc
<< " -> "
<< entity_names[stk::mesh::entity_rank(range_entity_key)] << " "
<< stk::mesh::entity_id(range_entity_key)
<< ", proc " << range.proc
<< ")\n";
}
}
}
void
use_case_4_driver(stk::ParallelMachine comm,
const std::string &working_directory,
const std::string &range_mesh_filename,
const std::string &range_mesh_type,
const std::string &range_entity,
const std::string &domain_mesh_filename,
const std::string &domain_mesh_type,
const std::string &domain_entity)
{
stk::diag::WriterThrowSafe _write_throw_safe(dw());
dw().m(LOG_SEARCH) << "Use case 4" << stk::diag::push << stk::diag::dendl;
// ========================================================================
// Initialize IO system. Registers all element types and storage
// types and the exodusII default database type.
Ioss::Init::Initializer init_db;
// Define range mesh...
stk::mesh::fem::FEMMetaData range_meta_data( spatial_dimension );
stk::io::MeshData range_mesh_data;
std::string filename = working_directory + range_mesh_filename;
stk::io::create_input_mesh(range_mesh_type, filename, comm,
range_meta_data, range_mesh_data);
range_meta_data.commit();
stk::mesh::BulkData range_bulk_data(range_meta_data.get_meta_data(range_meta_data) , comm);
stk::io::populate_bulk_data(range_bulk_data, range_mesh_data);
// Define domain mesh...
stk::mesh::fem::FEMMetaData domain_meta_data( spatial_dimension );
stk::io::MeshData domain_mesh_data;
filename = working_directory + domain_mesh_filename;
stk::io::create_input_mesh(domain_mesh_type, domain_mesh_filename, comm,
domain_meta_data, domain_mesh_data);
domain_meta_data.commit();
stk::mesh::BulkData domain_bulk_data(domain_meta_data.get_meta_data(domain_meta_data) , comm);
stk::io::populate_bulk_data(domain_bulk_data, domain_mesh_data);
// ========================================================================
// For this use case, the domain consists of an axis-aligned
// bounding box for each 'domain_entity' in the mesh. The range is also an
// axis-aligned bounding box of each 'range_entity'.
VectorField *range_coord_field = range_meta_data.get_field<VectorField>("coordinates");
std::vector<AxisAlignedBoundingBox3D> range_vector;
stk::search_util::build_axis_aligned_bbox(range_bulk_data,
range_meta_data.entity_rank(range_entity),
range_coord_field, range_vector);
VectorField *domain_coord_field = domain_meta_data.get_field<VectorField>("coordinates");
std::vector<AxisAlignedBoundingBox3D> domain_vector;
stk::search_util::build_axis_aligned_bbox(domain_bulk_data,
domain_meta_data.entity_rank(domain_entity),
domain_coord_field, domain_vector);
if (range_vector.size() <= 100)
dw().m(LOG_SEARCH) << "range " << range_vector << dendl;
else
dw().m(LOG_SEARCH) << "range vector size = " << range_vector.size() << dendl;
if (domain_vector.size() <= 100)
dw().m(LOG_SEARCH) << "domain " << domain_vector << dendl;
else
dw().m(LOG_SEARCH) << "domain vector size = " << domain_vector.size() << dendl;
FactoryOrder order;
order.m_communicator = comm;
//order.m_algorithm = FactoryOrder::BIHTREE;
dw() << "Search algorithm " << order.m_algorithm << dendl;
// dw().m(LOG_SEARCH) << "Search tree " << *range_search << dendl;
IdentProcRelation relation;
stk::search::coarse_search(relation, range_vector, domain_vector,order);
if (relation.size() <= 100)
dw().m(LOG_SEARCH) << "relation " << relation << dendl;
else
dw().m(LOG_SEARCH) << "relation size = " << relation.size() << dendl;
dw().m(LOG_SEARCH) << stk::diag::pop;
}
const stk_classic::mesh::Entity *
STKSearcher<SpatialDim>::findElement(MDArray& input_phy_points, MDArray& found_parametric_coordinates,
unsigned& found_it, const mesh::Entity *hint_element )
{
//return 0;
mesh::fem::FEMMetaData& metaData = stk_classic::mesh::fem::FEMMetaData::get(*m_bulk);
mesh::BulkData& bulkData = *m_bulk;
//VectorFieldType *coords_field = metaData.get_field<VectorFieldType >("coordinates");
PerceptMesh meshUtil(&metaData, &bulkData);
double pts[SpatialDim];
for (unsigned iDim = 0; iDim < SpatialDim; iDim++)
{
pts[iDim] = input_phy_points(0, iDim);
}
BPoint pointBoundingBox;
pointBoundingBox.key.ident = 123; // FIXME for multiple points
pointBoundingBox.set_center(pts);
std::vector<BPoint> points(1, pointBoundingBox);
stk_classic::search::FactoryOrder order;
order.m_communicator = bulkData.parallel();
order.m_algorithm = stk_classic::search::FactoryOrder::BIHTREE;
if (0 || EXTRA_PRINT)
{
bool box_p = m_boxes[0].intersect(pointBoundingBox);
bool p_box = pointBoundingBox.intersect(m_boxes[0]);
std::cout << "STKSearcher::findElement: m_boxes[0]= " << m_boxes[0] << std::endl;
std::cout << "STKSearcher::findElement: pointBoundingBox= " << pointBoundingBox << std::endl;
std::cout << "STKSearcher::findElement: box_p= " << box_p << std::endl;
std::cout << "STKSearcher::findElement: p_box= " << p_box << std::endl;
}
if (0 || EXTRA_PRINT) std::cout << "STKSearcher::findElement: nboxes= " << m_boxes.size() << std::endl;
IdentProcRelation relation;
stk_classic::search::coarse_search(relation, m_boxes, points, order);
//stk_classic::search::coarse_search(relation, points, m_boxes, order);
if (0 || EXTRA_PRINT) std::cout << "STKSearcher::findElement: found " << relation.size() << " containing bboxes" << std::endl;
if (relation.size())
{
IsInElement isIn(input_phy_points, found_parametric_coordinates);
for (unsigned i = 0; i < relation.size(); i++)
{
if (0 || EXTRA_PRINT)
std::cout << "relation[ " << i << "]= {" << relation[i].first << "} --> { " << relation[i].second << "}" << std::endl;
mesh::Entity *element = bulkData.get_entity(metaData.element_rank(), relation[i].second.ident);
//bool loop_break = ... intentionally ignoring return value
isIn(*element, bulkData);
if (0 || EXTRA_PRINT) std::cout << "STKSearcher::findElement: found it= " << isIn.m_found_it << std::endl;
if (isIn.m_found_it)
{
found_it = 1;
return isIn.m_foundElement;
}
else
{
found_it = 0;
return 0;
}
}
}
return 0;
}