TEST_F(PromoteElementHexTest, node_count)
{
int polyOrder = 7;
int nprocs = stk::parallel_machine_size(MPI_COMM_WORLD);
int nprocx = std::cbrt(nprocs+0.5);
if (nprocx*nprocx*nprocx != nprocs) {
return;
}
init(nprocx, nprocx, nprocx, polyOrder);
size_t originalNodeCount = ::count_nodes(*bulk, meta->universal_part());
stk::mesh::PartVector supElemParts;
stk::mesh::PartVector supSideParts;
promote_mesh();
EXPECT_EQ(expected_node_count(originalNodeCount), ::count_nodes(*bulk, meta->universal_part()));
bool outputMesh = false;
if (outputMesh) {
compute_dual_nodal_volume();
if (bulk->parallel_size() > 1) {
stk::mesh::parallel_sum(*bulk, {dnvField});
}
EXPECT_NO_THROW(output_mesh());
}
}
bool extract_boundary::run(viennamesh::algorithm_handle &)
{
mesh_handle input_mesh = get_required_input<mesh_handle>("mesh");
mesh_handle output_mesh = make_data<mesh_handle>();
point_container hole_points;
seed_point_container seed_points;
std::cerr << "Extract boundary of " << input_mesh.size() << " partitions" << std::endl;
//MY IMPLEMENTATION
output_mesh.resize(input_mesh.size());
for (size_t i = 0; i < input_mesh.size(); ++i)
{
hole_points.clear();
seed_points.clear();
input_mesh(i).set_full_layout();
viennagrid::extract_boundary( input_mesh(i), output_mesh(i), viennagrid::facet_dimension(input_mesh(i)) );
viennagrid::extract_seed_points( input_mesh(i), seed_points );
// viennagrid::extract_hole_points( input_mesh(), hole_points );
// set_output( "mesh", output_mesh ); //MY IMPLEMENTATION
// if (!hole_points.empty())
// {
// info(1) << "Extracted " << hole_points.size() << " hole points" << std::endl;
// for (point_container::const_iterator it = hole_points.begin(); it != hole_points.end(); ++it)
// info(1) << " " << *it << std::endl;
//
// point_handle output_hole_points = make_data<point>();
// output_hole_points.set( hole_points );
// set_output( "hole_points", output_hole_points );
// }
if (!seed_points.empty())
{
info(1) << "Extracted " << seed_points.size() << " seed points" << std::endl;
for (seed_point_container::const_iterator it = seed_points.begin(); it != seed_points.end(); ++it)
info(1) << " " << (*it).first << " -> " << (*it).second << std::endl;
seed_point_handle output_seed_points = make_data<seed_point>();
output_seed_points.set( seed_points );
set_output( "seed_points", output_seed_points );
}
}//end of for over input_mesh.size()
set_output( "mesh", output_mesh );
return true;
}
bool stretch_middle::run(viennamesh::algorithm_handle &)
{
mesh_handle input_mesh = get_required_input<mesh_handle>("mesh");
data_handle<double> stretch = get_required_input<double>("stretch");
data_handle<double> middle_tolerance = get_required_input<double>("middle_tolerance");
mesh_handle output_mesh = make_data<mesh_handle>();
if (output_mesh != input_mesh)
viennagrid::copy( input_mesh(), output_mesh() );
typedef viennagrid::mesh MeshType;
typedef viennagrid::result_of::point<MeshType>::type PointType;
typedef viennagrid::result_of::const_element_range<MeshType>::type ConstElementRangeType;
typedef viennagrid::result_of::iterator<ConstElementRangeType>::type ConstElementIteratorType;
ConstElementRangeType vertices( output_mesh(), 0 );
for (ConstElementIteratorType vit = vertices.begin(); vit != vertices.end(); ++vit)
{
PointType pt = viennagrid::get_point(*vit);
if (std::abs(pt[0]) >= middle_tolerance())
{
if (pt[0] < 0)
pt[0] -= stretch();
else
pt[0] += stretch();
}
viennagrid::set_point(*vit, pt);
}
set_output( "mesh", output_mesh );
return true;
}
bool uniform_refine::run(viennamesh::algorithm_handle &)
{
mesh_handle input_mesh = get_required_input<mesh_handle>("mesh");
if (!input_mesh.valid())
return false;
mesh_handle output_mesh = make_data<mesh_handle>();
if (output_mesh == input_mesh)
return false;
viennagrid::cell_refine_uniformly(input_mesh(), output_mesh());
set_output( "mesh", output_mesh );
return true;
}
bool map_regions::run(viennamesh::algorithm_handle &)
{
mesh_handle input_mesh = get_required_input<mesh_handle>("mesh");
string_handle input_region_mapping = get_required_input<string_handle>("region_mapping");
std::map<std::string, std::string> region_mapping;
{
std::string tmp = input_region_mapping();
std::list<std::string> mappings;
boost::algorithm::split( mappings, tmp, boost::is_any_of(";") );
// std::list<std::string> mappings = stringtools::split_string( input_region_mapping(), ";" );
for (std::list<std::string>::const_iterator sit = mappings.begin(); sit != mappings.end(); ++sit)
{
std::list<std::string> from_to;
boost::algorithm::split( from_to, *sit, boost::is_any_of(",") );
// std::list<std::string> from_to = stringtools::split_string( *sit, "," );
if (from_to.size() != 2)
{
return false;
}
std::list<std::string>::const_iterator it = from_to.begin();
std::string from = *it;
++it;
std::string to = *it;
region_mapping[from] = to;
}
}
for (std::map<std::string, std::string>::const_iterator it = region_mapping.begin(); it != region_mapping.end(); ++it)
{
info(1) << "Mapping region " << it->first << " to " << it->second << std::endl;
}
mesh_handle output_mesh = make_data<mesh_handle>();
map_regions_impl( input_mesh(), output_mesh(), region_mapping );
set_output( "mesh", output_mesh );
return true;
}
TEST_F(PromoteElementHexTest, png)
{
if (stk::parallel_machine_size(MPI_COMM_WORLD) > 48) {
return;
}
double tol = 1.0e-8;
int polyOrder = 4;
init(3, 2, 8, polyOrder);
promote_mesh();
double exactGradMag = initialize_linear_scalar_field();
stk::mesh::field_fill(0.0, *dnvField);
compute_dual_nodal_volume();
if (bulk->parallel_size() > 1) {
stk::mesh::parallel_sum(*bulk, {dnvField});
}
stk::mesh::field_fill(0.0, *dqdxField);
compute_projected_nodal_gradient_interior();
compute_projected_nodal_gradient_boundary();
if (bulk->parallel_size() > 1) {
stk::mesh::parallel_sum(*bulk, {dqdxField});
}
const auto& buckets = bulk->get_buckets(stk::topology::NODE_RANK, stk::mesh::selectUnion(superParts));
sierra::nalu::bucket_loop(buckets, [&](stk::mesh::Entity node) {
const double* dqdx = stk::mesh::field_data(*dqdxField, node);
double dqdxMag = std::sqrt(dqdx[0] * dqdx[0] + dqdx[1] * dqdx[1]+dqdx[2]*dqdx[2]);
EXPECT_NEAR(dqdxMag, exactGradMag, tol);
});
bool outputMesh = false;
if (outputMesh) {
EXPECT_NO_THROW(output_mesh());
}
}
bool check_hull_topology::run(viennamesh::algorithm_handle &)
{
mesh_handle input_mesh = get_required_input<mesh_handle>("mesh");
mesh_handle output_mesh = make_data<mesh_handle>();
typedef viennagrid::mesh MeshType;
typedef viennagrid::result_of::const_element_range<MeshType>::type ConstElementRangeType;
typedef viennagrid::result_of::iterator<ConstElementRangeType>::type ConstElementIteratorType;
typedef viennagrid::result_of::const_coboundary_range<MeshType>::type ConstCoboundaryElementRangeType;
typedef viennagrid::result_of::iterator<ConstCoboundaryElementRangeType>::type ConstCoboundaryElementIteratorType;
viennagrid::result_of::element_copy_map<>::type copy_map(output_mesh(), true);
ConstElementRangeType lines( input_mesh(), 1 );
for (ConstElementIteratorType lit = lines.begin(); lit != lines.end(); ++lit)
{
ConstCoboundaryElementRangeType coboundary_triangles( input_mesh(), *lit, 2 );
if (coboundary_triangles.size() < 2)
{
std::cout << "Line " << *lit << " has less than 2 co-boundary triangles" << std::endl;
for (ConstCoboundaryElementIteratorType ctit = coboundary_triangles.begin(); ctit != coboundary_triangles.end(); ++ctit)
{
copy_map(*ctit);
}
}
}
set_output( "mesh", output_mesh );
return true;
}
bool chessboard_coloring::run(viennamesh::algorithm_handle &)
{
viennamesh::info(1) << name() << std::endl;
//get input mesh and create output mesh
mesh_handle input_mesh = get_required_input<mesh_handle>("mesh");
mesh_handle output_mesh = make_data<mesh_handle>();
//Typedefs
typedef viennagrid::mesh MeshType;
// typedef viennagrid::result_of::element<MeshType>::type VertexType;
typedef viennagrid::result_of::element<MeshType>::type EdgeType;
typedef viennagrid::result_of::element<MeshType>::type TriangleType;
//typedef viennagrid::result_of::element_range<MeshType, 0>::type VertexRange;
typedef viennagrid::result_of::element_range<MeshType, 2>::type TriangleRange;
typedef viennagrid::result_of::iterator<TriangleRange>::type TriangleIterator;
typedef viennagrid::result_of::neighbor_range<MeshType, 1, 2>::type TriangleNeighborRangeType;
typedef viennagrid::result_of::iterator<TriangleNeighborRangeType>::type TriangleNeighborIterator;
//get number of vertices and triangles
int num_vertices = viennagrid::vertex_count(input_mesh());
int num_triangles = viennagrid::element_count(input_mesh(), 2);
/*
viennamesh::info(2) << "Number of vertices in mesh : " << num_vertices << std::endl;
viennamesh::info(2) << "Number of triangles in mesh: " << num_triangles << std::endl;
*/
//set up accessor
std::vector<bool> color_triangles(num_triangles, false);
std::vector<bool> touched (num_triangles, false);
viennagrid::result_of::accessor<std::vector<bool>, TriangleType>::type color_accessor(color_triangles);
//set first element to color "black" (BOOL = TRUE)
color_accessor.set(viennagrid::cells(input_mesh())[0], true);
//iterate triangles in mesh
TriangleRange triangles(input_mesh());
//Iterate over all triangles in the mesh
viennagrid_element_id * triangle_ids_begin;
viennagrid_element_id * triangle_ids_end;
viennagrid_dimension topological_dimension = viennagrid::cell_dimension( input_mesh() );
viennagrid_element_id * neighbor_begin;
viennagrid_element_id * neighbor_end;
viennagrid_dimension connector = 1;
viennagrid_mesh_elements_get(input_mesh().internal(), topological_dimension, &triangle_ids_begin, &triangle_ids_end);
viennagrid::quantity_field color_field(2,1);
// viennagrid_quantity_field_create(&color_field);
color_field.set_name("color");
//viennagrid_quantity_field_init(color_field, 2, VIENNAGRID_QUANTITY_FIELD_TYPE_NUMERIC, 1 , VIENNAGRID_QUANTITY_FIELD_STORAGE_DENSE);
//get triangles from mesh
for (viennagrid_element_id *tri = triangle_ids_begin; tri != triangle_ids_end; ++tri)
{
int tri_index = viennagrid_index_from_element_id( *tri );
//std::cout << tri_index << std::endl;
if ( !touched[tri_index])
{
//color_accessor.set(viennagrid::cells(input_mesh())[tri_index], true);
color_triangles[tri_index] = true;
touched[tri_index] = true;
double clr = 1;
color_field.set(*tri, clr);
viennagrid_element_neighbor_elements(input_mesh().internal(), *tri, 0, 2, &neighbor_begin, &neighbor_end);
for (viennagrid_element_id *n_tri = neighbor_begin; n_tri != neighbor_end; ++n_tri)
{
int n_tri_index = viennagrid_index_from_element_id( *n_tri );
//std::cout << " " << n_tri_index << std::endl;
viennagrid_element_id * n_neighbor_begin;
viennagrid_element_id * n_neighbor_end;
viennagrid_element_neighbor_elements(input_mesh().internal(), *n_tri, 0, 2, &n_neighbor_begin, &n_neighbor_end);
for (viennagrid_element_id *n_n_tri = n_neighbor_begin; n_n_tri != n_neighbor_end; ++n_n_tri)
{
int n_n_tri_index = viennagrid_index_from_element_id( *n_n_tri );
if ( !touched[n_n_tri_index])
{
//color_accessor.set(viennagrid::cells(input_mesh())[n_tri_index], false);
touched[n_n_tri_index] = true;
clr = 0;
color_field.set(*n_n_tri, clr);
}
}
}
}
}
output_mesh = input_mesh;
quantity_field_handle quantities = make_data<viennagrid::quantity_field>();
quantities.set(color_field);
set_output("color_field", quantities);
set_output("mesh", output_mesh());
return true;
} //end of bool chessboard_coloring::run(viennamesh::algorithm_handle &)
bool tdr_reader::run(viennamesh::algorithm_handle &)
{
string_handle filename = get_required_input<string_handle>("filename");
std::string path = base_path();
std::string full_filename;
if (!path.empty())
{
info(1) << "Using base path: " << path << std::endl;
full_filename = path + "/" + filename();
}
else
full_filename = filename();
shared_ptr<H5File> file( new H5File(full_filename.c_str(), H5F_ACC_RDWR) );
if (file->getNumObjs()!=1)
{
error(1) << "File has not exactly one collection (number of collections = " << file->getNumObjs() << std::endl;
return false;
}
tdr_geometry geometry;
geometry.read_collection(file->openGroup("collection"));
geometry.correct_vertices();
bool extrude_contacts = true;
if ( get_input<bool>("extrude_contacts").valid() )
extrude_contacts = get_input<bool>("extrude_contacts")();
double extrude_contacts_scale = 1.0;
if ( get_input<double>("extrude_contacts_scale").valid() )
extrude_contacts_scale = get_input<double>("extrude_contacts_scale")();
mesh_handle output_mesh = make_data<mesh_handle>();
geometry.to_viennagrid( output_mesh(), extrude_contacts, extrude_contacts_scale );
if ( get_input<bool>("fill_triangle_contacts").valid() && get_input<bool>("fill_triangle_contacts")() )
fill_triangle_contacts( output_mesh() );
std::vector<viennagrid::quantity_field> quantity_fields = geometry.quantity_fields( output_mesh() );
if (!quantity_fields.empty())
{
quantity_field_handle output_quantity_fields = make_data<viennagrid::quantity_field>();
output_quantity_fields.resize( quantity_fields.size() );
for (std::size_t i = 0; i != quantity_fields.size(); ++i)
output_quantity_fields.set(i, quantity_fields[i]);
set_output( "quantities", output_quantity_fields );
}
set_output("mesh", output_mesh);
return true;
}
bool merge_meshes::run(viennamesh::algorithm_handle &)
{
mesh_handle output_mesh = make_data<mesh_handle>();
mesh_handle input_mesh = get_input<mesh_handle>("mesh");
bool region_offset = true;
if ( get_input<bool>("region_offset").valid() )
region_offset = get_input<bool>("region_offset")();
double tolerance = 1e-6;
if ( get_input<double>("tolerance").valid() )
tolerance = get_input<double>("tolerance")();
info(1) << "Using region offset: " << std::boolalpha << region_offset << std::endl;
int merged_count = 0;
if (input_mesh.valid())
{
int mesh_count = input_mesh.size();
for (int i = 0; i != mesh_count; ++i)
{
merge_meshes_impl( input_mesh(i), output_mesh(), (merged_count == 0 ? -1 : tolerance), region_offset );
++merged_count;
}
}
int mesh_index = 0;
while (true)
{
std::string input_name = "mesh" + boost::lexical_cast<std::string>(mesh_index);
mesh_handle another_input_mesh = get_input<mesh_handle>(input_name);
if (!another_input_mesh.valid())
break;
int mesh_count = another_input_mesh.size();
for (int i = 0; i != mesh_count; ++i)
{
merge_meshes_impl( another_input_mesh(i), output_mesh(), (merged_count == 0 ? -1 : tolerance), region_offset );
++merged_count;
}
++mesh_index;
}
//
// if (input_mesh)
// merge_meshes_impl( input_mesh(), output_mesh() );
//
// int index = 0;
// input_mesh = get_input<mesh_handle>("mesh[" + lexical_cast<std::string>(index++) + "]");
// while (input_mesh)
// {
// merge_meshes_impl( input_mesh(), output_mesh() );
// input_mesh = get_input<mesh_handle>("mesh[" + lexical_cast<std::string>(index++) + "]");
// }
info(1) << "Merged " << merged_count << " meshes" << std::endl;
set_output( "mesh", output_mesh );
return true;
}
void Stitch_Meshes::stitch_meshes()
{
homemade_assert_msg(m_bGridPreallocated,"Grid not preallocated!\n");
// -> Third, stitch the meshes
libMesh::ReplicatedMesh temp_mesh(m_world_comm,3);
temp_mesh.allow_renumbering(false);
unsigned int full_mesh_nb_elems = 0;
unsigned int full_mesh_nb_nodes = 0;
libMesh::Elem * copy_elem = NULL;
libMesh::Elem * mesh_elem = NULL;
libMesh::Node * mesh_node = NULL;
double dummy_volume = 0;
// -> Stitch!
for(unsigned int iii = 0; iii < m_nb_files; ++iii)
{
// -> Open mesh file
temp_mesh.read(m_mesh_filenames[iii]);
// -> Insert nodes
libMesh::ReplicatedMesh::element_iterator it_mesh = temp_mesh.elements_begin();
for( ; it_mesh != temp_mesh.elements_end(); ++it_mesh)
{
copy_elem = * it_mesh;
// -> Each element is unique, so no tests for insertion
mesh_elem = libMesh::Elem::build(libMesh::TET4).release();
mesh_elem->set_id(full_mesh_nb_elems);
mesh_elem->processor_id(0);
// -> First, add the nodes
for(unsigned int jjj = 0; jjj < 4; ++jjj)
{
convert_to_discrete(copy_elem->point(jjj),m_dummy_discrete_point);
if(m_discrete_vertices.find(m_dummy_discrete_point) == m_discrete_vertices.end())
{
// New vertex! Add it to the mesh
m_discrete_vertices[m_dummy_discrete_point] = full_mesh_nb_nodes;
mesh_node = m_Stitched_mesh.add_point(copy_elem->point(jjj),full_mesh_nb_nodes,0);
++full_mesh_nb_nodes;
}
else
{
mesh_node = m_Stitched_mesh.node_ptr(m_discrete_vertices[m_dummy_discrete_point]);
}
// Associate vertex to the new element
mesh_elem->set_node(jjj) = mesh_node;
}
m_Stitched_mesh.add_elem(mesh_elem);
dummy_volume += mesh_elem->volume();
++full_mesh_nb_elems;
}
}
// Print information about the number of collisions
if(m_bPrintDebug)
{
size_t collisions = 0;
for (size_t bucket = 0; bucket != m_discrete_vertices.bucket_count(); ++bucket)
{
if (m_discrete_vertices.bucket_size(bucket) > 1)
{
collisions += m_discrete_vertices.bucket_size(bucket) - 1;
}
}
std::cout << " DEBUG: discrete grid hash collisions" << std::endl;
std::cout << " -> Nb. of collisions / size : " << collisions << " / " << m_discrete_vertices.size()
<< " (" << 100.*collisions/m_discrete_vertices.size() << "%)" << std::endl << std::endl;
}
m_Stitched_mesh.prepare_for_use();
// Print mesh
libMesh::NameBasedIO output_mesh(m_Stitched_mesh);
output_mesh.write(m_mesh_output);
if(m_bPrintDebug)
{
std::cout << " DEBUG: stitched mesh" << std::endl;
std::cout << " -> Volume : " << dummy_volume << std::endl << std::endl;
}
int wrong_volume = 0;
libMesh::ReplicatedMesh::element_iterator elem_begin = m_Stitched_mesh.local_elements_begin();
libMesh::ReplicatedMesh::element_iterator elem_end = m_Stitched_mesh.local_elements_end();
for( ; elem_begin != elem_end; ++elem_begin)
{
libMesh::Elem * dummy_elem = * elem_begin;
if(std::abs(dummy_elem->volume()) < m_vol_tol)
{
++wrong_volume;
}
}
std::cout << " -> bad volumes : " << wrong_volume << " ( " << m_vol_tol << " ) " << std::endl;
};
bool center_mesh::run(viennamesh::algorithm_handle &)
{
mesh_handle input_mesh = get_input<mesh_handle>("mesh");
if (input_mesh.valid())
{
mesh_handle output_mesh = make_data<mesh_handle>();
typedef viennagrid::mesh MeshType;
typedef viennagrid::result_of::point<MeshType>::type PointType;
typedef viennagrid::result_of::const_vertex_range<MeshType>::type ConstVertexRangeType;
typedef viennagrid::result_of::iterator<ConstVertexRangeType>::type ConstVertexRangeIterator;
viennagrid::copy( input_mesh(), output_mesh() );
PointType mesh_centroid = viennagrid::centroid( output_mesh() );
info(1) << "Mesh centroid " << mesh_centroid << std::endl;
ConstVertexRangeType vertices( output_mesh() );
for (ConstVertexRangeIterator vit = vertices.begin(); vit != vertices.end(); ++vit)
viennagrid::set_point( *vit, viennagrid::get_point(*vit) - mesh_centroid );
set_output( "mesh", output_mesh );
}
data_handle<viennagrid_plc> input_geometry = get_input<viennagrid_plc>("geometry");
if (input_geometry.valid())
{
data_handle<viennagrid_plc> output_geometry = make_data<viennagrid_plc>();
viennagrid_dimension geometric_dimension;
viennagrid_plc_geometric_dimension_get( input_geometry(), &geometric_dimension );
viennagrid_numeric * src_coords;
viennagrid_plc_vertex_coords_pointer( input_geometry(), &src_coords );
viennagrid_int vertex_count;
viennagrid_plc_element_count( input_geometry(), 0, &vertex_count );
std::vector<viennagrid_numeric> center( geometric_dimension, 0 );
for (viennagrid_int i = 0; i != vertex_count; ++i)
{
for (viennagrid_dimension d = 0; d != geometric_dimension; ++d)
center[d] += src_coords[ geometric_dimension*i + d ];
}
for (viennagrid_dimension d = 0; d != geometric_dimension; ++d)
center[d] /= vertex_count;
viennagrid_plc_copy( input_geometry(), output_geometry() );
viennagrid_numeric * dst_coords;
viennagrid_plc_vertex_coords_pointer( output_geometry(), &dst_coords );
for (viennagrid_int i = 0; i != vertex_count; ++i)
{
for (viennagrid_dimension d = 0; d != geometric_dimension; ++d)
dst_coords[ geometric_dimension*i + d ] -= center[d];
}
set_output( "geometry", output_geometry );
}
return true;
}
