zhangyiss/gctl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

tmp

Browse Source
This commit is contained in:
张壹 2025-01-21 17:21:19 +08:00
parent e29b31efa1
commit 3a22285275
3 changed files with 319 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
example/meshio_ex.cpp
View File

@ -52,10 +52,10 @@ int main(int argc, char const *argv[]) try
mshio.convert_tags_to_data(GeometryTag); mshio.convert_tags_to_data(GeometryTag);
array<double> body_val(mshio.element_size("Body2"), 2.0); array<double> body_val(mshio.element_size("Body2"), 2.0);
mshio.add_element_data(body_val, "BodyValue", "Body2"); mshio.add_element_data("BodyValue", "Body2", body_val);
array<double> body_val2(mshio.element_size("Body3"), 1.0); array<double> body_val2(mshio.element_size("Body3"), 1.0);
mshio.add_element_data(body_val2, "BodyValue", "Body3"); mshio.add_element_data("BodyValue", "Body3", body_val2);
mshio.save_gmsh_v2_ascii("tmp/ex1.2"); mshio.save_gmsh_v2_ascii("tmp/ex1.2");
//mshio.save_vtk_legacy_ascii("tmp/ex1.1"); //mshio.save_vtk_legacy_ascii("tmp/ex1.1");

310
lib/io/mesh_io.cpp
View File

