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-02-15 21:50:19 +08:00
parent 10c884b155
commit fb4ffd2acd
6 changed files with 456 additions and 685 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
example/CMakeLists.txt
View File

@ -26,7 +26,7 @@ add_example(kde_ex OFF)
add_example(meshio_ex OFF)
add_example(autodiff_ex OFF)
add_example(multinary_ex OFF)
add_example(text_io_ex ON)
add_example(text_io_ex OFF)
add_example(getoption_ex OFF)
add_example(process_ex OFF)
add_example(array_ex OFF)

19
example/meshio_ex.cpp
View File

@ -34,6 +34,22 @@ int main(int argc, char const *argv[]) try
{
mesh_io mshio;
mshio.read_gmsh_v2_ascii("tmp/example2");
mshio.info();
/*
array<vertex2dc> nodes;
array<triangle2d> tris;
//array<vertex3dc*> orinode_ptrs;
//array<meshio_element*> oriele_ptrs;
mshio.select_elements("Survey");
mshio.export_to(tris, nodes);
gmshio tmp_out;
tmp_out.init_file("tmp", Output);
tmp_out.set_packed(NotPacked, Output);
tmp_out.save_mesh(tris, nodes);
*/
/*
mshio.read_tetgen_ascii("tmp/ex1.1");
mshio.edit_group(Disable, GeometryTag, 5);
@ -47,7 +63,7 @@ int main(int argc, char const *argv[]) try
mshio.edit_group(GeometryTag, 4, "Body3");
mshio.save_gmsh_v2_ascii("tmp/ex1.1");
*/
/*
mshio.read_gmsh_v2_ascii("tmp/ex1.1");
mshio.convert_tags_to_data(GeometryTag);
@ -70,6 +86,7 @@ int main(int argc, char const *argv[]) try
gio.init_file("tmp.msh", Output);
gio.set_packed(NotPacked, Output);
gio.save_mesh(body2_tets, nodes);
*/
/*
mshio.read_gmsh_v2_ascii("tmp/wjb.1");
mshio.edit_group(Disable);

2
lib/io/gmsh_io.h
View File

@ -46,7 +46,7 @@ namespace gctl
};
/**
* @brief Gmsh文件的IO类，主要为调用下面定义的全局函数
* @brief Gmsh文件的IO类，主要为调用下面定义的全局函数 （此结构已被废弃，不再更新。可能在未来移除，建议使用mesh_io类型替代）
*/
class gmshio
{

840
lib/io/mesh_io.cpp
View File

@ -254,6 +254,9 @@ gctl::mesh_io::~mesh_io()
void gctl::mesh_io::reset()
{
if (!selected_nodes_.empty()) selected_nodes_.clear();
if (!selected_elems_.empty()) selected_elems_.clear();
if (!selected_groups_.empty()) selected_groups_.clear();
if (!nodes_.empty()) nodes_.clear();
if (!elems_.empty()) elems_.clear();
if (!nodes_tag_.empty()) nodes_tag_.clear();
@ -346,33 +349,6 @@ void gctl::mesh_io::info(std::ostream &ss)
return;
}
void gctl::mesh_io::edit_data(switch_type_e swt, std::string dataname)
{
if (dataname == "null" && swt == Enable)
{
for (size_t i = 0; i < datas_.size(); i++)
{
datas_[i].enabled = true;
}
}
else if (dataname == "null" && swt == Disable)
{
for (size_t i = 0; i < datas_.size(); i++)
{
datas_[i].enabled = false;
}
}
else
{
for (size_t i = 0; i < datas_.size(); i++)
{
if (datas_[i].str_tag.front() == dataname && swt == Enable) datas_[i].enabled = true;
if (datas_[i].str_tag.front() == dataname && swt == Disable) datas_[i].enabled = false;
}
}
return;
}
void gctl::mesh_io::edit_group(switch_type_e swt, element_type_enum e_type)
{
for (size_t g = 0; g < groups_.size(); g++)
@ -474,48 +450,65 @@ void gctl::mesh_io::edit_group(element_tag_enum anchor_type, int anchor_group, e
return;
}
const gctl::array<int> &gctl::mesh_io::get_node_tag()
{
return nodes_tag_;
}
int gctl::mesh_io::get_tag(element_tag_enum anchor_type, std::string anchor_name)
int gctl::mesh_io::group_tag(element_tag_enum tag_type, std::string group_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;
if (tag_type == PhysicalTag && groups_[i].name == group_name) return groups_[i].phys_group;
if (tag_type == GeometryTag && groups_[i].name == group_name) return groups_[i].geom_group;
if (tag_type == PartitionTag && groups_[i].name == group_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_all_nodes()
{
return nodes_;
}
const gctl::array<gctl::meshio_element> &gctl::mesh_io::get_elems()
const gctl::array<gctl::meshio_element> &gctl::mesh_io::get_all_elems()
{
return elems_;
}
size_t gctl::mesh_io::element_size(element_type_enum e_type)
void gctl::mesh_io::select_elements(element_type_enum e_type)
{
size_t s = 0;
if (!selected_nodes_.empty()) selected_nodes_.clear();
if (!selected_elems_.empty()) selected_elems_.clear();
if (!selected_groups_.empty()) selected_groups_.clear();
int vnum;
for (size_t i = 0; i < groups_.size(); i++)
{
if ((e_type == NotSet || groups_[i].type == e_type) && groups_[i].enabled)
{
s += groups_[i].elem_ptrs.size();
selected_groups_.push_back(&groups_[i]);
vnum = elem_size(groups_[i].type);
for (size_t e = 0; e < groups_[i].elem_ptrs.size(); e++)
{
selected_elems_.push_back(groups_[i].elem_ptrs[e]);
for (size_t v = 0; v < vnum; v++)
{
selected_nodes_.push_back(groups_[i].elem_ptrs[e]->vert_ptrs[v]);
}
}
}
}
return s;
std::vector<vertex3dc*>::iterator pos;
std::sort(selected_nodes_.begin(), selected_nodes_.end()); //排序
pos = std::unique(selected_nodes_.begin(), selected_nodes_.end()); //获取重复序列开始的位置
selected_nodes_.erase(pos, selected_nodes_.end()); //删除重复点
return;
}
size_t gctl::mesh_io::element_size(element_tag_enum tag_type, int tag)
void gctl::mesh_io::select_elements(element_tag_enum tag_type, int tag)
{
size_t s = 0;
if (!selected_nodes_.empty()) selected_nodes_.clear();
if (!selected_elems_.empty()) selected_elems_.clear();
if (!selected_groups_.empty()) selected_groups_.clear();
int vnum;
for (size_t i = 0; i < groups_.size(); i++)
{
if ((tag_type == PhysicalTag && groups_[i].phys_group == tag) ||
@ -523,23 +516,134 @@ size_t gctl::mesh_io::element_size(element_tag_enum tag_type, int tag)
(tag_type == PartitionTag && groups_[i].part_group == tag) &&
groups_[i].enabled)
{
s += groups_[i].elem_ptrs.size();
selected_groups_.push_back(&groups_[i]);
vnum = elem_size(groups_[i].type);
for (size_t e = 0; e < groups_[i].elem_ptrs.size(); e++)
{
selected_elems_.push_back(groups_[i].elem_ptrs[e]);
for (size_t v = 0; v < vnum; v++)
{
selected_nodes_.push_back(groups_[i].elem_ptrs[e]->vert_ptrs[v]);
}
}
}
}
return s;
std::vector<vertex3dc*>::iterator pos;
std::sort(selected_nodes_.begin(), selected_nodes_.end()); //排序
pos = std::unique(selected_nodes_.begin(), selected_nodes_.end()); //获取重复序列开始的位置
selected_nodes_.erase(pos, selected_nodes_.end()); //删除重复点
return;
}
size_t gctl::mesh_io::element_size(std::string phys_name)
void gctl::mesh_io::select_elements(std::string phys_name)
{
size_t s = 0;
if (!selected_nodes_.empty()) selected_nodes_.clear();
if (!selected_elems_.empty()) selected_elems_.clear();
if (!selected_groups_.empty()) selected_groups_.clear();
int vnum;
for (size_t i = 0; i < groups_.size(); i++)
{
if (groups_[i].enabled && groups_[i].name == phys_name)
{
s += groups_[i].elem_ptrs.size();
selected_groups_.push_back(&groups_[i]);
vnum = elem_size(groups_[i].type);
for (size_t e = 0; e < groups_[i].elem_ptrs.size(); e++)
{
selected_elems_.push_back(groups_[i].elem_ptrs[e]);
for (size_t v = 0; v < vnum; v++)
{
selected_nodes_.push_back(groups_[i].elem_ptrs[e]->vert_ptrs[v]);
}
}
}
}
return s;
std::vector<vertex3dc*>::iterator pos;
std::sort(selected_nodes_.begin(), selected_nodes_.end()); //排序
pos = std::unique(selected_nodes_.begin(), selected_nodes_.end()); //获取重复序列开始的位置
selected_nodes_.erase(pos, selected_nodes_.end()); //删除重复点
return;
}
size_t gctl::mesh_io::node_size()
{
return selected_nodes_.size();
}
size_t gctl::mesh_io::element_size()
{
return selected_elems_.size();
}
const gctl::array<int> &gctl::mesh_io::node_tags()
{
selected_node_tag_.resize(selected_nodes_.size());
for (size_t i = 0; i < selected_node_tag_.size(); i++)
{
selected_node_tag_[i] = nodes_tag_[selected_nodes_[i]->id];
}
return selected_node_tag_;
}
const gctl::array<int> &gctl::mesh_io::element_tags(element_tag_enum tag_type)
{
selected_elem_tag_.resize(selected_elems_.size());
size_t id = 0;
for (size_t i = 0; i < selected_groups_.size(); i++)
{
for (size_t e = 0; e < selected_groups_[i]->elem_ptrs.size(); e++)
{
if (tag_type == PhysicalTag) selected_elem_tag_[id] = selected_groups_[i]->phys_group;
else if (tag_type == GeometryTag) selected_elem_tag_[id] = selected_groups_[i]->geom_group;
else if (tag_type == PartitionTag) selected_elem_tag_[id] = selected_groups_[i]->part_group;
else selected_elem_tag_[id] = DEFAULT_INVALID_TAG;
id++;
}
}
return selected_elem_tag_;
}
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;
}
void gctl::mesh_io::convert_tags_to_data(element_tag_enum tag_type)
@ -609,188 +713,6 @@ void gctl::mesh_io::convert_tags_to_data(element_tag_enum tag_type)
return;
}
void gctl::mesh_io::export_elements_to(array<triangle> &tris, std::string phys_name)
{
size_t s = 0;
for (size_t i = 0; i < groups_.size(); i++)
{
if (groups_[i].enabled && groups_[i].type == _3NodeTriangle &&
(groups_[i].name == phys_name || phys_name == "All"))
{
s += groups_[i].elem_ptrs.size();
}
}
tris.resize(s);
s = 0;
for (size_t i = 0; i < elems_.size(); i++)
{
if (groups_[i].enabled && groups_[i].type == _3NodeTriangle &&
(groups_[i].name == phys_name || phys_name == "All"))
{
for (size_t e = 0; e < groups_[i].elem_ptrs.size(); e++)
{
tris[s].id = groups_[i].elem_ptrs[e]->id;
tris[s].vert[0] = groups_[i].elem_ptrs[e]->vert_ptrs[0];
tris[s].vert[1] = groups_[i].elem_ptrs[e]->vert_ptrs[1];
tris[s].vert[2] = groups_[i].elem_ptrs[e]->vert_ptrs[2];
s++;
}
}
}
return;
}
void gctl::mesh_io::export_elements_to(array<triangle> &tris, element_tag_enum tag_type, int tag)
{
size_t s = 0;
for (size_t i = 0; i < groups_.size(); i++)
{
if (groups_[i].enabled && groups_[i].type == _3NodeTriangle &&
((tag_type == PhysicalTag && groups_[i].phys_group == tag) ||
(tag_type == GeometryTag && groups_[i].geom_group == tag) ||
(tag_type == PartitionTag && groups_[i].part_group == tag)))
{
s += groups_[i].elem_ptrs.size();
}
}
tris.resize(s);
s = 0;
for (size_t i = 0; i < groups_.size(); i++)
{
if (groups_[i].enabled && groups_[i].type == _3NodeTriangle &&
((tag_type == PhysicalTag && groups_[i].phys_group == tag) ||
(tag_type == GeometryTag && groups_[i].geom_group == tag) ||
(tag_type == PartitionTag && groups_[i].part_group == tag)))
{
for (size_t e = 0; e < groups_[i].elem_ptrs.size(); e++)
{
tris[s].id = groups_[i].elem_ptrs[e]->id;
tris[s].vert[0] = groups_[i].elem_ptrs[e]->vert_ptrs[0];
tris[s].vert[1] = groups_[i].elem_ptrs[e]->vert_ptrs[1];
tris[s].vert[2] = groups_[i].elem_ptrs[e]->vert_ptrs[2];
s++;
}
}
}
return;
}
void gctl::mesh_io::export_elements_to(array<tetrahedron> &tets, std::string phys_name)
{
size_t s = 0;
for (size_t i = 0; i < groups_.size(); i++)
{
if (groups_[i].enabled && groups_[i].type == _4NodeTetrahedron &&
(groups_[i].name == phys_name || phys_name == "All"))
{
s += groups_[i].elem_ptrs.size();
}
}
tets.resize(s);
s = 0;
for (size_t i = 0; i < groups_.size(); i++)
{
if (groups_[i].enabled && groups_[i].type == _4NodeTetrahedron &&
(groups_[i].name == phys_name || phys_name == "All"))
{
for (size_t e = 0; e < groups_[i].elem_ptrs.size(); e++)
{
tets[s].set(groups_[i].elem_ptrs[e]->vert_ptrs[0],
groups_[i].elem_ptrs[e]->vert_ptrs[1],
groups_[i].elem_ptrs[e]->vert_ptrs[2],
groups_[i].elem_ptrs[e]->vert_ptrs[3],
groups_[i].elem_ptrs[e]->id);
s++;
}
}
}
return;
}
void gctl::mesh_io::export_elements_to(array<tetrahedron> &tets, element_tag_enum tag_type, int tag)
{
size_t s = 0;
for (size_t i = 0; i < groups_.size(); i++)
{
if (groups_[i].enabled && groups_[i].type == _4NodeTetrahedron &&
(tag_type == PhysicalTag && groups_[i].phys_group == tag) ||
(tag_type == GeometryTag && groups_[i].geom_group == tag) ||
(tag_type == PartitionTag && groups_[i].part_group == tag))
{
s += groups_[i].elem_ptrs.size();
}
}
tets.resize(s);
s = 0;
for (size_t i = 0; i < groups_.size(); i++)
{
if (groups_[i].enabled && groups_[i].type == _4NodeTetrahedron &&
(tag_type == PhysicalTag && groups_[i].phys_group == tag) ||
(tag_type == GeometryTag && groups_[i].geom_group == tag) ||
(tag_type == PartitionTag && groups_[i].part_group == tag))
{
for (size_t e = 0; e < groups_[i].elem_ptrs.size(); e++)
{
tets[s].set(groups_[i].elem_ptrs[e]->vert_ptrs[0],
groups_[i].elem_ptrs[e]->vert_ptrs[1],
groups_[i].elem_ptrs[e]->vert_ptrs[2],
groups_[i].elem_ptrs[e]->vert_ptrs[3],
groups_[i].elem_ptrs[e]->id);
s++;
}
}
}
return;
}
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++)
@ -815,92 +737,94 @@ gctl::meshio_data *gctl::mesh_io::get_data_ptr(std::string name, mesh_data_type_
return &datas_[id];
}
void gctl::mesh_io::add_node_data(std::string name, const array<double> &data)
void gctl::mesh_io::add_data(std::string name, const array<double> &data,
mesh_data_type_e dtype, output_type_e op)
{
size_t s = nodes_.size();
if (data.size()!= s) throw std::runtime_error("[gctl::mesh_io::create_node_data] Incompatible data size.");
size_t s;
if (dtype == NodeData) s = selected_nodes_.size();
else s = selected_elems_.size();
int d_id = if_saved_data(name, NodeData);
if (d_id != -1)
if (data.size()!= s) throw std::runtime_error("[gctl::mesh_io::add_data] Incompatible data size to the selected nodes or elements.");
int d_id;
if (dtype == NodeData) d_id = if_saved_data(name, NodeData);
else d_id = if_saved_data(name, ElemData);
if (d_id != -1) // data exist
{
if (op == Append)
{
array<void*> tmp_ptrs(s, nullptr);
if (dtype == NodeData)
{
for (size_t i = 0; i < s; i++)
{
tmp_ptrs[i] = selected_nodes_[i];
}
}
else
{
for (size_t i = 0; i < s; i++)
{
tmp_ptrs[i] = selected_elems_[i];
}
}
datas_[d_id].int_tag[2] += s;
datas_[d_id].tar_ptrs.concat(tmp_ptrs);
datas_[d_id].val.concat(data);
}
else // OverWrite
{
datas_[d_id].int_tag[2] = s;
datas_[d_id].tar_ptrs.resize(s, nullptr);
datas_[d_id].val.resize(s, 0.0);
if (dtype == NodeData)
{
for (size_t i = 0; i < s; i++)
{
datas_[d_id].tar_ptrs[i] = selected_nodes_[i];
datas_[d_id].val[i] = data[i];
}
}
else
{
for (size_t i = 0; i < s; i++)
{
datas_[d_id].tar_ptrs[i] = selected_elems_[i];
datas_[d_id].val[i] = data[i];
}
}
}
return;
}
meshio_data new_data;
new_data.enabled = true;
new_data.d_type = NodeData;
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] = s;
new_data.tar_ptrs.resize(s, nullptr);
new_data.val.resize(s);
if (dtype == NodeData)
{
for (size_t i = 0; i < s; i++)
{
datas_[d_id].val[i] = data[i];
new_data.tar_ptrs[i] = selected_nodes_[i];
new_data.val[i] = data[i];
}
return;
}
meshio_data new_data;
new_data.enabled = true;
new_data.d_type = NodeData;
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] = s;
new_data.tar_ptrs.resize(s, nullptr);
new_data.val.resize(s);
for (size_t i = 0; i < s; i++)
else
{
new_data.tar_ptrs[i] = nodes_.get(i);
new_data.val[i] = data[i];
}
datas_.push_back(new_data);
return;
}
void gctl::mesh_io::add_node_data(std::string name, const array<double> &data, const array<bool> &boolen)
{
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.");
s = 0;
for (size_t i = 0; i < nodes_.size(); i++)
{
if (boolen[i]) s++;
}
int d_id = if_saved_data(name, NodeData);
if (d_id != -1)
{
datas_[d_id].val.resize(s);
datas_[d_id].tar_ptrs.resize(s, nullptr);
datas_[d_id].int_tag[2] = s;
s = 0;
for (size_t i = 0; i < nodes_.size(); i++)
for (size_t i = 0; i < s; i++)
{
if (boolen[i])
{
datas_[d_id].tar_ptrs[s] = nodes_.get(i);
datas_[d_id].val[s] = data[i];
s++;
}
}
return;
}
meshio_data new_data;
new_data.enabled = true;
new_data.d_type = NodeData;
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] = s;
new_data.tar_ptrs.resize(s, nullptr);
new_data.val.resize(s);
s = 0;
for (size_t i = 0; i < nodes_.size(); i++)
{
if (boolen[i])
{
new_data.tar_ptrs[s] = nodes_.get(i);
new_data.val[s] = data[i];
s++;
new_data.tar_ptrs[i] = selected_elems_[i];
new_data.val[i] = data[i];
}
}
@ -908,276 +832,30 @@ void gctl::mesh_io::add_node_data(std::string name, const array<double> &data, c
return;
}
void gctl::mesh_io::add_element_data(std::string name, const array<double> &data, element_type_enum e_type)
void gctl::mesh_io::edit_data(switch_type_e swt, std::string dataname)
{
size_t e = 0;
for (size_t i = 0; i < groups_.size(); i++)
if (dataname == "null" && swt == Enable)
{
if ((e_type == NotSet || groups_[i].type == e_type) && groups_[i].enabled) e += groups_[i].elem_ptrs.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].tar_ptrs.resize(e, nullptr);
datas_[d_id].val.resize(e, 0.0);
e = 0;
for (size_t i = 0; i < groups_.size(); i++)
for (size_t i = 0; i < datas_.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].tar_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.tar_ptrs.resize(e, nullptr);
new_data.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++)
{
new_data.tar_ptrs[e] = groups_[i].elem_ptrs[j];
new_data.val[e] = data[e];
e++;
}
datas_[i].enabled = true;
}
}
datas_.push_back(new_data);
return;
}
void gctl::mesh_io::add_element_data(std::string name, const array<double> &data, element_tag_enum tag_type, int tag)
{
size_t e = 0;
for (size_t i = 0; i < groups_.size(); i++)
else if (dataname == "null" && swt == Disable)
{
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 i = 0; i < datas_.size(); i++)
{
e += groups_[i].elem_ptrs.size();
datas_[i].enabled = false;
}
}
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)
else
{
array<void*> more_elem_ptrs(e, nullptr);
array<double> more_val(e, 0.0);
e = 0;
for (size_t i = 0; i < groups_.size(); i++)
for (size_t i = 0; i < datas_.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].tar_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.tar_ptrs.resize(e, nullptr);
new_data.val.resize(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++)
{
new_data.tar_ptrs[e] = groups_[i].elem_ptrs[j];
new_data.val[e] = data[e];
e++;
}
if (datas_[i].str_tag.front() == dataname && swt == Enable) datas_[i].enabled = true;
if (datas_[i].str_tag.front() == dataname && swt == Disable) datas_[i].enabled = false;
}
}
datas_.push_back(new_data);
return;
}
void gctl::mesh_io::add_element_data(std::string name, std::string phys_name, const array<double> &data)
{
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();
}
}
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<void*> 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] = data[e];
e++;
}
}
}
datas_[d_id].int_tag[2] += e;
datas_[d_id].tar_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.tar_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.tar_ptrs[e] = groups_[i].elem_ptrs[j];
new_data.val[e] = data[e];
e++;
}
}
}
datas_.push_back(new_data);
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<void*> 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].tar_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.tar_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.tar_ptrs[e] = groups_[i].elem_ptrs[j];
new_data.val[e] = phys_val;
e++;
}
}
}
datas_.push_back(new_data);
return;
}
@ -1793,7 +1471,7 @@ void gctl::mesh_io::save_gmsh_v2_ascii(std::string filename, index_packed_e is_p
{
if (reinterpret_cast<vertex3dc*>(datas_[i].tar_ptrs[n])->id != DEFAULT_INVALID_TAG) d_size++;
}
if (d_size)
{
outfile << "$NodeData\n";
@ -2174,4 +1852,32 @@ void gctl::mesh_io::sort_groups()
destroy_vector(tmp_groups);
return;
}
gctl::element_type_enum gctl::mesh_io::match_type(const std::type_info &tinfo)
{
std::smatch ret;
std::regex pat_triangle("type_triangle");
std::regex pat_tetrahedron("type_tetrahedron");
std::regex pat_block("type_block");
std::regex pat_edge("type_edge");
std::regex pat_edge2d("type_edge2d");
std::regex pat_node("type_node");
std::regex pat_prism("type_prism");
std::regex pat_rectangle2d("type_rectangle2d");
std::regex pat_tricone("type_tricone");
std::regex pat_triangle2d("type_triangle2d");
std::string t_str = tinfo.name();
if (regex_search(t_str, ret, pat_triangle)) return _3NodeTriangle;
else if (regex_search(t_str, ret, pat_tetrahedron)) return _4NodeTetrahedron;
else if (regex_search(t_str, ret, pat_block)) return _8NodeHexahedron;
else if (regex_search(t_str, ret, pat_edge)) return _2NodeLine;
else if (regex_search(t_str, ret, pat_edge2d)) return _2NodeLine;
else if (regex_search(t_str, ret, pat_node)) return _1NodePoint;
else if (regex_search(t_str, ret, pat_prism)) return _6NodePrism;
else if (regex_search(t_str, ret, pat_rectangle2d)) return _4NodeQuadrangle;
else if (regex_search(t_str, ret, pat_tricone)) return _4NodeTetrahedron;
else if (regex_search(t_str, ret, pat_triangle2d)) return _3NodeTriangle;
else return NotSet;
}

267
lib/io/mesh_io.h
View File

@ -194,14 +194,6 @@ namespace gctl
*/
void info(std::ostream &ss = std::clog);
/**
* @brief 编辑网格数据状态。
*
* @param swt 使能类型（Enable或Disable）
* @param dataname 数据名称（缺省值为null，表示对所有数据进行操作）。
*/
void edit_data(switch_type_e swt, std::string dataname = "null");
/**
* @brief 按单元体类型编辑网格单元体组。
*
@ -246,101 +238,78 @@ namespace gctl
*/
void edit_group(element_tag_enum anchor_type, int anchor_group, element_tag_enum tar_type, int tar_group);
/**
* @brief 返回顶点标签数组的引用。
*
* @return 整型数组的引用。
*/
const array<int> &get_node_tag();
/**
* @brief 返回指定类型与名称的标签值
*
* @param anchor_type 查找的标签类型（PhysicalTag，GeometryTag或者PartitionTag）。
* @param anchor_name 查找的元素组名称。
* @param tag_type 查找的标签类型（PhysicalTag，GeometryTag或者PartitionTag）。
* @param group_name 查找的元素组名称。
* @return 标签值
*/
int get_tag(element_tag_enum anchor_type, std::string anchor_name);
int group_tag(element_tag_enum tag_type, std::string group_name);
/**
* @brief 返回所有顶点数组的引用。
*
* @return 顶点数组的引用。
*/
const array<vertex3dc> &get_nodes();
const array<vertex3dc> &get_all_nodes();
/**
* @brief 返回所有单元体数组的引用。
*
* @return 单元体数组的引用。
*/
const array<meshio_element> &get_elems();
const array<meshio_element> &get_all_elems();
/**
* @brief 返回对应类型单元体的数量（注意只会统计有效的单元体组）。
* @brief 选择所有符合条件的单元体（注意只会统计有效的单元体组）。
*
* @param e_type 单元体类型（缺省为NotSet，返回所有单元体类型的总和）。
* @return 整型大小。
* @param e_type 单元体类型（缺省为NotSet，即选择所有单元体类型）。
*/
size_t element_size(element_type_enum e_type = NotSet);
void select_elements(element_type_enum e_type = NotSet);
/**
* @brief 返回对应标签类型与标签值的单元体数量（注意只会统计有效的单元体组）。
* @brief 选择所有符合条件的单元体（注意只会统计有效的单元体组）。
*
* @param tag_type 标签类型。
* @param tag 标签值。
* @return 整型大小。
*/
size_t element_size(element_tag_enum tag_type, int tag);
void select_elements(element_tag_enum tag_type, int tag);
/**
* @brief 返回对应名称的单元体数量（注意只会统计有效的单元体组）。
* @brief 选择所有符合条件的单元体（注意只会统计有效的单元体组）。
*
* @param phys_name 单元体组名称
* @return 整型大小。
*/
size_t element_size(std::string phys_name);
void select_elements(std::string phys_name);
/**
* @brief 将对应标签类型转换为网格数据类型
* @brief 返回已选择的单元体所对应的顶点数量（使用select_elements函数选择）。
*
* @param tag_type 标签类型。
* @return 顶点数量
*/
void convert_tags_to_data(element_tag_enum tag_type);
size_t node_size();
/**
* @brief 输出对应名称的单元体组到三角形数组。
* @brief 返回已选择的单元体的数量（使用select_elements函数选择）。
*
* @param tris 输出的三角形数组的引用。
* @param phys_name 单元体组的名称。
* @return 单元体数量
*/
void export_elements_to(array<triangle> &tris, std::string phys_name = "All");
size_t element_size();
/**
* @brief 输出对应标签类型与标签值的单元体组到三角形数组。
* @brief 返回已选择的单元体所对应的顶点标签
*
* @param tris 输出的三角形数组的引用。
* @param tag_type 标签类型。
* @param tag 标签值。
* @return 整型数组的引用。
*/
void export_elements_to(array<triangle> &tris, element_tag_enum tag_type, int tag);
const array<int> &node_tags();
/**
* @brief 输出对应名称的单元体组到四面体数组。
* @brief 返回已选择的单元体所对应的元素标签
*
* @param tets 输出的四面体数组的引用。
* @param phys_name 单元体组的名称。
* @return 整型数组的引用。
*/
void export_elements_to(array<tetrahedron> &tets, std::string phys_name = "All");
/**
* @brief 输出对应标签类型与标签值的单元体组到四面体数组。
*
* @param tris 输出的四面体数组的引用。
* @param tag_type 标签类型。
* @param tag 标签值。
*/
void export_elements_to(array<tetrahedron> &tets, element_tag_enum tag_type, int tag);
const array<int> &element_tags(element_tag_enum tag_type);
/**
* @brief 获取gmsh格式分组表
@ -349,6 +318,13 @@ namespace gctl
*/
void get_gmsh_physical_groups(std::vector<gmsh_physical_group> &g_groups);
/**
* @brief 将对应标签类型转换为网格数据类型
*
* @param tag_type 标签类型。
*/
void convert_tags_to_data(element_tag_enum tag_type);
/**
* @brief 检查是否存在名为name的数据
*
@ -378,70 +354,23 @@ namespace gctl
meshio_data *get_data_ptr(std::string name, mesh_data_type_e type);
/**
* @brief 添加一个顶点数据对象。数据将依次添加到所有顶点位置。
* @brief 添加一个顶点数据对象。数据将依次添加到已选择的顶点位置。
*
* @note 若对应名称的数据已经存在则会覆盖
*
* @param data 输入的数据数组，长度与网格所有顶点数据相同。
* @param data 输入的数据数组，长度与已选择的顶点数据相同。
* @param name 新建的数据名称。
* @param dtype 数据类型。
* @param op 数据的添加方式（OverWrite或Append）。
*/
void add_node_data(std::string name, const array<double> &data);
void add_data(std::string name, const array<double> &data,
mesh_data_type_e dtype, output_type_e op = OverWrite);
/**
* @brief 添加一个顶点数据对象。数据将依次添加到布尔为真的顶点位置。
* @brief 编辑网格数据状态。
*
* @note 若对应名称的数据已经存在则会覆盖
*
* @param data 输入的数据数组，长度与网格所有顶点数据相同。
* @param boolen 输入的布尔，只有为真元素位置的顶点数据将被保存。
* @param name 新建的数据名称。
* @param swt 使能类型（Enable或Disable）
* @param dataname 数据名称（缺省值为null，表示对所有数据进行操作）。
*/
void add_node_data(std::string name, const array<double> &data, const array<bool> &boolen);
/**
* @brief 按单元体类型筛选创建一个单元体数据对象。数据将依次添加到所选元素位置。
*
* @note 若对应名称的数据已经存在则会覆盖
*
* @param data 输入的数据数组。
* @param name 新建数据名称。
* @param e_type 新建数据的单元体类型（缺省值为NotSet，表示选择所有有效的单元体）。
*/
void add_element_data(std::string name, const array<double> &data, element_type_enum e_type = NotSet);
/**
* @brief 按单元体标签值筛选创建一个单元体数据对象。
*
* @note 若对应名称的数据已经存在则会追加
*
* @param data 输入的数据数组。
* @param name 新建数据名称。
* @param tag_type 标签类型。
* @param tag 标签值。
*/
void add_element_data(std::string name, const array<double> &data, element_tag_enum tag_type, int tag);
/**
* @brief 按单元体组的名称筛选创建一个单元体数据对象。
*
* @note 若对应名称的数据已经存在则会追加
*
* @param data 输入的数据数组。
* @param name 新建数据名称。
* @param 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);
void edit_data(switch_type_e swt, std::string dataname = "null");
/**
* @brief 读入triangle软件输出的网格剖分文件。
@ -492,10 +421,35 @@ namespace gctl
* @param refR 参考椭球的长半径（out_coor为Cartesian时无效）
*/
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);
/**
* @brief 提取对应类型和单元体到外部数组。
*
* @tparam T 单元体类型。
* @param elems 新生成的单元体数组的引用。
* @param nodes 新生成的顶点数组的引用。
*/
template <typename T>
void export_to(array<T> &elems, array<vertex3dc> &nodes);
/**
* @brief 提取对应类型和单元体到外部数组。
*
* @tparam T 单元体类型。
* @param elems 新生成的单元体数组的引用。
* @param nodes 新生成的顶点数组的引用。
* @param x_id 二维坐标系统的x索引（缺省值为0）。
* @param y_id 二维坐标系统的y索引（缺省值为1）。
*
* @note 二维坐标系统的索引表示取xyz坐标中的对应项分别赋值给二维坐标的xy值，{0,1}即为xoy平面、
* {1,0}即为yox平面、{0,2}即为xoz平面、{1,2}即为yoz平面。
*/
template <typename T>
void export_to(array<T> &elems, array<vertex2dc> &nodes, int x_id = 0, int y_id = 1);
protected:
bool initialized_; // 类型是否已经初始化完成
// 有效的顶点、单元体和单元体组的数量
size_t valid_node_size_, valid_elem_size_, valid_group_size_;
array<vertex3dc> nodes_; // 网格顶点 当顶点索引为无效值时将不会被输出
@ -503,7 +457,13 @@ namespace gctl
std::vector<meshio_data> datas_; // 网格数据
std::vector<meshio_element_group> groups_; // 网格单元体组
array<int> nodes_tag_; // 顶点标签
array<int> selected_node_tag_; // 被选择的顶点的标签
array<int> selected_elem_tag_; // 被选择的单元体的标签
std::vector<vertex3dc*> selected_nodes_; // 被选择的顶点
std::vector<meshio_element*> selected_elems_; // 被选择的单元体
std::vector<meshio_element_group*> selected_groups_; // 被选择的单元体组
element_type_enum elem_gmshcode2type_[94]; // gmsh的单元体类型数组 数组索引为gmsh的单元体类型码值
element_type_enum elem_vtkcode2type_[14]; // vtk的单元体类型数组 数组索引为vtk的单元体类型码值
std::map<element_type_enum, int> elem_type2gmshcode_; // 单元体类型到gmsh类型码值的映射
@ -519,7 +479,84 @@ namespace gctl
element_type_enum elem_vtk_type(int code); // 获取对应vtk类型码的单元体类型
void update_indexing(); // 更新索引（对网格的元素进行操作后需调用）
void sort_groups(); // 对单元体组进行梳理（对网格的元素进行操作后需调用）
element_type_enum match_type(const std::type_info &tinfo); // 根据type_info返回单元体类型
};
template <typename T>
void gctl::mesh_io::export_to(array<T> &elems, array<vertex3dc> &nodes)
{
const std::type_info &tinfo = typeid(T);
element_type_enum oe_type = match_type(tinfo);
size_t n = selected_nodes_.size();
size_t s = selected_elems_.size();
std::map<int, int> node_map;
nodes.resize(n);
for (size_t i = 0; i < n; i++)
{
node_map[selected_nodes_[i]->id] = i; // 原网格顶点索引到新网格顶点索引的映射
nodes[i].id = i;
nodes[i].x = selected_nodes_[i]->x;
nodes[i].y = selected_nodes_[i]->y;
nodes[i].z = selected_nodes_[i]->z;
}
int vnum = elem_size(oe_type);
elems.resize(s);
for (size_t i = 0; i < s; i++)
{
if (selected_elems_[i]->type != oe_type)
throw gctl::invalid_argument("[gctl::mesh_io::export_to] The selected element is not " + elem_name(oe_type) + ".");
elems[i].id = i;
for (size_t v = 0; v < vnum; v++)
elems[i].vert[v] = nodes.get(node_map[selected_elems_[i]->vert_ptrs[v]->id]);
}
node_map.clear();
return;
}
template <typename T>
void gctl::mesh_io::export_to(array<T> &elems, array<vertex2dc> &nodes, int x_id, int y_id)
{
const std::type_info &tinfo = typeid(T);
element_type_enum oe_type = match_type(tinfo);
size_t n = selected_nodes_.size();
size_t s = selected_elems_.size();
std::map<int, int> node_map;
nodes.resize(n);
double xyz_ref[3];
for (size_t i = 0; i < n; i++)
{
node_map[selected_nodes_[i]->id] = i; // 原网格顶点索引到新网格顶点索引的映射
nodes[i].id = i;
xyz_ref[0] = selected_nodes_[i]->x;
xyz_ref[1] = selected_nodes_[i]->y;
xyz_ref[2] = selected_nodes_[i]->z;
nodes[i].x = xyz_ref[x_id];
nodes[i].y = xyz_ref[y_id];
}
int vnum = elem_size(oe_type);
elems.resize(s);
for (size_t i = 0; i < s; i++)
{
if (selected_elems_[i]->type != oe_type)
throw gctl::invalid_argument("[gctl::mesh_io::export_to] The selected element is not " + elem_name(oe_type) + ".");
elems[i].id = i;
for (size_t v = 0; v < vnum; v++)
elems[i].vert[v] = nodes.get(node_map[selected_elems_[i]->vert_ptrs[v]->id]);
}
node_map.clear();
return;
}
};
#endif // _GCTL_MESH_IO_H

