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; }