Flow123d
JS_before_hm-1717-gd762018d2
|
Go to the documentation of this file.
21 #include <unordered_map>
67 "Use BIH for finding initial candidates, then continue by prolongation.")
69 "Use BIH for finding all candidates.")
71 "Use bounding boxes for finding initial candidates, then continue by prolongation.")
76 return IT::Record(
"Mesh",
"Record with mesh related data." )
79 "Input file with mesh description.")
81 "List of additional region and region set definitions not contained in the mesh. "
82 "There are three region sets implicitly defined:\n\n"
83 "- ALL (all regions of the mesh)\n"
84 "- .BOUNDARY (all boundary regions)\n"
85 "- BULK (all bulk regions)")
89 IT::Default(
"\"BIHsearch\""),
"Search algorithm for element intersections.")
91 "Maximal snapping distance from the mesh in various search operations. In particular, it is used "
92 "to find the closest mesh element of an observe point; and in FieldFormula to find closest surface "
93 "element in plan view (Z projection).")
95 "Output file with neighboring data from mesh.")
97 "This will speed up the calculations in assembations.")
110 node_4_loc_(nullptr),
120 in_record_(in_record),
127 node_4_loc_(nullptr),
133 istringstream is(
"{mesh_file=\"\"}");
175 for(
int dim=0; dim < 3; dim++) {
177 for(
int i_side=0; i_side < dim+2; i_side++)
181 for (
unsigned int sid=0; sid<RefElement<1>::n_sides; sid++)
182 for (
unsigned int nid=0; nid<RefElement<1>::n_nodes_per_side; nid++)
185 for (
unsigned int sid=0; sid<RefElement<2>::n_sides; sid++)
186 for (
unsigned int nid=0; nid<RefElement<2>::n_nodes_per_side; nid++)
189 for (
unsigned int sid=0; sid<RefElement<3>::n_sides; sid++)
190 for (
unsigned int nid=0; nid<RefElement<3>::n_nodes_per_side; nid++)
197 if (edg.side_)
delete[] edg.side_;
199 for (
unsigned int idx=0; idx <
bulk_size_; idx++) {
235 unsigned int li, count = 0;
237 for (li=0; li<ele->n_nodes(); li++) {
247 return Edge(
this, edge_idx);
271 switch (elm->dim()) {
290 std::string reg_name =
"UndefinedRegion";
293 dim_to_check = ele.
dim();
297 for (
auto elem_to_region :
map) {
300 if( ele.
dim() != dim_to_check){
301 THROW(ExcRegionElmDiffDim() << EI_Region(reg_name) << EI_RegIdx(elem_to_region.second) << EI_Dim(dim_to_check)
302 << EI_DimOther(ele.
dim()) << EI_ElemId(elem_to_region.first) );
317 double quality = ele.quality_measure_smooth();
319 WarningOut().fmt(
"Bad quality (<0.001) of the element {}.\n", ele.idx());
322 for (
uint ele_node=0; ele_node<ele->n_nodes(); ele_node++) {
323 uint inode = ele->node_idx(ele_node);
324 nodes_new_idx[inode] = inode;
334 for(
uint inode = 0; inode < nodes_new_idx.size(); inode++) {
336 WarningOut().fmt(
"A node {} does not belong to any element "
337 " and will be removed.",
342 nodes_new_idx[inode] = inode_new;
352 uint n_nodes_new = inode_new;
355 if(n_nodes_new < nodes_new_idx.size()){
357 DebugOut() <<
"Updating node-element numbering due to unused nodes: "
366 for (
uint ele_node=0; ele_node<ele->n_nodes(); ele_node++) {
367 uint inode_orig = ele->node_idx(ele_node);
368 uint inode = nodes_new_idx[inode_orig];
370 const_cast<Element*
>(ele.element())->
nodes_[ele_node] = inode;
401 id_4_old[i++] = ele.idx();
468 for (
unsigned int n=0; n<ele->n_nodes(); n++)
472 stable_sort(n->begin(), n->end());
482 if (nodes_list.size() == 0) {
483 intersection_element_list.clear();
484 }
else if (nodes_list.size() == 1) {
491 it1=set_intersection(
494 intersection_element_list.begin());
495 intersection_element_list.resize(it1-intersection_element_list.begin());
497 for(;it2<nodes_list.end();++it2) {
498 it1=set_intersection(
499 intersection_element_list.begin(), intersection_element_list.end(),
501 intersection_element_list.begin());
502 intersection_element_list.resize(it1-intersection_element_list.begin());
509 bool is_neighbour =
false;
517 if (is_neighbour)
THROW(ExcTooMatchingIds() << EI_ElemId(this->
elem_index(*ele)) << EI_ElemIdOther(this->
elem_index(element_idx)) );
523 element_list.resize( e_dest - element_list.begin());
532 return ( ni == si->
n_nodes() );
547 .error(
"Temporary structure of boundary element data is not empty. Did you call create_boundary_elements?");
551 unsigned int ngh_element_idx;
554 neighbour.
mesh_ =
this;
575 THROW( ExcBdrElemMatchRegular() << EI_ElemId(bc_ele.
idx()) << EI_ElemIdOther(this->
elem_index(ngh_element_idx)) );
577 if (intersection_list.size() == 0) {
579 WarningOut().fmt(
"Lonely boundary element, id: {}, region: {}, dimension {}.\n",
583 last_edge_idx=
edges.size();
584 edges.resize(last_edge_idx+1);
585 edg = &(
edges.back() );
587 edg->
side_ =
new struct SideIter[ intersection_list.size() ];
601 for (
unsigned int ecs=0; ecs<elem->
n_sides(); ecs++) {
607 int new_bc_ele_idx=i;
608 THROW( ExcDuplicateBoundary()
635 for (
unsigned int s=0; s<e->n_sides(); s++)
643 for (
unsigned n=0; n<e.side(s)->
n_nodes(); n++)
side_nodes[n] = e.side(s)->node(n).idx();
653 last_edge_idx=
edges.size();
654 edges.resize(last_edge_idx+1);
655 edg = &(
edges.back() );
657 edg->
side_ =
new struct SideIter[ intersection_list.size() ];
661 if (intersection_list.size() == 1) {
665 edg->
side_[0] = e.side(s);
668 if (e->boundary_idx_ == NULL) {
699 for (
unsigned int ecs=0; ecs<elem->
n_sides(); ecs++) {
705 last_edge_idx=
edges.size();
706 edges.resize(last_edge_idx+1);
707 edg = &(
edges.back() );
729 ASSERT_EQ( (
unsigned int) edg->
n_sides, intersection_list.size())(e.index())(s).error(
"Missing edge sides.");
742 std::unordered_map<unsigned int,unsigned int> node_numbers;
746 unsigned int n_side_nodes = edg.side(0)->n_nodes();
748 edg.side(0)->element()->permutation_idx_[edg.side(0)->side_idx()] = 0;
750 if (edg.n_sides() > 1)
753 unsigned int permutation[n_side_nodes];
756 node_numbers.clear();
757 for (
uint i=0; i<n_side_nodes; i++)
758 node_numbers[edg.side(0)->node(i).idx()] = i;
760 for (
uint sid=1; sid<edg.n_sides(); sid++)
762 for (
uint i=0; i<n_side_nodes; i++)
763 permutation[node_numbers[edg.side(sid)->node(i).idx()]] = i;
765 switch (edg.side(0)->dim())
785 unsigned int n_side_nodes = nb->element()->n_nodes();
786 unsigned int permutation[n_side_nodes];
787 node_numbers.clear();
791 for (
unsigned int i=0; i<n_side_nodes; i++)
792 node_numbers[nb->element().node(i).idx()] = i;
794 for (
unsigned int i=0; i<n_side_nodes; i++)
795 permutation[node_numbers[nb->side()->node(i).idx()]] = i;
797 switch (nb->side()->dim())
814 Edge edg = this->
edge(bdr->edge_idx_);
819 unsigned int n_side_nodes = bdr_elm->
n_nodes();
820 unsigned int permutation[n_side_nodes];
821 node_numbers.clear();
825 for (
unsigned int i=0; i<n_side_nodes; i++) {
826 node_numbers[bdr_elm.
node(i).idx()] = i;
831 for (
uint i=0; i<n_side_nodes; i++) {
832 permutation[node_numbers[edg.
side(sid)->
node(i).idx()]] = i;
835 switch (bdr_elm.
dim())
864 ele->n_neighs_vb_ =0;
867 for (
auto & ngh : this->
vb_neighbours_) ngh.element()->n_neighs_vb_++;
871 if( ele->n_neighs_vb() > 0 ) {
872 ele->neigh_vb =
new struct Neighbour* [ele->n_neighs_vb()];
878 for (
auto & ngh : this->vb_neighbours_) {
900 intersections = std::make_shared<MixedMeshIntersections>(
this);
922 if (bulk_elements_id.size() ==0) {
927 map_it = bulk_elements_id.begin();
929 for(
unsigned int idx=0; idx <
n_elements(); idx++, ++map_it) {
931 last_id=*map_it = id;
933 std::sort(bulk_elements_id.begin(), bulk_elements_id.end());
936 map_it = boundary_elements_id.begin();
943 if (
id < 0) last_id=*map_it=-1;
945 if (last_id >=
id)
THROW( ExcElmWrongOrder() << EI_ElemId(
id) );
946 last_id=*map_it = id;
954 static const double point_tolerance = 1E-10;
955 return fabs(p1[0]-p2[0]) < point_tolerance
956 && fabs(p1[1]-p2[1]) < point_tolerance
957 && fabs(p1[2]-p2[2]) < point_tolerance;
968 std::shared_ptr<std::vector<LongIdx>> map_ptr = std::make_shared<std::vector<LongIdx>>(
element_vec_.size());
976 unsigned int i_node, i_elm_node;
988 for (i_node=0; i_node<ele->
n_nodes(); i_node++)
990 static const double point_tolerance = 1E-10;
991 if ( arma::norm(*ele.
node(i_node) - *nod, 1) < point_tolerance) {
992 i_elm_node = ele.
node(i_node).idx();
994 else if (found_i_node != i_elm_node) {
996 return std::make_shared<std::vector<LongIdx>>(0);
1002 searched_elements.clear();
1012 unsigned int n_found=0;
1016 for (
unsigned int j=0; j<elm->n_nodes(); j++) {
1017 if (node_ids[ elm->node_idx(j) ] ==
Mesh::undef_idx) valid_nodes =
false;
1018 node_list.push_back( node_ids[ elm->node_idx(j) ] );
1022 for (
auto i_elm : candidate_list) {
1023 if ( input_mesh.
element_accessor(i_elm)->
dim() == elm.dim() ) result_list.push_back(i_elm);
1026 if (result_list.size() == 1) {
1027 element_ids_map[i] = (
LongIdx)result_list[0];
1033 result_list.clear();
1039 return std::make_shared<std::vector<LongIdx>>(0);
1053 for (
auto elm : bc_mesh->elements_range()) {
1055 for (
unsigned int j=0; j<elm->n_nodes(); j++) {
1056 if (node_ids[ elm->node_idx(j) ] ==
Mesh::undef_idx) valid_nodes =
false;
1057 node_list.push_back( node_ids[ elm->node_idx(j) ] );
1060 input_bc_mesh->intersect_element_lists(node_list, candidate_list);
1061 for (
auto i_elm : candidate_list) {
1062 if ( input_bc_mesh->element_accessor(i_elm)->dim() == elm.dim() ) result_list.push_back(i_elm);
1065 if (result_list.size() == 1) {
1066 element_ids_map[i] = (
LongIdx)result_list[0];
1071 result_list.clear();
1081 static const double point_tolerance = 1E-10;
1082 if (elm1.
dim() != elm2.
dim())
return false;
1084 for (
unsigned int i=0; i<elm1->
n_nodes(); i++) {
1086 for (
unsigned int j=0; j<elm2->
n_nodes(); j++) {
1087 if ( arma::norm(*elm1.
node(i) - *elm2.
node(j), 1) < point_tolerance)
1090 if (!equal_node)
return false;
1100 std::shared_ptr<std::vector<LongIdx>> map_ptr = std::make_shared<std::vector<LongIdx>>(
element_vec_.size());
1111 unsigned int n_found=0;
1114 for (
auto s : searched_elements) {
1116 if (
equal_elm(elm, acc) ) result_list.push_back(s);
1119 if (result_list.size() == 1) {
1120 element_ids_map[i] = (
LongIdx)result_list[0];
1125 result_list.clear();
1126 searched_elements.clear();
1132 return std::make_shared<std::vector<LongIdx>>(0);
1145 for (
auto elm : bc_mesh->elements_range()) {
1147 for (
auto s : searched_elements) {
1149 if (
equal_elm(elm, acc) ) result_list.push_back(s);
1151 if (result_list.size() == 1) {
1152 element_ids_map[i] = (
LongIdx)result_list[0];
1156 result_list.clear();
1157 searched_elements.clear();
1169 it != region_list.
end();
1208 bih_tree_ = std::make_shared<BIHTree>();
1232 void Mesh::add_element(
unsigned int elm_id,
unsigned int dim,
unsigned int region_id,
unsigned int partition_id,
1244 WarningOut().fmt(
"Bulk elements of zero size(dim=0) are not supported. Element ID: {}.\n", elm_id);
1249 this->
init_element(ele, elm_id, dim, region_idx, partition_id, node_ids);
1257 ele->
init(dim, region_idx);
1258 ele->
pid_ = partition_id;
1260 for (
unsigned int ni=0; ni<ele->
n_nodes(); ni++) {
1270 WarningOut().fmt(
"Tetrahedron element with id {} has wrong numbering or is degenerated (Jacobian = {}).",elm_id, jac);
1328 auto bgn_it = make_iter<Edge>(
Edge(
this, 0) );
1329 auto end_it = make_iter<Edge>(
Edge(
this,
edges.size()) );
1348 ofstream raw_ngh_output_file;
1352 MessageOut() <<
"Opening raw ngh output: " << raw_output_file_path <<
"\n";
1354 raw_output_file_path.
open_stream(raw_ngh_output_file);
1358 if (! raw_ngh_output_file.is_open())
return;
1361 raw_ngh_output_file <<
"// fields:\n//ele_id n_sides ns_side_neighbors[n] neighbors[n*ns] n_vb_neighbors vb_neighbors[n_vb]\n";
1367 unsigned int undefined_ele_id = -1;
1370 if(ele->n_neighs_vb() > 0){
1371 for (
unsigned int i = 0; i < ele->n_neighs_vb(); i++){
1374 auto search = neigh_vb_map.find(higher_ele.
idx());
1375 if(search != neigh_vb_map.end()){
1377 search->second[ele->neigh_vb[i]->side()->side_idx()] = ele.idx();
1382 higher_ele_side_ngh[ele->neigh_vb[i]->side()->side_idx()] = ele.idx();
1383 neigh_vb_map[higher_ele.
idx()] = higher_ele_side_ngh;
1390 raw_ngh_output_file << ele.idx() <<
" ";
1391 raw_ngh_output_file << ele->n_sides() <<
" ";
1393 auto search_neigh = neigh_vb_map.end();
1394 for (
unsigned int i = 0; i < ele->n_sides(); i++) {
1395 unsigned int n_side_neighs = ele.side(i)->edge().n_sides()-1;
1397 if(n_side_neighs == 0){
1399 if(search_neigh == neigh_vb_map.end())
1400 search_neigh = neigh_vb_map.find(ele.idx());
1402 if(search_neigh != neigh_vb_map.end())
1403 if(search_neigh->second[i] != undefined_ele_id)
1406 raw_ngh_output_file << n_side_neighs <<
" ";
1409 for (
unsigned int i = 0; i < ele->n_sides(); i++) {
1418 else if(search_neigh != neigh_vb_map.end()
1419 && search_neigh->second[i] != undefined_ele_id){
1420 raw_ngh_output_file << search_neigh->second[i] <<
" ";
1425 raw_ngh_output_file << ele->n_neighs_vb() <<
" ";
1426 for (
unsigned int i = 0; i < ele->n_neighs_vb(); i++)
1427 raw_ngh_output_file << ele->neigh_vb[i]->side()->element().idx() <<
" ";
1429 raw_ngh_output_file << endl;
1432 raw_ngh_output_file <<
"$EndFlowField\n" << endl;
1441 e_data.partition_id, e_data.node_ids);
1455 std::array<unsigned int, 4> tmp_nodes;
1459 for(
unsigned int i=0; i<elem.
n_nodes(); i++)
1461 tmp_nodes[i] = elem.
nodes_[permutation_vec[i]];
1472 std::array<unsigned int, 4> tmp_nodes;
1476 for(
unsigned int i=0; i<elem.
n_nodes(); i++)
1478 tmp_nodes[i] = elem.
nodes_[permutation_vec[i]];
1491 ASSERT_PTR(
el_4_loc).error(
"Array 'el_4_loc' is not initialized. Did you call Partitioning::id_maps?\n");
1493 unsigned int i_proc, i_node, i_ghost_node, elm_node;
1494 unsigned int my_proc =
el_ds->
myp();
1495 unsigned int n_proc =
el_ds->
np();
1503 i_proc = elm.proc();
1504 for (elm_node=0; elm_node<elm->n_nodes(); elm_node++) {
1505 i_node = elm->node_idx(elm_node);
1506 if (i_proc == my_proc) local_node_flag[i_node] =
true;
1507 if (i_proc < node_proc[i_node]) node_proc[i_node] = i_proc;
1513 for(
uint i_proc : node_proc) {
1514 if (i_proc == my_proc)
1516 else if (i_proc == n_proc)
1517 ASSERT(0)(
find_node_id(n_own_nodes)).error(
"A node does not belong to any element!");
1524 i_ghost_node = n_own_nodes;
1525 for (
unsigned int i=0; i<this->
n_nodes(); ++i) {
1526 if (local_node_flag[i]) {
1527 if (node_proc[i]==my_proc)
Edge edge() const
Returns pointer to the edge connected to the side.
void calculate_node_curve_values_as_hilbert()
unsigned int create_boundary_elements()
Create boundary elements from data of temporary structure, this method MUST be call after read mesh f...
unsigned int np() const
get num of processors
void permute_triangle(unsigned int elm_idx, std::vector< unsigned int > permutation_vec)
Permute nodes of 2D elements of given elm_idx.
static unsigned int permutation_index(unsigned int p[n_nodes_per_side])
Class RefElement defines numbering of vertices, sides, calculation of normal vectors etc.
Armor::Array< double > nodes_
virtual std::shared_ptr< std::vector< LongIdx > > check_compatible_discont_mesh(Mesh &input_mesh)
Mesh * mesh_
Pointer to Mesh to which belonged.
std::vector< int > sort_elements(std::vector< unsigned int > &elem_permutation)
void permute_tetrahedron(unsigned int elm_idx, std::vector< unsigned int > permutation_vec)
Permute nodes of 3D elements of given elm_idx.
std::string label() const
Returns label of the region (using RegionDB)
static const Input::Type::Selection & get_input_intersection_variant()
The definition of input record for selection of variant of file format.
std::vector< BoundingBox > get_element_boxes()
Compute bounding boxes of elements contained in mesh.
unsigned int edge_idx_
Index of Edge in Mesh.
double tetrahedron_jacobian() const
LongIdx * node_4_loc_
Index set assigning to local node index its global index.
void init_element_vector(unsigned int size)
Initialize element_vec_, set size and reset counters of boundary and bulk elements.
static const unsigned int undef_idx
unsigned int elem_idx_
Index of element in Mesh::element_vec_.
void init_element(Element *ele, unsigned int elm_id, unsigned int dim, RegionIdx region_idx, unsigned int partition_id, std::vector< unsigned int > node_ids)
Initialize element.
unsigned int myp() const
get my processor
static Input::Type::Abstract & get_input_type()
void calculate_element_curve_values_as_hilbert_of_centers()
#define ASSERT(expr)
Allow use shorter versions of macro names if these names is not used with external library.
virtual Range< ElementAccessor< 3 > > elements_range() const
Returns range of bulk elements.
unsigned int n_sides() const
Support classes for parallel programing.
unsigned int n_sides() const
Returns number of sides aligned with the edge.
Main class for computation of intersection of meshes of combined dimensions.
bool compare_points(const arma::vec3 &p1, const arma::vec3 &p2)
unsigned int boundary_loaded_size_
Count of boundary elements loaded from mesh file.
ArmaVec< Type, nr > vec(uint mat_index) const
vector< Element > element_vec_
int pid_
Id # of mesh partition.
Dedicated class for storing path to input and output files.
bool is_valid() const
Returns false if the region has undefined/invalid value.
void sort_permuted_nodes_elements(std::vector< int > new_node_ids, std::vector< int > new_elem_ids)
Sort elements and nodes by order stored in permutation vectors.
void mark_used_region(unsigned int idx)
static const Input::Type::Record & get_input_type()
Class for O(log N) lookup for intersections with a set of bounding boxes.
#define THROW(whole_exception_expr)
Wrapper for throw. Saves the throwing point.
friend class RegionSetBase
unsigned int max_edge_sides_[3]
Maximal number of sides per one edge in the actual mesh (set in make_neighbours_and_edges()).
Class for the mesh partitioning. This should provide:
void make_edge_permutations()
#define ASSERT_EQ_DBG(a, b)
Definition of comparative assert macro (EQual) only for debug mode.
Region get_region(unsigned int id, unsigned int dim)
Range< NodeAccessor< 3 > > node_range() const
Returns range of nodes.
const LongIdx * get_loc_part() const
Boundary boundary(uint edge_idx) const
unsigned int idx() const
Returns a global index of the region.
unsigned int n_local_nodes_
Hold number of local nodes (own + ghost), value is equal with size of node_4_loc array.
std::string format(CStringRef format_str, ArgList args)
std::vector< unsigned int > permutation_idx_
const Element * element() const
void open_stream(Stream &stream) const
void read_regions_from_input(Input::Array region_list)
std::string create_label_from_id(unsigned int id) const
MapElementIDToRegionID el_to_reg_map_
IntersectionSearch get_intersection_search()
Getter for input type selection for intersection search algorithm.
unsigned int n_vb_neighbours() const
virtual unsigned int n_elements() const
Returns count of boundary or bulk elements.
#define ASSERT_PTR_DBG(ptr)
Definition of assert macro checking non-null pointer (PTR) only for debug mode.
Distribution * el_ds
Parallel distribution of elements.
unsigned int id() const
Returns id of the region (using RegionDB)
void intersect_element_lists(vector< unsigned int > const &nodes_list, vector< unsigned int > &intersection_element_list)
static const unsigned int undefined_dim
std::vector< int > sort_nodes(std::vector< unsigned int > &node_permutation)
void output_internal_ngh_data()
Output of neighboring data into raw output.
virtual const LongIdx * get_local_part()
BidirectionalMap< int > node_ids_
Maps node ids to indexes into vector node_vec_.
BoundingBox bounding_box() const
void check_mesh_on_read()
void find_point(const Space< 3 >::Point &point, std::vector< unsigned int > &result_list, bool full_list=false) const
bool find_lower_dim_element(vector< unsigned int > &element_list, unsigned int dim, unsigned int &element_idx)
void count_element_types()
const BIHTree & get_bih_tree()
Getter for BIH. Creates and compute BIH at first call.
void distribute_nodes()
Fill array node_4_loc_ and create object node_ds_ according to element distribution.
SideIter side(const unsigned int i) const
Gets side iterator of the i -th side.
BCMesh * get_bc_mesh()
Create boundary mesh if doesn't exist and return it.
bool is_boundary() const
Returns true if it is a Boundary region and false if it is a Bulk region.
LongIdx * el_4_loc
Index set assigning to local element index its global index.
void elements_id_maps(vector< LongIdx > &bulk_elements_id, vector< LongIdx > &boundary_elements_id) const
unsigned int n_neighs_vb_
vector< vector< vector< unsigned int > > > side_nodes
std::vector< unsigned int > node_permutation_
Vector of node permutations of optimized mesh (see class MeshOptimizer)
const unsigned int * get_lsizes_array()
get local sizes array
ElementAccessor< 3 > element()
IntersectionSearch
Types of search algorithm for finding intersection candidates.
int find_elem_id(unsigned int pos) const
Return element id (in GMSH file) of element of given position in element vector.
#define ASSERT_EQ(a, b)
Definition of comparative assert macro (EQual)
void init(unsigned int dim, RegionIdx reg)
Region find_id(unsigned int id, unsigned int dim) const
ElementAccessor< 3 > element() const
Returns iterator to the element of the side.
std::shared_ptr< BIHTree > bih_tree_
Distribution * node_ds_
Parallel distribution of nodes. Depends on elements distribution.
unsigned int n_nodes() const
Returns number of nodes of the side.
NodeAccessor< 3 > node(unsigned int ni) const
bool same_sides(const SideIter &si, vector< unsigned int > &side_nodes)
ArrayMatSet set(uint index)
void element_to_neigh_vb()
unsigned int node_idx(unsigned int ni) const
Return index (in Mesh::node_vec) of ni-th node.
void check_element_size(unsigned int elem_idx) const
Check if given index is in element_vec_.
void add_element(unsigned int elm_id, unsigned int dim, unsigned int region_id, unsigned int partition_id, std::vector< unsigned int > node_ids)
Add new element of given id to mesh.
unsigned int side_idx() const
Returns local index of the side on the element.
static const Input::Type::Record & get_input_type()
Region implicit_boundary_region()
virtual ~Mesh()
Destructor.
std::array< unsigned int, 4 > nodes_
indices to element's nodes
void create_node_element_lists()
unsigned int edge_idx(unsigned int edg_idx) const
Return edge_idx of given index.
int LongIdx
Define type that represents indices of large arrays (elements, nodes, dofs etc.)
Element * add_element_to_vector(int id)
Adds element to mesh data structures (element_vec_, element_ids_), returns pointer to this element.
void modify_element_ids(const RegionDB::MapElementIDToRegionID &map)
bool equal_elm(ElementAccessor< 3 > elm1, ElementAccessor< 3 > elm2)
unsigned int n_sides() const
int elem_index(int elem_id) const
For element of given elem_id returns index in element_vec_ or (-1) if element doesn't exist.
std::vector< EdgeData > edges
Vector of MH edges, this should not be part of the geometrical mesh.
void make_neighbours_and_edges()
void clear()
Clear the content. Do not release memory.
void init_node_vector(unsigned int size)
Initialize node_vec_, set size.
virtual std::shared_ptr< std::vector< LongIdx > > check_compatible_mesh(Mesh &input_mesh)
std::vector< unsigned int > elem_permutation_
Vector of element permutations of optimized mesh (see class MeshOptimizer)
#define WarningOut()
Macro defining 'warning' record of log.
void append(const ArmaMat< Type, nr, nc > &item)
int node_index(int node_id) const
For node of given node_id returns index in element_vec_ or (-1) if node doesn't exist.
Class represents boundary part of mesh.
Range< Edge > edge_range() const
Returns range of edges.
vector< vector< unsigned int > > node_elements_
For each node the vector contains a list of elements that use this node.
#define ASSERT_LT_DBG(a, b)
Definition of comparative assert macro (Less Than) only for debug mode.
BidirectionalMap< int > element_ids_
Maps element ids to indexes into vector element_vec_.
void add_node(unsigned int node_id, arma::vec3 coords)
Add new node of given id and coordinates to mesh.
vector< ElementTmpData > bc_element_tmp_
Hold data of boundary elements during reading mesh (allow to preserve correct order during reading of...
void find_bounding_box(const BoundingBox &boundingBox, std::vector< unsigned int > &result_list, bool full_list=false) const
unsigned int idx() const
Return local idx of element in boundary / bulk part of element vector.
Region add_region(unsigned int id, const std::string &label, unsigned int dim, const std::string &address="implicit")
std::shared_ptr< Partitioning > part_
unsigned int bulk_size_
Count of bulk elements.
unsigned int add_item(T val)
Add new item at the end position of map.
void print_region_table(std::ostream &stream) const
LongIdx * row_4_el
Index set assigning to global element index the local index used in parallel vectors.
const vector< vector< unsigned int > > & node_elements()
double global_snap_radius() const
Maximal distance of observe point from Mesh relative to its size.
vector< BoundaryData > boundary_
unsigned int n_local_nodes() const
virtual Partitioning * get_part()
NodeAccessor< 3 > node(unsigned int i) const
Returns node for given local index i on the side.
BCMesh * bc_mesh_
Boundary mesh, object is created only if it's necessary.
MixedMeshIntersections & mixed_intersections()
#define DebugOut()
Macro defining 'debug' record of log.
#define ASSERT_PTR(ptr)
Definition of assert macro checking non-null pointer (PTR)
SideIter side(const unsigned int loc_index)
NodeAccessor< 3 > node(unsigned int idx) const
Create and return NodeAccessor to node of given idx.
virtual ElementAccessor< 3 > element_accessor(unsigned int idx) const
Create and return ElementAccessor to element of given idx.
void reserve(unsigned int init_size=0)
Reset data of map, reserve space for given size.
virtual unsigned int n_nodes() const
#define START_TIMER(tag)
Starts a timer with specified tag.
int find_node_id(unsigned int pos) const
Return node id (in GMSH file) of node of given position in node vector.
unsigned int * boundary_idx_
Edge edge(uint edge_idx) const
void add_physical_name(unsigned int dim, unsigned int id, std::string name)
Add new node of given id and coordinates to mesh.
vector< Neighbour > vb_neighbours_
#define END_TIMER(tag)
Ends a timer with specified tag.
unsigned int n_nodes() const
unsigned int size() const
Return size of map.
Implementation of range helper class.
#define MessageOut()
Macro defining 'message' record of log.
std::shared_ptr< MixedMeshIntersections > intersections