11
tool/dsviewer/example.csv Normal file
View File

@ -0,0 +1,11 @@
Name,Age,Gender,Occupation,City,Phone Number,Email,Annual Income,Company,Position
John Doe,28,Male,Engineer,New York,123-456-7890,john.doe@example.com,$75000,ABC Tech,Senior Software Engineer
Jane Smith,34,Female,Teacher,Los Angeles,234-567-8901,jane.smith@example.com,$55000,XYZ School,Math Teacher
Michael Brown,22,Male,Student,Toronto,345-678-9012,michael.brown@example.com,$18000,University of Toronto,Undergraduate Student
Emily Davis,45,Female,Doctor,Chicago,456-789-0123,emily.davis@example.com,$180000,Chicago Medical Center,Cardiologist
David Wilson,30,Male,Designer,San Francisco,567-890-1234,david.wilson@example.com,$90000,DesignWorks,Senior Graphic Designer
Sarah Johnson,29,Female,Marketing Specialist,Seattle,678-901-2345,sarah.johnson@example.com,$85000,MarketingPro,Marketing Manager
Robert Lee,36,Male,Software Developer,Boston,789-012-3456,robert.lee@example.com,$120000,SoftDev Solutions,Lead Developer
Laura Miller,25,Female,Graphic Designer,Denver,890-123-4567,laura.miller@example.com,$60000,Creative Arts,Junior Designer
William Clark,40,Male,Consultant,Atlanta,901-234-5678,william.clark@example.com,$110000,ConsultPro,Business Consultant
Olivia Turner,33,Female,Researcher,Phoenix,012-345-6789,olivia.turner@example.com,$70000,ResearchInnovate,Research Scientist
1 Name Age Gender Occupation City Phone Number Email Annual Income Company Position
2 John Doe 28 Male Engineer New York 123-456-7890 john.doe@example.com $75000 ABC Tech Senior Software Engineer
3 Jane Smith 34 Female Teacher Los Angeles 234-567-8901 jane.smith@example.com $55000 XYZ School Math Teacher
4 Michael Brown 22 Male Student Toronto 345-678-9012 michael.brown@example.com $18000 University of Toronto Undergraduate Student
5 Emily Davis 45 Female Doctor Chicago 456-789-0123 emily.davis@example.com $180000 Chicago Medical Center Cardiologist
6 David Wilson 30 Male Designer San Francisco 567-890-1234 david.wilson@example.com $90000 DesignWorks Senior Graphic Designer
7 Sarah Johnson 29 Female Marketing Specialist Seattle 678-901-2345 sarah.johnson@example.com $85000 MarketingPro Marketing Manager
8 Robert Lee 36 Male Software Developer Boston 789-012-3456 robert.lee@example.com $120000 SoftDev Solutions Lead Developer
9 Laura Miller 25 Female Graphic Designer Denver 890-123-4567 laura.miller@example.com $60000 Creative Arts Junior Designer
10 William Clark 40 Male Consultant Atlanta 901-234-5678 william.clark@example.com $110000 ConsultPro Business Consultant
11 Olivia Turner 33 Female Researcher Phoenix 012-345-6789 olivia.turner@example.com $70000 ResearchInnovate Research Scientist