@ -27,20 +27,20 @@
#include "mesh_io.h" #include "mesh_io.h"
gctl::mesh_element::mesh_element() gctl::meshio_element::meshio_element()
{ {
enabled = false; enabled = false;
id = DEFAULT_INVALID_TAG; id = DEFAULT_INVALID_TAG;
type = NotSet; type = NotSet;
} }
gctl::mesh_data::mesh_data() gctl::meshio_data::meshio_data()
{ {
enabled = false; enabled = false;
d_type = NodeData; d_type = NodeData;
} }
void gctl::mesh_data::clear() void gctl::meshio_data::clear()
{ {
enabled = false; enabled = false;
str_tag.clear(); str_tag.clear();
@ -52,7 +52,7 @@ void gctl::mesh_data::clear()
return; return;
} }
bool gctl::mesh_data::pass_check() bool gctl::meshio_data::pass_check()
{ {
// 检查是否同时连接了顶点和单元体 // 检查是否同时连接了顶点和单元体
if (vert_ptrs.empty() && elem_ptrs.empty()) return false; if (vert_ptrs.empty() && elem_ptrs.empty()) return false;
@ -63,7 +63,7 @@ bool gctl::mesh_data::pass_check()
return true; return true;
} }
gctl::mesh_element_group::mesh_element_group() gctl::meshio_element_group::meshio_element_group()
{ {
enabled = false; enabled = false;
type = NotSet; type = NotSet;
@ -71,7 +71,7 @@ gctl::mesh_element_group::mesh_element_group()
phys_group = geom_group = part_group = DEFAULT_INVALID_TAG; phys_group = geom_group = part_group = DEFAULT_INVALID_TAG;
} }
void gctl::mesh_element_group::enable_elements() void gctl::meshio_element_group::enable_elements()
{ {
for (size_t e = 0; e < elem_ptrs.size(); e++) for (size_t e = 0; e < elem_ptrs.size(); e++)
{ {
@ -80,7 +80,7 @@ void gctl::mesh_element_group::enable_elements()
return; return;
} }
void gctl::mesh_element_group::disable_elements() void gctl::meshio_element_group::disable_elements()
{ {
for (size_t e = 0; e < elem_ptrs.size(); e++) for (size_t e = 0; e < elem_ptrs.size(); e++)
{ {
@ -481,12 +481,23 @@ const gctl::array<int> &gctl::mesh_io::get_node_tag()
return nodes_tag_; return nodes_tag_;
} }
int gctl::mesh_io::get_tag(element_tag_enum anchor_type, std::string anchor_name)
{
for (size_t i = 0; i < groups_.size(); i++)
{
if (anchor_type == PhysicalTag && groups_[i].name == anchor_name) return groups_[i].phys_group;
if (anchor_type == GeometryTag && groups_[i].name == anchor_name) return groups_[i].geom_group;
if (anchor_type == PartitionTag && groups_[i].name == anchor_name) return groups_[i].part_group;
}
return DEFAULT_INVALID_TAG;
}
const gctl::array<gctl::vertex3dc> &gctl::mesh_io::get_nodes() const gctl::array<gctl::vertex3dc> &gctl::mesh_io::get_nodes()
{ {
return nodes_; return nodes_;
} }
const gctl::array<gctl::mesh_element> &gctl::mesh_io::get_elems() const gctl::array<gctl::meshio_element> &gctl::mesh_io::get_elems()
{ {
return elems_; return elems_;
} }
@ -535,7 +546,7 @@ size_t gctl::mesh_io::element_size(std::string phys_name)
void gctl::mesh_io::convert_tags_to_data(element_tag_enum tag_type) void gctl::mesh_io::convert_tags_to_data(element_tag_enum tag_type)
{ {
mesh_data tmp_data; meshio_data tmp_data;
if (tag_type == NodeTag && (!nodes_tag_.empty())) if (tag_type == NodeTag && (!nodes_tag_.empty()))
{ {
tmp_data.enabled = true; tmp_data.enabled = true;
@ -742,21 +753,76 @@ void gctl::mesh_io::export_elements_to(array<tetrahedron> &tets, element_tag_enu
return; return;
} }
int gctl::mesh_io::if_saved_data(std::string name) void gctl::mesh_io::get_gmsh_physical_groups(std::vector<gmsh_physical_group> &g_groups)
{
if (!g_groups.empty()) g_groups.clear();
gmsh_physical_group tmp_group;
bool not_found;
for (size_t i = 0; i < groups_.size(); i++)
{
if (g_groups.empty() && groups_[i].enabled)
{
tmp_group.name = groups_[i].name;
tmp_group.phys_tag = groups_[i].phys_group;
tmp_group.dim_tag = groups_[i].part_group;
g_groups.push_back(tmp_group);
}
else
{
not_found = true;
for (size_t g = 0; g < g_groups.size(); g++)
{
if (groups_[i].part_group == g_groups[g].dim_tag &&
groups_[i].phys_group == g_groups[g].phys_tag)
{
not_found = false;
break;
}
}
if (not_found && groups_[i].enabled)
{
tmp_group.name = groups_[i].name;
tmp_group.phys_tag = groups_[i].phys_group;
tmp_group.dim_tag = groups_[i].part_group;
g_groups.push_back(tmp_group);
}
}
}
return;
}
int gctl::mesh_io::if_saved_data(std::string name, mesh_data_type_e type)
{ {
for (size_t i = 0; i < datas_.size(); i++) for (size_t i = 0; i < datas_.size(); i++)
{ {
if (datas_[i].str_tag.front() == name) return i; if (datas_[i].str_tag.front() == name &&
datas_[i].d_type == type) return i;
} }
return -1; return -1;
} }
void gctl::mesh_io::add_node_data(const array<double> &data, std::string name) gctl::meshio_data &gctl::mesh_io::get_data(std::string name, mesh_data_type_e type)
{
int id = if_saved_data(name, type);
if (id == -1) throw std::runtime_error("[gctl::mesh_io::get_data] Data not found.");
return datas_[id];
}
gctl::meshio_data *gctl::mesh_io::get_data_ptr(std::string name, mesh_data_type_e type)
{
int id = if_saved_data(name, type);
if (id == -1) throw std::runtime_error("[gctl::mesh_io::get_data] Data not found.");
return &datas_[id];
}
void gctl::mesh_io::add_node_data(std::string name, const array<double> &data)
{ {
size_t s = nodes_.size(); size_t s = nodes_.size();
if (data.size()!= s) throw std::runtime_error("[gctl::mesh_io::create_node_data] Incompatible data size."); if (data.size()!= s) throw std::runtime_error("[gctl::mesh_io::create_node_data] Incompatible data size.");
int d_id = if_saved_data(name); int d_id = if_saved_data(name, NodeData);
if (d_id != -1) if (d_id != -1)
{ {
for (size_t i = 0; i < s; i++) for (size_t i = 0; i < s; i++)
@ -766,7 +832,7 @@ void gctl::mesh_io::add_node_data(const array<double> &data, std::string name)
return; return;
} }
mesh_data new_data; meshio_data new_data;
new_data.enabled = true; new_data.enabled = true;
new_data.d_type = NodeData; new_data.d_type = NodeData;
new_data.str_tag.resize(1, name); new_data.str_tag.resize(1, name);
@ -787,7 +853,7 @@ void gctl::mesh_io::add_node_data(const array<double> &data, std::string name)
return; return;
} }
void gctl::mesh_io::add_node_data(const array<double> &data, const array<bool> &boolen, std::string name) void gctl::mesh_io::add_node_data(std::string name, const array<double> &data, const array<bool> &boolen)
{ {
size_t s = nodes_.size(); size_t s = nodes_.size();
if (data.size()!= s || boolen.size() != s) throw std::runtime_error("[gctl::mesh_io::create_node_data] Incompatible data size."); if (data.size()!= s || boolen.size() != s) throw std::runtime_error("[gctl::mesh_io::create_node_data] Incompatible data size.");
@ -798,7 +864,7 @@ void gctl::mesh_io::add_node_data(const array<double> &data, const array<bool> &
if (boolen[i]) s++; if (boolen[i]) s++;
} }
int d_id = if_saved_data(name); int d_id = if_saved_data(name, NodeData);
if (d_id != -1) if (d_id != -1)
{ {
datas_[d_id].val.resize(s); datas_[d_id].val.resize(s);
@ -818,7 +884,7 @@ void gctl::mesh_io::add_node_data(const array<double> &data, const array<bool> &
return; return;
} }
mesh_data new_data; meshio_data new_data;
new_data.enabled = true; new_data.enabled = true;
new_data.d_type = NodeData; new_data.d_type = NodeData;
new_data.str_tag.resize(1, name); new_data.str_tag.resize(1, name);
@ -844,16 +910,8 @@ void gctl::mesh_io::add_node_data(const array<double> &data, const array<bool> &
return; return;
} }
void gctl::mesh_io::add_element_data(const array<double> &data, std::string name, element_type_enum e_type) void gctl::mesh_io::add_element_data(std::string name, const array<double> &data, element_type_enum e_type)
{ {
mesh_data new_data;
new_data.enabled = true;
new_data.d_type = ElemData;
new_data.str_tag.resize(1, name);
new_data.real_tag.resize(1, 0.0);
new_data.int_tag.resize(3, 0);
new_data.int_tag[1] = 1;
size_t e = 0; size_t e = 0;
for (size_t i = 0; i < groups_.size(); i++) for (size_t i = 0; i < groups_.size(); i++)
{ {
@ -862,6 +920,36 @@ void gctl::mesh_io::add_element_data(const array<double> &data, std::string name
if (data.size() != e) throw std::runtime_error("[gctl::mesh_io::create_element_data] Incompatible data size."); if (data.size() != e) throw std::runtime_error("[gctl::mesh_io::create_element_data] Incompatible data size.");
int d_id = if_saved_data(name, ElemData);
if (d_id != -1)
{
datas_[d_id].int_tag[2] = e;
datas_[d_id].elem_ptrs.resize(e, nullptr);
datas_[d_id].val.resize(e, 0.0);
e = 0;
for (size_t i = 0; i < groups_.size(); i++)
{
if ((e_type == NotSet || groups_[i].type == e_type) && groups_[i].enabled)
{
for (size_t j = 0; j < groups_[i].elem_ptrs.size(); j++)
{
datas_[d_id].elem_ptrs[e] = groups_[i].elem_ptrs[j];
datas_[d_id].val[e] = data[e];
e++;
}
}
}
return;
}
meshio_data new_data;
new_data.enabled = true;
new_data.d_type = ElemData;
new_data.str_tag.resize(1, name);
new_data.real_tag.resize(1, 0.0);
new_data.int_tag.resize(3, 0);
new_data.int_tag[1] = 1;
new_data.int_tag[2] = e; new_data.int_tag[2] = e;
new_data.elem_ptrs.resize(e, nullptr); new_data.elem_ptrs.resize(e, nullptr);
new_data.val.resize(e, 0.0); new_data.val.resize(e, 0.0);
@ -884,16 +972,8 @@ void gctl::mesh_io::add_element_data(const array<double> &data, std::string name
return; return;
} }
void gctl::mesh_io::add_element_data(const array<double> &data, std::string name, element_tag_enum tag_type, int tag) void gctl::mesh_io::add_element_data(std::string name, const array<double> &data, element_tag_enum tag_type, int tag)
{ {
mesh_data new_data;
new_data.enabled = true;
new_data.d_type = ElemData;
new_data.str_tag.resize(1, name);
new_data.real_tag.resize(1, 0.0);
new_data.int_tag.resize(3, 0);
new_data.int_tag[1] = 1;
size_t e = 0; size_t e = 0;
for (size_t i = 0; i < groups_.size(); i++) for (size_t i = 0; i < groups_.size(); i++)
{ {
@ -908,6 +988,42 @@ void gctl::mesh_io::add_element_data(const array<double> &data, std::string name
if (data.size() != e) throw std::runtime_error("[gctl::mesh_io::create_element_data] Incompatible data size."); if (data.size() != e) throw std::runtime_error("[gctl::mesh_io::create_element_data] Incompatible data size.");
int d_id = if_saved_data(name, ElemData);
if (d_id != -1)
{
array<meshio_element*> more_elem_ptrs(e, nullptr);
array<double> more_val(e, 0.0);
e = 0;
for (size_t i = 0; i < groups_.size(); i++)
{
if ((tag_type == PhysicalTag && groups_[i].phys_group == tag) ||
(tag_type == GeometryTag && groups_[i].geom_group == tag) ||
(tag_type == PartitionTag && groups_[i].part_group == tag) &&
groups_[i].enabled)
{
for (size_t j = 0; j < groups_[i].elem_ptrs.size(); j++)
{
more_elem_ptrs[e] = groups_[i].elem_ptrs[j];
more_val[e] = data[e];
e++;
}
}
}
datas_[d_id].int_tag[2] += e;
datas_[d_id].elem_ptrs.concat(more_elem_ptrs);
datas_[d_id].val.concat(more_val);
return;
}
meshio_data new_data;
new_data.enabled = true;
new_data.d_type = ElemData;
new_data.str_tag.resize(1, name);
new_data.real_tag.resize(1, 0.0);
new_data.int_tag.resize(3, 0);
new_data.int_tag[1] = 1;
new_data.int_tag[2] = e; new_data.int_tag[2] = e;
new_data.elem_ptrs.resize(e, nullptr); new_data.elem_ptrs.resize(e, nullptr);
new_data.val.resize(e, 0.0); new_data.val.resize(e, 0.0);
@ -933,7 +1049,7 @@ void gctl::mesh_io::add_element_data(const array<double> &data, std::string name
return; return;
} }
void gctl::mesh_io::add_element_data(const array<double> &data, std::string name, std::string phys_name) void gctl::mesh_io::add_element_data(std::string name, std::string phys_name, const array<double> &data)
{ {
size_t e = 0; size_t e = 0;
for (size_t i = 0; i < groups_.size(); i++) for (size_t i = 0; i < groups_.size(); i++)
@ -946,10 +1062,10 @@ void gctl::mesh_io::add_element_data(const array<double> &data, std::string name
if (data.size() != e) throw std::runtime_error("[gctl::mesh_io::create_element_data] Incompatible data size."); if (data.size() != e) throw std::runtime_error("[gctl::mesh_io::create_element_data] Incompatible data size.");
int d_id = if_saved_data(name); int d_id = if_saved_data(name, ElemData);
if (d_id != -1) if (d_id != -1)
{ {
array<mesh_element*> more_elem_ptrs(e, nullptr); array<meshio_element*> more_elem_ptrs(e, nullptr);
array<double> more_val(e, 0.0); array<double> more_val(e, 0.0);
e = 0; e = 0;
@ -972,7 +1088,7 @@ void gctl::mesh_io::add_element_data(const array<double> &data, std::string name
return; return;
} }
mesh_data new_data; meshio_data new_data;
new_data.enabled = true; new_data.enabled = true;
new_data.d_type = ElemData; new_data.d_type = ElemData;
new_data.str_tag.resize(1, name); new_data.str_tag.resize(1, name);
@ -1001,6 +1117,72 @@ void gctl::mesh_io::add_element_data(const array<double> &data, std::string name
return; return;
} }
void gctl::mesh_io::add_element_data(std::string name, std::string phys_name, double phys_val)
{
size_t e = 0;
for (size_t i = 0; i < groups_.size(); i++)
{
if (groups_[i].enabled && groups_[i].name == phys_name)
{
e += groups_[i].elem_ptrs.size();
}
}
int d_id = if_saved_data(name, ElemData);
if (d_id != -1)
{
array<meshio_element*> more_elem_ptrs(e, nullptr);
array<double> more_val(e, 0.0);
e = 0;
for (size_t i = 0; i < groups_.size(); i++)
{
if (groups_[i].enabled && groups_[i].name == phys_name)
{
for (size_t j = 0; j < groups_[i].elem_ptrs.size(); j++)
{
more_elem_ptrs[e] = groups_[i].elem_ptrs[j];
more_val[e] = phys_val;
e++;
}
}
}
datas_[d_id].int_tag[2] += e;
datas_[d_id].elem_ptrs.concat(more_elem_ptrs);
datas_[d_id].val.concat(more_val);
return;
}
meshio_data new_data;
new_data.enabled = true;
new_data.d_type = ElemData;
new_data.str_tag.resize(1, name);
new_data.real_tag.resize(1, 0.0);
new_data.int_tag.resize(3, 0);
new_data.int_tag[1] = 1;
new_data.int_tag[2] = e;
new_data.elem_ptrs.resize(e, nullptr);
new_data.val.resize(e, 0.0);
e = 0;
for (size_t i = 0; i < groups_.size(); i++)
{
if (groups_[i].enabled && groups_[i].name == phys_name)
{
for (size_t j = 0; j < groups_[i].elem_ptrs.size(); j++)
{
new_data.elem_ptrs[e] = groups_[i].elem_ptrs[j];
new_data.val[e] = phys_val;
e++;
}
}
}
datas_.push_back(new_data);
return;
}
void gctl::mesh_io::read_triangle_ascii(std::string filename, index_packed_e is_packed) void gctl::mesh_io::read_triangle_ascii(std::string filename, index_packed_e is_packed)
{ {
if (initialized_ == true) if (initialized_ == true)
@ -1056,7 +1238,7 @@ void gctl::mesh_io::read_triangle_ascii(std::string filename, index_packed_e is_
} }
// 整理单元体组 // 整理单元体组
mesh_element_group tmp_group; meshio_element_group tmp_group;
tmp_group.type = elems_[0].type; tmp_group.type = elems_[0].type;
tmp_group.phys_group = int_tag[0][0]; tmp_group.phys_group = int_tag[0][0];
tmp_group.geom_group = int_tag[0][1]; tmp_group.geom_group = int_tag[0][1];
@ -1205,7 +1387,7 @@ void gctl::mesh_io::read_tetgen_ascii(std::string filename, index_packed_e is_pa
} }
// 整理单元体组 // 整理单元体组
mesh_element_group tmp_group; meshio_element_group tmp_group;
tmp_group.type = elems_[0].type; tmp_group.type = elems_[0].type;
tmp_group.phys_group = int_tag[0][0]; tmp_group.phys_group = int_tag[0][0];
tmp_group.geom_group = int_tag[0][1]; tmp_group.geom_group = int_tag[0][1];
@ -1339,7 +1521,7 @@ void gctl::mesh_io::read_gmsh_v2_ascii(std::string filename, index_packed_e is_p
// 读入模型空间元素集 // 读入模型空间元素集
int i_size, type_code, attri_num, vt_idx; int i_size, type_code, attri_num, vt_idx;
array<array<int> > int_tag; array<array<int> > file_itag;
while(getline(infile,tmp_str)) while(getline(infile,tmp_str))
{ {
if (tmp_str == "$Elements") if (tmp_str == "$Elements")
@ -1350,23 +1532,24 @@ void gctl::mesh_io::read_gmsh_v2_ascii(std::string filename, index_packed_e is_p
valid_elem_size_ = i_size; valid_elem_size_ = i_size;
elems_.resize(i_size); elems_.resize(i_size);
int_tag.resize(valid_elem_size_); file_itag.resize(valid_elem_size_);
for (size_t i = 0; i < i_size; i++) for (size_t i = 0; i < i_size; i++)
{ {
getline(infile,tmp_str); getline(infile,tmp_str);
str2ss(tmp_str, tmp_ss); str2ss(tmp_str, tmp_ss);
tmp_ss >> elems_[i].id >> type_code >> attri_num; tmp_ss >> elems_[i].id >> type_code >> attri_num;
if (is_packed == NotPacked) elems_[i].id -= 1;
elems_[i].type = elem_gmsh_type(type_code); elems_[i].type = elem_gmsh_type(type_code);
elems_[i].vert_ptrs.resize(elem_size(elems_[i].type)); elems_[i].vert_ptrs.resize(elem_size(elems_[i].type));
// we get at least three tags. see below for tag types // we get at least three tags. see below for tag types
// default tags will be assgined to DEFAULT_INVALID_TAG // default tags will be assgined to DEFAULT_INVALID_TAG
int_tag[i].resize(GCTL_MAX(3, attri_num), DEFAULT_INVALID_TAG); file_itag[i].resize(GCTL_MAX(3, attri_num), DEFAULT_INVALID_TAG);
for (size_t a = 0; a < attri_num; a++) for (size_t a = 0; a < attri_num; a++)
{ {
tmp_ss >> int_tag[i][a]; tmp_ss >> file_itag[i][a];
} }
for (size_t v = 0; v < elems_[i].vert_ptrs.size(); v++) for (size_t v = 0; v < elems_[i].vert_ptrs.size(); v++)
@ -1381,7 +1564,7 @@ void gctl::mesh_io::read_gmsh_v2_ascii(std::string filename, index_packed_e is_p
} }
// 读入数据模块 // 读入数据模块
mesh_data tmp_data; meshio_data tmp_data;
while(getline(infile,tmp_str)) while(getline(infile,tmp_str))
{ {
if (!infile.good()) break; if (!infile.good()) break;
@ -1461,11 +1644,11 @@ void gctl::mesh_io::read_gmsh_v2_ascii(std::string filename, index_packed_e is_p
infile.close(); infile.close();
// 整理单元体组 // 整理单元体组
mesh_element_group tmp_group; meshio_element_group tmp_group;
tmp_group.type = elems_[0].type; tmp_group.type = elems_[0].type;
tmp_group.phys_group = int_tag[0][0]; tmp_group.phys_group = file_itag[0][0];
tmp_group.geom_group = int_tag[0][1]; tmp_group.geom_group = file_itag[0][1];
tmp_group.part_group = int_tag[0][2]; tmp_group.part_group = file_itag[0][2];
tmp_group.elem_ptrs.push_back(elems_.get(0)); tmp_group.elem_ptrs.push_back(elems_.get(0));
groups_.push_back(tmp_group); groups_.push_back(tmp_group);
@ -1477,9 +1660,9 @@ void gctl::mesh_io::read_gmsh_v2_ascii(std::string filename, index_packed_e is_p
for (size_t g = 0; g < groups_.size(); g++) for (size_t g = 0; g < groups_.size(); g++)
{ {
if (groups_[g].type == elems_[i].type && if (groups_[g].type == elems_[i].type &&
groups_[g].phys_group == int_tag[i][0] && groups_[g].phys_group == file_itag[i][0] &&
groups_[g].geom_group == int_tag[i][1] && groups_[g].geom_group == file_itag[i][1] &&
groups_[g].part_group == int_tag[i][2]) groups_[g].part_group == file_itag[i][2])
{ {
groups_[g].elem_ptrs.push_back(elems_.get(i)); groups_[g].elem_ptrs.push_back(elems_.get(i));
not_found = false; not_found = false;
@ -1491,9 +1674,9 @@ void gctl::mesh_io::read_gmsh_v2_ascii(std::string filename, index_packed_e is_p
{ {
tmp_group.elem_ptrs.clear(); tmp_group.elem_ptrs.clear();
tmp_group.type = elems_[i].type; tmp_group.type = elems_[i].type;
tmp_group.phys_group = int_tag[i][0]; // 物理组 tmp_group.phys_group = file_itag[i][0]; // 物理组
tmp_group.geom_group = int_tag[i][1]; // 几何组 tmp_group.geom_group = file_itag[i][1]; // 几何组
tmp_group.part_group = int_tag[i][2]; // 剖分组（一般以元素的维度区分） tmp_group.part_group = file_itag[i][2]; // 剖分组（一般以元素的维度区分）
tmp_group.elem_ptrs.push_back(elems_.get(i)); tmp_group.elem_ptrs.push_back(elems_.get(i));
groups_.push_back(tmp_group); groups_.push_back(tmp_group);
} }
@ -1539,11 +1722,14 @@ void gctl::mesh_io::save_gmsh_v2_ascii(std::string filename, index_packed_e is_p
outfile << "$MeshFormat\n2.2 0 8\n$EndMeshFormat\n"; outfile << "$MeshFormat\n2.2 0 8\n$EndMeshFormat\n";
outfile << "$PhysicalNames\n" << valid_group_size_ << "\n"; std::vector<gmsh_physical_group> gmsh_groups;
for (size_t i = 0; i < groups_.size(); i++) get_gmsh_physical_groups(gmsh_groups);
outfile << "$PhysicalNames\n" << gmsh_groups.size() << "\n";
for (size_t i = 0; i < gmsh_groups.size(); i++)
{ {
if (groups_[i].enabled && groups_[i].phys_group != DEFAULT_INVALID_TAG) outfile << groups_[i].part_group << " " << groups_[i].phys_group << " \"" << groups_[i].name << "\"\n"; if (gmsh_groups[i].phys_tag != DEFAULT_INVALID_TAG) outfile << gmsh_groups[i].dim_tag << " " << gmsh_groups[i].phys_tag << " \"" << gmsh_groups[i].name << "\"\n";
else if (groups_[i].enabled) outfile << groups_[i].part_group << " 0 \"" << groups_[i].name << "\"\n"; else outfile << gmsh_groups[i].dim_tag << " 0 \"" << gmsh_groups[i].name << "\"\n";
} }
outfile << "$EndPhysicalNames\n"; outfile << "$EndPhysicalNames\n";
@ -1929,7 +2115,7 @@ void gctl::mesh_io::update_indexing()
void gctl::mesh_io::sort_groups() void gctl::mesh_io::sort_groups()
{ {
// 拷贝到临时组 // 拷贝到临时组
std::vector<mesh_element_group> tmp_groups = groups_; std::vector<meshio_element_group> tmp_groups = groups_;
// 清空对象 // 清空对象
for (size_t i = 0; i < groups_.size(); i++) for (size_t i = 0; i < groups_.size(); i++)
@ -1940,7 +2126,7 @@ void gctl::mesh_io::sort_groups()
// 整理单元体组 // 整理单元体组
bool not_found; bool not_found;
mesh_element_group tmp_group; meshio_element_group tmp_group;
for (size_t i = 0; i < tmp_groups.size(); i++) for (size_t i = 0; i < tmp_groups.size(); i++)
{ {
tmp_group = tmp_groups[i]; tmp_group = tmp_groups[i];

92
lib/io/mesh_io.h
View File

@ -103,22 +103,22 @@ namespace gctl
* @brief 网格单元体结构体 * @brief 网格单元体结构体
* *
*/ */
struct mesh_element struct meshio_element
{ {
bool enabled; // 单元体是否有效 bool enabled; // 单元体是否有效
int id; // 单元体编号 int id; // 单元体编号
element_type_enum type; // 单元体类型 element_type_enum type; // 单元体类型
array<vertex3dc*> vert_ptrs; // 顶点指针数组 array<vertex3dc*> vert_ptrs; // 顶点指针数组
array<mesh_element*> neigh_ptrs; // 相邻单元体指针数组 array<meshio_element*> neigh_ptrs; // 相邻单元体指针数组
mesh_element(); meshio_element();
}; };
/** /**
* @brief 网格数据结构体 * @brief 网格数据结构体
* *
*/ */
struct mesh_data struct meshio_data
{ {
bool enabled; // 数据体是否有效 bool enabled; // 数据体是否有效
mesh_data_type_e d_type; // 数据类型 mesh_data_type_e d_type; // 数据类型
@ -126,10 +126,10 @@ namespace gctl
array<double> real_tag; // 实数类型的标签（默认为一个，等于0.0） array<double> real_tag; // 实数类型的标签（默认为一个，等于0.0）
array<int> int_tag; // 整数类型的标签（最少三个，最后一个为数据的长度） array<int> int_tag; // 整数类型的标签（最少三个，最后一个为数据的长度）
array<vertex3dc*> vert_ptrs; // 两者只能存在一个 array<vertex3dc*> vert_ptrs; // 两者只能存在一个
array<mesh_element*> elem_ptrs; // 两者只能存在一个 array<meshio_element*> elem_ptrs; // 两者只能存在一个
array<double> val; // 数据值 array<double> val; // 数据值
mesh_data(); meshio_data();
/** /**
* @brief 清空数组并重置变量。 * @brief 清空数组并重置变量。
@ -148,7 +148,7 @@ namespace gctl
* @brief 网格单元体分组结构体。 * @brief 网格单元体分组结构体。
* *
*/ */
struct mesh_element_group struct meshio_element_group
{ {
bool enabled; // 组是否有效 bool enabled; // 组是否有效
element_type_enum type; // 组内单元体类型 element_type_enum type; // 组内单元体类型
@ -156,9 +156,9 @@ namespace gctl
int geom_group; // 几何分组标签 int geom_group; // 几何分组标签
int part_group; // 剖分分组标签 int part_group; // 剖分分组标签
std::string name; // 组名 std::string name; // 组名
std::vector<mesh_element*> elem_ptrs; // 组内单元体指针数组 std::vector<meshio_element*> elem_ptrs; // 组内单元体指针数组
mesh_element_group(); meshio_element_group();
/** /**
* @brief 将组内所有单元体设置为有效状态。 * @brief 将组内所有单元体设置为有效状态。
@ -255,6 +255,15 @@ namespace gctl
*/ */
const array<int> &get_node_tag(); const array<int> &get_node_tag();
/**
* @brief 返回指定类型与名称的标签值
*
* @param anchor_type 查找的标签类型（PhysicalTag，GeometryTag或者PartitionTag）。
* @param anchor_name 查找的元素组名称。
* @return 标签值
*/
int get_tag(element_tag_enum anchor_type, std::string anchor_name);
/** /**
* @brief 返回所有顶点数组的引用。 * @brief 返回所有顶点数组的引用。
* *
@ -267,10 +276,10 @@ namespace gctl
* *
* @return 单元体数组的引用。 * @return 单元体数组的引用。
*/ */
const array<mesh_element> &get_elems(); const array<meshio_element> &get_elems();
/** /**
* @brief 返回对应类型单元体的数量。 * @brief 返回对应类型单元体的数量（注意只会统计有效的单元体组）。
* *
* @param e_type 单元体类型（缺省为NotSet，返回所有单元体类型的总和）。 * @param e_type 单元体类型（缺省为NotSet，返回所有单元体类型的总和）。
* @return 整型大小。 * @return 整型大小。
@ -278,7 +287,7 @@ namespace gctl
size_t element_size(element_type_enum e_type = NotSet); size_t element_size(element_type_enum e_type = NotSet);
/** /**
* @brief 返回对应标签类型与标签值的单元体数量。 * @brief 返回对应标签类型与标签值的单元体数量（注意只会统计有效的单元体组）。
* *
* @param tag_type 标签类型。 * @param tag_type 标签类型。
* @param tag 标签值。 * @param tag 标签值。
@ -287,7 +296,7 @@ namespace gctl
size_t element_size(element_tag_enum tag_type, int tag); size_t element_size(element_tag_enum tag_type, int tag);
/** /**
* @brief 返回对应名称的单元体数量。 * @brief 返回对应名称的单元体数量（注意只会统计有效的单元体组）。
* *
* @param phys_name 单元体组名称 * @param phys_name 单元体组名称
* @return 整型大小。 * @return 整型大小。
@ -335,14 +344,40 @@ namespace gctl
*/ */
void export_elements_to(array<tetrahedron> &tets, element_tag_enum tag_type, int tag); void export_elements_to(array<tetrahedron> &tets, element_tag_enum tag_type, int tag);
/**
* @brief 获取gmsh格式分组表
*
* @param g_groups gmsh格式表
*/
void get_gmsh_physical_groups(std::vector<gmsh_physical_group> &g_groups);
/** /**
* @brief 检查是否存在名为name的数据 * @brief 检查是否存在名为name的数据
* *
* @param name 数据名称 * @param name 数据名称
* @param type 数据类型
* *
* @return 存在则返回数据索引，不存在则返回-1。 * @return 存在则返回数据索引，不存在则返回-1。
*/ */
int if_saved_data(std::string name); int if_saved_data(std::string name, mesh_data_type_e type);
/**
* @brief 获取数据对象的引用
*
* @param name 数据名称
* @param type 数据类型
* @return 数据引用
*/
meshio_data &get_data(std::string name, mesh_data_type_e type);
/**
* @brief 获取数据对象的指针
*
* @param name 数据名称
* @param type 数据类型
* @return 数据指针
*/
meshio_data *get_data_ptr(std::string name, mesh_data_type_e type);
/** /**
* @brief 添加一个顶点数据对象。数据将依次添加到所有顶点位置。 * @brief 添加一个顶点数据对象。数据将依次添加到所有顶点位置。
@ -352,7 +387,7 @@ namespace gctl
* @param data 输入的数据数组，长度与网格所有顶点数据相同。 * @param data 输入的数据数组，长度与网格所有顶点数据相同。
* @param name 新建的数据名称。 * @param name 新建的数据名称。
*/ */
void add_node_data(const array<double> &data, std::string name); void add_node_data(std::string name, const array<double> &data);
/** /**
* @brief 添加一个顶点数据对象。数据将依次添加到布尔为真的顶点位置。 * @brief 添加一个顶点数据对象。数据将依次添加到布尔为真的顶点位置。
@ -363,7 +398,7 @@ namespace gctl
* @param boolen 输入的布尔，只有为真元素位置的顶点数据将被保存。 * @param boolen 输入的布尔，只有为真元素位置的顶点数据将被保存。
* @param name 新建的数据名称。 * @param name 新建的数据名称。
*/ */
void add_node_data(const array<double> &data, const array<bool> &boolen, std::string name); void add_node_data(std::string name, const array<double> &data, const array<bool> &boolen);
/** /**
* @brief 按单元体类型筛选创建一个单元体数据对象。数据将依次添加到所选元素位置。 * @brief 按单元体类型筛选创建一个单元体数据对象。数据将依次添加到所选元素位置。
@ -374,7 +409,7 @@ namespace gctl
* @param name 新建数据名称。 * @param name 新建数据名称。
* @param e_type 新建数据的单元体类型（缺省值为NotSet，表示选择所有有效的单元体）。 * @param e_type 新建数据的单元体类型（缺省值为NotSet，表示选择所有有效的单元体）。
*/ */
void add_element_data(const array<double> &data, std::string name, element_type_enum e_type = NotSet); void add_element_data(std::string name, const array<double> &data, element_type_enum e_type = NotSet);
/** /**
* @brief 按单元体标签值筛选创建一个单元体数据对象。 * @brief 按单元体标签值筛选创建一个单元体数据对象。
@ -386,7 +421,7 @@ namespace gctl
* @param tag_type 标签类型。 * @param tag_type 标签类型。
* @param tag 标签值。 * @param tag 标签值。
*/ */
void add_element_data(const array<double> &data, std::string name, element_tag_enum tag_type, int tag); void add_element_data(std::string name, const array<double> &data, element_tag_enum tag_type, int tag);
/** /**
* @brief 按单元体组的名称筛选创建一个单元体数据对象。 * @brief 按单元体组的名称筛选创建一个单元体数据对象。
@ -397,7 +432,18 @@ namespace gctl
* @param name 新建数据名称。 * @param name 新建数据名称。
* @param phys_name 单元体组的名称。 * @param phys_name 单元体组的名称。
*/ */
void add_element_data(const array<double> &data, std::string name, std::string phys_name); void add_element_data(std::string name, std::string phys_name, const array<double> &data);
/**
* @brief 按单元体组的名称筛选创建一个单元体数据对象。
*
* @note 若对应名称的数据已经存在则会追加
*
* @param phys_val 数据初始值
* @param name 新建数据名称。
* @param phys_name 单元体组的名称。
*/
void add_element_data(std::string name, std::string phys_name, double phys_val);
/** /**
* @brief 读入triangle软件输出的网格剖分文件。 * @brief 读入triangle软件输出的网格剖分文件。
@ -449,15 +495,15 @@ namespace gctl
*/ */
void save_data_to_xyz(std::string filename, std::string dataname = "null", coordinate_system_e out_coor = Cartesian, double refr = GCTL_Earth_Radius, double refR = GCTL_Earth_Radius); void save_data_to_xyz(std::string filename, std::string dataname = "null", coordinate_system_e out_coor = Cartesian, double refr = GCTL_Earth_Radius, double refR = GCTL_Earth_Radius);
private: protected:
bool initialized_; // 类型是否已经初始化完成 bool initialized_; // 类型是否已经初始化完成
// 有效的顶点、单元体和单元体组的数量 // 有效的顶点、单元体和单元体组的数量
size_t valid_node_size_, valid_elem_size_, valid_group_size_; size_t valid_node_size_, valid_elem_size_, valid_group_size_;
array<vertex3dc> nodes_; // 网格顶点 当顶点索引为无效值时将不会被输出 array<vertex3dc> nodes_; // 网格顶点 当顶点索引为无效值时将不会被输出
array<mesh_element> elems_; // 网格元素 array<meshio_element> elems_; // 网格元素
std::vector<mesh_data> datas_; // 网格数据 std::vector<meshio_data> datas_; // 网格数据
std::vector<mesh_element_group> groups_; // 网格单元体组 std::vector<meshio_element_group> groups_; // 网格单元体组
array<int> nodes_tag_; // 顶点标签 array<int> nodes_tag_; // 顶点标签
element_type_enum elem_gmshcode2type_[94]; // gmsh的单元体类型数组 数组索引为gmsh的单元体类型码值 element_type_enum elem_gmshcode2type_[94]; // gmsh的单元体类型数组 数组索引为gmsh的单元体类型码值