496 lines
12 KiB
C++
496 lines
12 KiB
C++
#ifndef _FUNC_H
|
|
#define _FUNC_H
|
|
#include "iostream"
|
|
#include "fstream"
|
|
#include "sstream"
|
|
#include "stdio.h"
|
|
#include "string.h"
|
|
#include "iomanip"
|
|
#include "list"
|
|
#include "algorithm"
|
|
#include "map"
|
|
|
|
#define MeshFormat "$MeshFormat"
|
|
#define EndMeshFormat "$EndMeshFormat"
|
|
#define PhysicalNames "$PhysicalNames"
|
|
#define EndPhysicalNames "$EndPhysicalNames"
|
|
#define Nodes "$Nodes"
|
|
#define EndNodes "$EndNodes"
|
|
#define Elements "$Elements"
|
|
#define EndElements "$EndElements"
|
|
#define NodeData "$NodeData"
|
|
#define EndNodeData "$EndNodeData"
|
|
#define ElementData "$ElementData"
|
|
#define EndElementData "$EndElementData"
|
|
|
|
using namespace std;
|
|
|
|
struct phys_str
|
|
{
|
|
int id;
|
|
int dim;
|
|
char name[1024];
|
|
};
|
|
|
|
struct node_str
|
|
{
|
|
int id;
|
|
double x,y,z;
|
|
};
|
|
|
|
struct element_str
|
|
{
|
|
int id;
|
|
int type;
|
|
int tag_num;
|
|
int tag[3];
|
|
int* node_id;
|
|
};
|
|
|
|
struct nodedata_str
|
|
{
|
|
int id;
|
|
double value;
|
|
};
|
|
|
|
struct elemdata_str
|
|
{
|
|
int id;
|
|
double value;
|
|
};
|
|
|
|
typedef list<int> ListELementType;
|
|
typedef list<int> ListPhysical;
|
|
typedef list<int> ListGeometry;
|
|
typedef map<int,string> TypeMap;
|
|
typedef map<string,int> CataMap;
|
|
typedef map<int,string> PhysMap;
|
|
|
|
class MshSet
|
|
{
|
|
public:
|
|
MshSet();
|
|
~MshSet();
|
|
int init();
|
|
int readmsh(char*);
|
|
int outmsh(char*,char*,int*,double*,int);
|
|
int relese_node_id();
|
|
private:
|
|
double version_num;
|
|
int file_type;
|
|
int data_size;
|
|
|
|
int node_num;
|
|
node_str* node;
|
|
|
|
int elem_num;
|
|
element_str* element;
|
|
|
|
int str_tag_num;
|
|
string* str_tag;
|
|
int real_tag_num;
|
|
double* real_tag;
|
|
int int_tag_num;
|
|
int int_tag[3];
|
|
int nodedata_num;
|
|
nodedata_str* nodedata;
|
|
double nodedata_max;
|
|
double nodedata_min;
|
|
|
|
int ele_str_tag_num;
|
|
string* ele_str_tag;
|
|
int ele_real_tag_num;
|
|
double* ele_real_tag;
|
|
int ele_int_tag_num;
|
|
int ele_int_tag[3];
|
|
int elemdata_num;
|
|
elemdata_str* elemdata;
|
|
double elemdata_max;
|
|
double elemdata_min;
|
|
|
|
ListELementType type_list;
|
|
ListELementType::iterator it;
|
|
ListPhysical phys_list;
|
|
ListPhysical::iterator ip;
|
|
ListGeometry geom_list;
|
|
ListGeometry::iterator ig;
|
|
|
|
TypeMap map_type;
|
|
TypeMap::iterator im;
|
|
CataMap map_cata;
|
|
CataMap::iterator ic;
|
|
PhysMap map_phys;
|
|
PhysMap::iterator ih;
|
|
int typeint[94];
|
|
|
|
char* inputname;
|
|
};
|
|
|
|
MshSet::MshSet()
|
|
{
|
|
node = NULL;
|
|
element = NULL;
|
|
str_tag = NULL;
|
|
real_tag = NULL;
|
|
nodedata = NULL;
|
|
ele_str_tag = NULL;
|
|
ele_real_tag = NULL;
|
|
elemdata = NULL;
|
|
}
|
|
|
|
MshSet::~MshSet()
|
|
{
|
|
if(node!=NULL) delete[] node;
|
|
if(element!=NULL) delete[] element;
|
|
if(str_tag!=NULL) delete[] str_tag;
|
|
if(real_tag!=NULL) delete[] real_tag;
|
|
if(nodedata!=NULL) delete[] nodedata;
|
|
if(ele_str_tag!=NULL) delete[] ele_str_tag;
|
|
if(ele_real_tag!=NULL) delete[] ele_real_tag;
|
|
if(elemdata!=NULL) delete[] elemdata;
|
|
if(!type_list.empty()) type_list.clear();
|
|
if(!phys_list.empty()) phys_list.clear();
|
|
if(!geom_list.empty()) geom_list.clear();
|
|
if(!map_type.empty()) map_type.clear();
|
|
if(!map_cata.empty()) map_cata.clear();
|
|
if(!map_phys.empty()) map_phys.clear();
|
|
}
|
|
|
|
int MshSet::init()
|
|
{
|
|
nodedata_max = -1e+30;
|
|
nodedata_min = 1e+30;
|
|
|
|
elemdata_max = -1e+30;
|
|
elemdata_min = 1e+30;
|
|
|
|
map_type[1] = "2-node line";
|
|
map_type[2] = "3-node triangle";
|
|
map_type[3] = "4-node quadrangle";
|
|
map_type[4] = "4-node tetrahedron";
|
|
map_type[5] = "8-node hexahedron";
|
|
map_type[6] = "6-node prism";
|
|
map_type[7] = "5-node pyramid";
|
|
map_type[8] = "3-node second order line";
|
|
map_type[9] = "6-ndoe second order line";
|
|
map_type[10] = "9-node second order quadrangle";
|
|
map_type[11] = "10-node second order tetrahedron";
|
|
map_type[12] = "27-node second order hexahedron";
|
|
map_type[13] = "18-node second order prism";
|
|
map_type[14] = "14-node second order pyramid";
|
|
map_type[15] = "1-node point";
|
|
map_type[16] = "8-node second order quadrangle";
|
|
map_type[17] = "20-ndoe second order hexahedron";
|
|
map_type[18] = "15-node second order prism";
|
|
map_type[19] = "13-node second order pyramid";
|
|
map_type[20] = "9-node third order incomplete triangle";
|
|
map_type[21] = "10-ndoe third order triangle";
|
|
map_type[22] = "12-node fourth order incomplete triangle";
|
|
map_type[23] = "15-node fourth order triangle";
|
|
map_type[24] = "15-node fifth order complete triangle";
|
|
map_type[25] = "21-node fifth order complete triangle";
|
|
map_type[26] = "4-node third order edge";
|
|
map_type[27] = "5-node fourth order edge";
|
|
map_type[28] = "6-node fifth order edge";
|
|
map_type[29] = "20-node third order tetrahedron";
|
|
map_type[30] = "35-node fourth order tetrahedron";
|
|
map_type[31] = "56-node fifith order tetrahedron";
|
|
map_type[92] = "64-node third order hexahedron";
|
|
map_type[93] = "125-node fourth order hexahedron";
|
|
|
|
typeint[1] = 2; typeint[2] = 3; typeint[3] = 4; typeint[4] = 4; typeint[5] = 8;
|
|
typeint[6] = 6; typeint[7] = 5; typeint[8] = 3; typeint[9] = 6; typeint[10] = 6;
|
|
typeint[11] = 10; typeint[12] = 27; typeint[13] = 18; typeint[14] = 14; typeint[15] = 1;
|
|
typeint[16] = 8; typeint[17] = 20; typeint[18] = 15; typeint[19] = 13; typeint[20] = 9;
|
|
typeint[21] = 10; typeint[22] = 12; typeint[23] = 15; typeint[24] = 15; typeint[25] = 21;
|
|
typeint[26] = 4; typeint[27] = 5; typeint[28] = 6; typeint[29] = 20; typeint[30] = 35;
|
|
typeint[31] = 56; typeint[92] = 64; typeint[93] = 125;
|
|
return 0;
|
|
}
|
|
|
|
int MshSet::readmsh(char* filename)
|
|
{
|
|
string curline;
|
|
string strtemp,temp_head,temp_middle;
|
|
stringstream stemp;
|
|
ifstream mshin(filename);
|
|
if (!mshin)
|
|
{
|
|
cout<<filename<<" not found!"<<endl;
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
inputname = filename;
|
|
while(getline(mshin,curline))
|
|
{
|
|
if (curline==MeshFormat)
|
|
{
|
|
mshin>>version_num>>file_type>>data_size;
|
|
if (file_type!=0)
|
|
{
|
|
cout<<filename<<" not supported!"<<endl;
|
|
return 1;
|
|
}
|
|
}
|
|
else if (curline==EndMeshFormat) continue;
|
|
else if (curline==PhysicalNames)
|
|
{
|
|
int phys_num;
|
|
phys_str phys_temp;
|
|
mshin>>phys_num;
|
|
for (int i = 0; i < phys_num; ++i)
|
|
{
|
|
mshin>>phys_temp.dim>>phys_temp.id>>strtemp;
|
|
sscanf(strtemp.c_str(),"\"%[0-9a-zA-Z]",phys_temp.name);
|
|
map_phys[phys_temp.id] = phys_temp.name;
|
|
}
|
|
}
|
|
else if (curline==EndPhysicalNames) continue;
|
|
else if (curline==Nodes)
|
|
{
|
|
mshin>>node_num;
|
|
node = new node_str [node_num];
|
|
for (int i = 0; i < node_num; ++i)
|
|
{
|
|
mshin>>node[i].id>>node[i].x>>node[i].y>>node[i].z;
|
|
}
|
|
}
|
|
else if (curline==EndNodes) continue;
|
|
else if (curline==Elements)
|
|
{
|
|
mshin>>elem_num;
|
|
element = new element_str [elem_num];
|
|
for (int i = 0; i < elem_num; ++i)
|
|
{
|
|
element[i].node_id = NULL;
|
|
for (int j = 0; j < 3; ++j)
|
|
{
|
|
element[i].tag[j] = 1e+5;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < elem_num; ++i)
|
|
{
|
|
mshin>>element[i].id>>element[i].type>>element[i].tag_num;
|
|
im = map_type.find(element[i].type);
|
|
if (im==map_type.end())
|
|
{
|
|
cout<<"unsupported element type!"<<endl;
|
|
return 1;
|
|
}
|
|
|
|
if (type_list.empty())
|
|
{
|
|
type_list.push_back(element[i].type);
|
|
}
|
|
else
|
|
{
|
|
it = find(type_list.begin(),type_list.end(),element[i].type);
|
|
if (it==type_list.end()) type_list.push_back(element[i].type);
|
|
}
|
|
|
|
for (int j = 0; j < element[i].tag_num; ++j)
|
|
{
|
|
mshin>>element[i].tag[j];
|
|
}
|
|
if (element[i].tag_num==1)
|
|
{
|
|
if (phys_list.empty())
|
|
{
|
|
phys_list.push_back(element[i].tag[0]);
|
|
}
|
|
else
|
|
{
|
|
ip = find(phys_list.begin(),phys_list.end(),element[i].tag[0]);
|
|
if (ip==phys_list.end()) phys_list.push_back(element[i].tag[0]);
|
|
}
|
|
}
|
|
else if (element[i].tag_num==2)
|
|
{
|
|
if (phys_list.empty())
|
|
{
|
|
phys_list.push_back(element[i].tag[0]);
|
|
}
|
|
else
|
|
{
|
|
ip = find(phys_list.begin(),phys_list.end(),element[i].tag[0]);
|
|
if (ip==phys_list.end()) phys_list.push_back(element[i].tag[0]);
|
|
}
|
|
|
|
if (geom_list.empty())
|
|
{
|
|
geom_list.push_back(element[i].tag[1]);
|
|
}
|
|
else
|
|
{
|
|
ig = find(geom_list.begin(),geom_list.end(),element[i].tag[1]);
|
|
if (ig==geom_list.end()) geom_list.push_back(element[i].tag[1]);
|
|
}
|
|
}
|
|
|
|
element[i].node_id = new int [typeint[element[i].type]];
|
|
for (int k = 0; k < typeint[element[i].type]; ++k)
|
|
{
|
|
mshin>>element[i].node_id[k];
|
|
}
|
|
|
|
temp_head = "";
|
|
stemp.clear();
|
|
stemp<<element[i].type;
|
|
stemp>>temp_head;
|
|
for (int j = 0; j < element[i].tag_num; ++j)
|
|
{
|
|
stemp.clear();
|
|
stemp<<element[i].tag[j];
|
|
stemp>>temp_middle;
|
|
temp_head = temp_head + " " + temp_middle;
|
|
}
|
|
ic = map_cata.find(temp_head);
|
|
if (ic==map_cata.end()) map_cata[temp_head] = 1;
|
|
else map_cata[temp_head] = ic->second + 1;
|
|
}
|
|
}
|
|
else if (curline==EndElements) continue;
|
|
else if (curline==NodeData)
|
|
{
|
|
mshin>>str_tag_num;
|
|
str_tag = new string [str_tag_num];
|
|
getline(mshin,strtemp);//这里加1是因为需要跳过一个上一行的换行符
|
|
for (int i = 0; i < str_tag_num; ++i)
|
|
{
|
|
getline(mshin,strtemp);
|
|
str_tag[i] = strtemp;
|
|
}
|
|
mshin>>real_tag_num;
|
|
real_tag = new double [real_tag_num];
|
|
for (int i = 0; i < real_tag_num; ++i)
|
|
{
|
|
mshin>>real_tag[i];
|
|
}
|
|
mshin>>int_tag_num;
|
|
for (int i = 0; i < int_tag_num; ++i)
|
|
{
|
|
mshin>>int_tag[i];
|
|
}
|
|
nodedata_num = int_tag[int_tag_num-1];
|
|
nodedata = new nodedata_str [nodedata_num];
|
|
for (int i = 0; i < nodedata_num; ++i)
|
|
{
|
|
mshin>>nodedata[i].id>>nodedata[i].value;
|
|
if (nodedata[i].value<nodedata_min) nodedata_min = nodedata[i].value;
|
|
if (nodedata[i].value>nodedata_max) nodedata_max = nodedata[i].value;
|
|
}
|
|
}
|
|
else if (curline==EndNodeData) continue;
|
|
else if (curline==ElementData)
|
|
{
|
|
mshin>>ele_str_tag_num;
|
|
ele_str_tag = new string [ele_str_tag_num];
|
|
getline(mshin,strtemp);//这里加1是因为需要跳过一个上一行的换行符
|
|
for (int i = 0; i < ele_str_tag_num; ++i)
|
|
{
|
|
getline(mshin,strtemp);
|
|
ele_str_tag[i] = strtemp;
|
|
}
|
|
mshin>>ele_real_tag_num;
|
|
ele_real_tag = new double [ele_real_tag_num];
|
|
for (int i = 0; i < ele_real_tag_num; ++i)
|
|
{
|
|
mshin>>ele_real_tag[i];
|
|
}
|
|
mshin>>ele_int_tag_num;
|
|
for (int i = 0; i < ele_int_tag_num; ++i)
|
|
{
|
|
mshin>>ele_int_tag[i];
|
|
}
|
|
elemdata_num = ele_int_tag[ele_int_tag_num-1];
|
|
elemdata = new elemdata_str [elemdata_num];
|
|
for (int i = 0; i < elemdata_num; ++i)
|
|
{
|
|
mshin>>elemdata[i].id>>elemdata[i].value;
|
|
if (elemdata[i].value<elemdata_min) elemdata_min = elemdata[i].value;
|
|
if (elemdata[i].value>elemdata_max) elemdata_max = elemdata[i].value;
|
|
}
|
|
}
|
|
else if (curline==EndElementData) continue;
|
|
}
|
|
mshin.close();
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int MshSet::outmsh(char* infilename,char* outfilename,int* input_type,double* input_value,int input_num)
|
|
{
|
|
int total_num = 0;
|
|
int inttemp;
|
|
string strtemp;
|
|
stringstream stemp;
|
|
ifstream mshin(infilename);
|
|
ofstream mshout(outfilename);
|
|
if (!mshout)
|
|
{
|
|
cout<<"can not create "<<outfilename<<endl;
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
while(getline(mshin,strtemp))
|
|
{
|
|
mshout<<strtemp<<endl;
|
|
}
|
|
mshin.close();
|
|
|
|
for (int i = 0; i < input_num; ++i)
|
|
{
|
|
for (ic=map_cata.begin();ic!=map_cata.end();++ic)
|
|
{
|
|
strtemp = ic->first;
|
|
stemp.clear();
|
|
stemp<<strtemp;
|
|
stemp>>inttemp>>inttemp;
|
|
if (*(input_type+i)==inttemp)
|
|
{
|
|
//total_num += ic->second;
|
|
total_num = ic->second;
|
|
mshout<<ElementData<<endl;
|
|
mshout<<1<<endl<<"\"PhysicGroup model " << i << "\"" <<endl<<1<<endl<<0<<endl<<3<<endl<<0<<endl<<1<<endl<<total_num<<endl;
|
|
for (int j = 0; j < elem_num; ++j)
|
|
{
|
|
if (element[j].tag[0] == *(input_type+i))
|
|
{
|
|
mshout<<element[j].id<<" "<< *(input_value+i) <<endl;
|
|
}
|
|
}
|
|
mshout<<EndElementData<<endl;
|
|
}
|
|
}
|
|
}
|
|
/*
|
|
mshout<<ElementData<<endl;
|
|
mshout<<1<<endl<<"\"gmshset model\""<<endl<<1<<endl<<0<<endl<<3<<endl<<0<<endl<<1<<endl<<total_num<<endl;
|
|
for (int j = 0; j < input_num; ++j)
|
|
{
|
|
for (int i = 0; i < elem_num; ++i)
|
|
{
|
|
if (element[i].tag[0] == *(input_type+j))
|
|
{
|
|
mshout<<element[i].id<<" "<< *(input_value+j) <<endl;
|
|
}
|
|
}
|
|
}
|
|
mshout<<EndElementData;
|
|
*/
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int MshSet::relese_node_id()
|
|
{
|
|
for (int i = 0; i < elem_num; ++i)
|
|
{
|
|
if (element[i].node_id!=NULL) delete[] element[i].node_id;
|
|
}
|
|
return 0;
|
|
}
|
|
#endif |