1124 lines
29 KiB
C++
1124 lines
29 KiB
C++
#ifndef _TETRA_G_H
|
||
#define _TETRA_G_H
|
||
#include "Data_Func.h"
|
||
#include "res_reg.h"
|
||
class Tetra_G
|
||
{
|
||
public:
|
||
Tetra_G();
|
||
~Tetra_G();
|
||
|
||
int info_taker_run(int,string,string,string);//读入必要参数
|
||
int info_taker_run(int,string,double*,string,double *);//读入必要参数
|
||
int info_taker_run(int,string,double*,string);
|
||
int info_taker_run(int,string,string,string,double *);
|
||
|
||
int readnode(string);//读取.node文件并保存至结构体vertex
|
||
|
||
int readele(string);//读取.ele文件并保存至结构体tetrahedron
|
||
int readele(string,double *);//读取.ele文件并保存至结构体tetrahedron
|
||
|
||
int readmsh(string,double *);//读取.msh文件
|
||
|
||
int field_reader(int,string);//读取观测面信息保存至结构体point3d
|
||
int manual_input(int,double *);//手工输入计算信息保存至结构体field_point，只适用于水平观测面
|
||
|
||
int cal_tetra_info();//计算四面体属性
|
||
|
||
double cal_tetra_gc(point3d);//计算四面体网络在单个观测点的重力异常值
|
||
int cal_tetra_ggc(point3d,double &,double &,double &);
|
||
double cal_tetra_gs(point3d,sphere_point);//计算四面体网络在单个观测点的重力异常值
|
||
int cal_tetra_ggs(point3d,sphere_point,double &,double &,double &);
|
||
|
||
int cal_total_g(int,string);//计算所有四面体重力异常，并利用res_reg类进行保存
|
||
private:
|
||
double once_time;//一次四面体到计算值的所用时间
|
||
clock_t start,finish;
|
||
|
||
//info_taker_run
|
||
string nodename;
|
||
string elename;
|
||
string mshname;
|
||
|
||
//readnode&&readmsh
|
||
int vertex_sum;
|
||
vertex *vert;
|
||
|
||
int edge_sum;
|
||
edge *edg;
|
||
|
||
int face_sum;
|
||
face *fac;
|
||
|
||
//readele&&readmsh
|
||
int tetra_sum;
|
||
tetra *tet;
|
||
|
||
//readmsh
|
||
int element_sum;
|
||
|
||
//field_reader&&manual_input
|
||
int fie_sum;
|
||
point3d *fie;
|
||
sphere_point *s_point;
|
||
|
||
//cal_total_g
|
||
double *_Obdata;
|
||
double *_Obdata2;
|
||
double *_Obdata3;
|
||
};
|
||
/************************************************************************/
|
||
Tetra_G::Tetra_G()
|
||
{
|
||
once_time=2e-7;//通过实验计算得到单次计算耗时
|
||
vert = NULL;
|
||
edg = NULL;
|
||
fac = NULL;
|
||
tet = NULL;
|
||
fie = NULL;
|
||
s_point = NULL;
|
||
_Obdata = NULL;
|
||
_Obdata2 = NULL;
|
||
_Obdata3 = NULL;
|
||
}
|
||
|
||
Tetra_G::~Tetra_G()
|
||
{
|
||
if(tet!=NULL)
|
||
{
|
||
for(int i=0;i<tetra_sum;i++)
|
||
{
|
||
if(tet[i].attribute) delete []tet[i].attribute;
|
||
}
|
||
delete []tet;
|
||
}
|
||
if(vert!=NULL) delete []vert;
|
||
if(edg!=NULL) delete []edg;
|
||
if(fac!=NULL) delete []fac;
|
||
if(fie!=NULL) delete []fie;
|
||
if(s_point!=NULL) delete []s_point;
|
||
if(_Obdata!=NULL) delete []_Obdata;
|
||
if(_Obdata2!=NULL) delete []_Obdata2;
|
||
if(_Obdata3!=NULL) delete []_Obdata3;
|
||
}
|
||
/************************************************************************/
|
||
int Tetra_G::info_taker_run(int calculate_type,string meshname,double *ob_info,string savename,double *attri)
|
||
{
|
||
elename = meshname + ".ele";
|
||
nodename = meshname + ".node";
|
||
mshname = meshname + ".msh";
|
||
if(access(elename.c_str(),F_OK)&&access(nodename.c_str(),F_OK)&&access(mshname.c_str(),F_OK)){
|
||
cout<<"No surpported file exist!";
|
||
return 1;
|
||
}
|
||
|
||
if(!access(elename.c_str(),F_OK)&&!access(nodename.c_str(),F_OK))
|
||
{
|
||
readnode(nodename);
|
||
readele(elename,attri);
|
||
}
|
||
else if(!access(mshname.c_str(),F_OK))
|
||
{
|
||
readmsh(mshname,attri);
|
||
}
|
||
|
||
if(manual_input(calculate_type,ob_info)) return 1;
|
||
cal_tetra_info();
|
||
cal_total_g(calculate_type,savename);
|
||
return 0;
|
||
}
|
||
|
||
int Tetra_G::info_taker_run(int calculate_type,string meshname,string fiename,string savename)
|
||
{
|
||
elename = meshname + ".ele";
|
||
nodename = meshname + ".node";
|
||
if(access(elename.c_str(),F_OK)&&access(nodename.c_str(),F_OK)){
|
||
cout<<"No surpported file exist!";
|
||
return 1;
|
||
}
|
||
|
||
readnode(nodename);
|
||
readele(elename);
|
||
|
||
if(field_reader(calculate_type,fiename)) return 1;
|
||
cal_tetra_info();
|
||
cal_total_g(calculate_type,savename);
|
||
return 0;
|
||
}
|
||
|
||
int Tetra_G::info_taker_run(int calculate_type,string meshname,double *ob_info,string savename)
|
||
{
|
||
elename = meshname + ".ele";
|
||
nodename = meshname + ".node";
|
||
if(access(elename.c_str(),F_OK)&&access(nodename.c_str(),F_OK)){
|
||
cout<<"No surpported file exist!";
|
||
return 1;
|
||
}
|
||
|
||
readnode(nodename);
|
||
readele(elename);
|
||
|
||
if(manual_input(calculate_type,ob_info)) return 1;
|
||
cal_tetra_info();
|
||
cal_total_g(calculate_type,savename);
|
||
return 0;
|
||
}
|
||
|
||
int Tetra_G::info_taker_run(int calculate_type,string meshname,string fiename,string savename,double *attri)
|
||
{
|
||
elename = meshname + ".ele";
|
||
nodename = meshname + ".node";
|
||
mshname = meshname + ".msh";
|
||
if(access(elename.c_str(),F_OK)&&access(nodename.c_str(),F_OK)&&access(mshname.c_str(),F_OK)){
|
||
cout<<"No surpported file exist!";
|
||
return 1;
|
||
}
|
||
|
||
if(!access(elename.c_str(),F_OK)&&!access(nodename.c_str(),F_OK))
|
||
{
|
||
readnode(nodename);
|
||
readele(elename,attri);
|
||
}
|
||
else if(!access(mshname.c_str(),F_OK))
|
||
{
|
||
readmsh(mshname,attri);
|
||
}
|
||
|
||
if(field_reader(calculate_type,fiename)) return 1;
|
||
cal_tetra_info();
|
||
cal_total_g(calculate_type,savename);
|
||
return 0;
|
||
}
|
||
/************************************************************************/
|
||
int Tetra_G::readnode(string filename)
|
||
{
|
||
cout<<"reading "<<filename<<"... ";
|
||
start = clock();
|
||
|
||
const char* openname = filename.c_str();
|
||
ifstream nodein(openname);
|
||
int temp,first_No;
|
||
nodein>>vertex_sum>>temp>>temp>>temp>>first_No;
|
||
nodein.seekg(-1,ios::cur);
|
||
vert = new vertex [vertex_sum];
|
||
if(first_No==1)
|
||
{
|
||
for(int i=0;i<vertex_sum;i++)
|
||
{
|
||
nodein>>vert[i].No>>vert[i].vt.x>>vert[i].vt.y>>vert[i].vt.z;
|
||
vert[i].No = i;
|
||
}
|
||
finish=clock();
|
||
cout<<(double)(finish-start)/CLOCKS_PER_SEC<<" s"<<endl;
|
||
}
|
||
else
|
||
{
|
||
for(int i=0;i<vertex_sum;i++)
|
||
{
|
||
nodein>>vert[i].No>>vert[i].vt.x>>vert[i].vt.y>>vert[i].vt.z;
|
||
}
|
||
finish=clock();
|
||
cout<<(double)(finish-start)/CLOCKS_PER_SEC<<" s"<<endl;
|
||
}
|
||
nodein.close();
|
||
|
||
/*ofstream testout("testout.txt");
|
||
for(int i=0;i<vertex_sum;i++)
|
||
{
|
||
testout<<vert[i].vt.x<<" "<<vert[i].vt.y<<" "<<vert[i].vt.z<<endl;
|
||
}
|
||
testout.close();*/
|
||
return 0;
|
||
}
|
||
|
||
int Tetra_G::readele(string filename)
|
||
{
|
||
cout<<"reading "<<filename<<"... ";
|
||
start = clock();
|
||
|
||
const char* openname = filename.c_str();
|
||
ifstream elein(openname);
|
||
int vertex_num,attribute_sum,first_No;
|
||
elein>>tetra_sum>>vertex_num>>attribute_sum>>first_No;
|
||
elein.seekg(-1,ios::cur);
|
||
tet = new tetra [tetra_sum];
|
||
if(first_No==1)
|
||
{
|
||
for(int i=0;i<tetra_sum;i++)
|
||
{
|
||
tet[i].attribute = new double [attribute_sum];
|
||
}
|
||
for(int i=0;i<tetra_sum;i++)
|
||
{
|
||
elein>>tet[i].No>>tet[i].ver[0]>>tet[i].ver[1]>>tet[i].ver[2]>>tet[i].ver[3];
|
||
for(int j=0;j<attribute_sum;j++)
|
||
{
|
||
elein>>tet[i].attribute[j];
|
||
}
|
||
tet[i].No = i;
|
||
tet[i].ver[0] -= 1;
|
||
tet[i].ver[1] -= 1;
|
||
tet[i].ver[2] -= 1;
|
||
tet[i].ver[3] -= 1;
|
||
}
|
||
finish=clock();
|
||
cout<<(double)(finish-start)/CLOCKS_PER_SEC<<" s"<<endl;
|
||
}
|
||
else
|
||
{
|
||
for(int i=0;i<tetra_sum;i++)
|
||
{
|
||
tet[i].attribute = new double [attribute_sum];
|
||
}
|
||
for(int i=0;i<tetra_sum;i++)
|
||
{
|
||
elein>>tet[i].No>>tet[i].ver[0]>>tet[i].ver[1]>>tet[i].ver[2]>>tet[i].ver[3];
|
||
for(int j=0;j<attribute_sum;j++)
|
||
{
|
||
elein>>tet[i].attribute[j];
|
||
}
|
||
}
|
||
finish=clock();
|
||
cout<<(double)(finish-start)/CLOCKS_PER_SEC<<" s"<<endl;
|
||
}
|
||
elein.close();
|
||
return 0;
|
||
}
|
||
|
||
int Tetra_G::readele(string filename,double *attri)
|
||
{
|
||
cout<<"reading "<<filename<<"... ";
|
||
start = clock();
|
||
|
||
const char* openname = filename.c_str();
|
||
ifstream elein(openname);//声明模型读入文件流
|
||
int vertex_num,attribute_sum,first_No;//此处并未应用vertex_num这个值
|
||
elein>>tetra_sum>>vertex_num>>attribute_sum>>first_No;
|
||
elein.seekg(-1,ios::cur);
|
||
tet = new tetra [tetra_sum];
|
||
if(first_No==1)
|
||
{
|
||
for(int i=0;i<tetra_sum;i++)
|
||
{
|
||
tet[i].attribute = new double [1];
|
||
tet[i].attribute[0] = *(attri);
|
||
}
|
||
for(int i=0;i<tetra_sum;i++)
|
||
{
|
||
elein>>tet[i].No>>tet[i].ver[0]>>tet[i].ver[1]>>tet[i].ver[2]>>tet[i].ver[3];
|
||
tet[i].No = i;
|
||
tet[i].ver[0] -= 1;
|
||
tet[i].ver[1] -= 1;
|
||
tet[i].ver[2] -= 1;
|
||
tet[i].ver[3] -= 1;
|
||
}
|
||
finish=clock();
|
||
cout<<(double)(finish-start)/CLOCKS_PER_SEC<<" s"<<endl;
|
||
}
|
||
else
|
||
{
|
||
for(int i=0;i<tetra_sum;i++)
|
||
{
|
||
tet[i].attribute = new double [1];
|
||
tet[i].attribute[0] = *attri;
|
||
}
|
||
for(int i=0;i<tetra_sum;i++)
|
||
{
|
||
elein>>tet[i].No>>tet[i].ver[0]>>tet[i].ver[1]>>tet[i].ver[2]>>tet[i].ver[3];
|
||
}
|
||
finish=clock();
|
||
cout<<(double)(finish-start)/CLOCKS_PER_SEC<<" s"<<endl;
|
||
}
|
||
elein.close();
|
||
|
||
/*ofstream testout("testout2.txt");
|
||
for(int i=0;i<tetra_sum;i++)
|
||
{
|
||
testout<<tet[i].ver[0]<<" "<<tet[i].ver[1]<<" "<<tet[i].ver[2]<<" "<<tet[i].ver[3]<<" "<<tet[i].attribute[0]<<endl;
|
||
}
|
||
testout.close();*/
|
||
return 0;
|
||
}
|
||
|
||
int Tetra_G::readmsh(string filename,double *attri)
|
||
{
|
||
double version;
|
||
int format,precision;
|
||
int element_order,element_type;
|
||
int itemp;
|
||
int count;
|
||
string temp;
|
||
stringstream stemp;
|
||
edge E1;
|
||
edge_list EdgList;
|
||
edge_list::iterator ie;
|
||
face F1;
|
||
face_list FacList;
|
||
face_list::iterator ifac;
|
||
tetra T1;
|
||
tetra_list TetList;
|
||
tetra_list::iterator it;
|
||
cout<<"reading "<<filename<<"... ";
|
||
|
||
const char* openname = filename.c_str();
|
||
ifstream mshin(openname);
|
||
start = clock();
|
||
while (getline(mshin,temp))
|
||
{
|
||
if(temp=="$MeshFormat")//读入.msh文件版本信息，虽然对我们来说没什么用
|
||
{
|
||
getline(mshin,temp);
|
||
stemp.clear();
|
||
stemp.str(temp);
|
||
stemp>>version>>format>>precision;
|
||
}
|
||
else if(temp=="$Nodes")//读入node信息
|
||
{
|
||
getline(mshin,temp);
|
||
stemp.clear();
|
||
stemp.str(temp);
|
||
stemp>>vertex_sum;
|
||
vert = new vertex [vertex_sum];
|
||
for(int i=0;i<vertex_sum;i++)
|
||
{
|
||
getline(mshin,temp);
|
||
stemp.clear();
|
||
stemp.str(temp);
|
||
stemp>>vert[i].No>>vert[i].vt.x>>vert[i].vt.y>>vert[i].vt.z;
|
||
vert[i].No-=1;//.msh文件中点的编号是从1开始的
|
||
}
|
||
}
|
||
else if(temp=="$Elements")//读入元素信息，保存到相应的链表
|
||
{
|
||
getline(mshin,temp);
|
||
stemp.clear();
|
||
stemp.str(temp);
|
||
stemp>>element_sum;
|
||
for(int i=0;i<element_sum;i++)
|
||
{
|
||
getline(mshin,temp);
|
||
stemp.clear();
|
||
stemp.str(temp);
|
||
stemp>>element_order>>element_type;
|
||
if(element_type==4)//四面体元素
|
||
{
|
||
stemp>>itemp>>itemp>>itemp>>T1.ver[0]>>T1.ver[1]>>T1.ver[2]>>T1.ver[3];
|
||
T1.ver[0]-=1;
|
||
T1.ver[1]-=1;
|
||
T1.ver[2]-=1;
|
||
T1.ver[3]-=1;
|
||
TetList.push_back(T1);
|
||
}
|
||
else if(element_type==1)//边元素
|
||
{
|
||
stemp>>itemp>>itemp>>itemp>>E1.ver[0]>>E1.ver[1];
|
||
E1.ver[0]-=1;
|
||
E1.ver[1]-=1;
|
||
EdgList.push_back(E1);
|
||
}
|
||
else if(element_type==2)//三角形元素
|
||
{
|
||
stemp>>itemp>>itemp>>itemp>>F1.ver[0]>>F1.ver[1]>>F1.ver[2];
|
||
F1.ver[0]-=1;
|
||
F1.ver[1]-=1;
|
||
F1.ver[2]-=1;
|
||
FacList.push_back(F1);
|
||
}
|
||
else continue;
|
||
}
|
||
}
|
||
}
|
||
mshin.close();
|
||
|
||
tetra_sum = TetList.size();
|
||
edge_sum = EdgList.size();
|
||
face_sum = FacList.size();
|
||
tet = new tetra [tetra_sum];
|
||
edg = new edge [edge_sum];
|
||
fac = new face [face_sum];
|
||
count=0;
|
||
for(it=TetList.begin();it!=TetList.end();++it)
|
||
{
|
||
T1 = *it;
|
||
T1.No = count;
|
||
tet[count] = T1;
|
||
count++;
|
||
}
|
||
TetList.clear();
|
||
count=0;
|
||
for(ie=EdgList.begin();ie!=EdgList.end();++ie)
|
||
{
|
||
E1 = *ie;
|
||
E1.No = count;
|
||
edg[count] = E1;
|
||
count++;
|
||
}
|
||
EdgList.clear();
|
||
count=0;
|
||
for(ifac=FacList.begin();ifac!=FacList.end();++ifac)
|
||
{
|
||
F1 = *ifac;
|
||
F1.No = count;
|
||
fac[count] = F1;
|
||
count++;
|
||
}
|
||
FacList.clear();
|
||
|
||
for(int i=0;i<tetra_sum;i++)
|
||
{
|
||
tet[i].attribute = new double [1];
|
||
tet[i].attribute[0] = *attri;
|
||
}
|
||
finish=clock();
|
||
cout<<(double)(finish-start)/CLOCKS_PER_SEC<<" s"<<endl;
|
||
return 0;
|
||
}
|
||
|
||
int Tetra_G::field_reader(int cal_type,string filename)
|
||
{
|
||
filename+= ".fie";
|
||
if(access(filename.c_str(),F_OK)){
|
||
cout<<filename<<" not found!"<<endl;
|
||
return 1;
|
||
}
|
||
cout<<"reading "<<filename<<"... ";
|
||
start = clock();
|
||
|
||
const char* openname = filename.c_str();
|
||
ifstream fiein(openname);
|
||
fiein>>fie_sum;
|
||
fie = new point3d [fie_sum];
|
||
if(cal_type==1||cal_type==2)
|
||
{
|
||
for(int i=0;i<fie_sum;i++)
|
||
{
|
||
fiein>>fie[i].x>>fie[i].y>>fie[i].z;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
s_point = new sphere_point [fie_sum];
|
||
for(int i=0;i<fie_sum;i++)
|
||
{
|
||
fiein>>s_point[i].phi>>s_point[i].thet>>s_point[i].radius;
|
||
fie[i]=SCS2CCS(s_point[i]);
|
||
}
|
||
}
|
||
|
||
finish=clock();
|
||
cout<<(double)(finish-start)/CLOCKS_PER_SEC<<" s"<<endl;
|
||
fiein.close();
|
||
return 0;
|
||
}
|
||
|
||
int Tetra_G::manual_input(int cal_type,double *ob_info)
|
||
{
|
||
int M,N;
|
||
double _ob[7];
|
||
|
||
cout<<"calculating observing points... ";
|
||
start = clock();
|
||
|
||
for(int i=0;i<7;i++)
|
||
{
|
||
_ob[i]=*(ob_info+i);
|
||
}
|
||
N=int (_ob[5]-_ob[3])/_ob[4]+1;
|
||
M=int (_ob[2]-_ob[0])/_ob[1]+1;
|
||
_ob[2]=_ob[0]+(M-1)*_ob[1];
|
||
_ob[5]=_ob[3]+(N-1)*_ob[4];
|
||
|
||
fie_sum = M*N;
|
||
fie = new point3d [fie_sum];
|
||
if(cal_type==1||cal_type==2)
|
||
{
|
||
for(int i=0;i<fie_sum;i++)
|
||
{
|
||
fie[i].y = _ob[4]*(i%N)+_ob[3];
|
||
fie[i].x = _ob[1]*(i/N)+_ob[0];
|
||
fie[i].z = _ob[6];
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if(_ob[0]<-90||_ob[2]>90||_ob[3]<-180||_ob[5]>180||_ob[6]<=0)
|
||
{
|
||
cout<<"coordinate out of range! function fail...";
|
||
return 1;
|
||
}
|
||
s_point = new sphere_point [fie_sum];
|
||
for(int i=0;i<fie_sum;i++)
|
||
{
|
||
s_point[i].phi = _ob[4]*(i%N)+_ob[3];
|
||
s_point[i].thet = _ob[1]*(i/N)+_ob[0];
|
||
s_point[i].radius = _ob[6];
|
||
fie[i]=SCS2CCS(s_point[i]);
|
||
}
|
||
}
|
||
|
||
finish=clock();
|
||
cout<<(double)(finish-start)/CLOCKS_PER_SEC<<" s"<<endl;
|
||
|
||
/*
|
||
ofstream testout("testout.txt");
|
||
for(int i=0;i<fie_sum;i++)
|
||
{
|
||
testout<<fie[i].x<<" "<<fie[i].y<<" "<<fie[i].z<<endl;
|
||
}
|
||
testout.close();
|
||
*/
|
||
return 0;
|
||
}
|
||
/************************************************************************/
|
||
int Tetra_G::cal_tetra_info()
|
||
{
|
||
point3d refer_vertex,plane_vertex[3],nf,nor_f;
|
||
|
||
int t1,t2;
|
||
point3d v1,v2,ref1,ref2,edge12,edge21;
|
||
point3d n12,nor_n12,nA,nor_nA;
|
||
point3d n21,nor_n21,nB,nor_nB;
|
||
double nor_nAn12[3][3],nor_nBn21[3][3];
|
||
int count;
|
||
|
||
cout<<"calculating tetrahedrons' parameters... ";
|
||
start = clock();
|
||
for(int i=0;i<tetra_sum;i++)
|
||
{
|
||
for(int f=0;f<4;f++)
|
||
{
|
||
refer_vertex=vert[tet[i].ver[f]].vt;
|
||
plane_vertex[0]=vert[tet[i].ver[(f+1)%4]].vt;
|
||
plane_vertex[1]=vert[tet[i].ver[(f+2)%4]].vt;
|
||
plane_vertex[2]=vert[tet[i].ver[(f+3)%4]].vt;
|
||
|
||
if(re_order(refer_vertex,plane_vertex[0],plane_vertex[1],plane_vertex[2]))
|
||
{
|
||
tet[i].ordered_ver[f][0]=tet[i].ver[(f+1)%4];
|
||
tet[i].ordered_ver[f][1]=tet[i].ver[(f+3)%4];
|
||
tet[i].ordered_ver[f][2]=tet[i].ver[(f+2)%4];
|
||
}
|
||
else
|
||
{
|
||
tet[i].ordered_ver[f][0]=tet[i].ver[(f+1)%4];
|
||
tet[i].ordered_ver[f][1]=tet[i].ver[(f+2)%4];
|
||
tet[i].ordered_ver[f][2]=tet[i].ver[(f+3)%4];
|
||
}
|
||
|
||
nf=cross(plane_vertex[1]-plane_vertex[0],plane_vertex[2]-plane_vertex[0]);
|
||
nor_f=nor_point3d(nf);
|
||
/*
|
||
for(int h=0;h<3;h++)
|
||
{
|
||
for(int l=0;l<3;l++)
|
||
{
|
||
//tet[i].F_kron[f].kron[h][l] = *(kron_v(nor_f,nor_f)+h*3+l);
|
||
tet[i].F_kron[f].kron[h][l] = 0.1;
|
||
}
|
||
}
|
||
*/
|
||
tet[i].F_kron[f].kron[0][0]=nor_f.x*nor_f.x; tet[i].F_kron[f].kron[0][1]=nor_f.x*nor_f.y; tet[i].F_kron[f].kron[0][2]=nor_f.x*nor_f.z;
|
||
tet[i].F_kron[f].kron[1][0]=nor_f.y*nor_f.x; tet[i].F_kron[f].kron[1][1]=nor_f.y*nor_f.y; tet[i].F_kron[f].kron[1][2]=nor_f.y*nor_f.z;
|
||
tet[i].F_kron[f].kron[2][0]=nor_f.z*nor_f.x; tet[i].F_kron[f].kron[2][1]=nor_f.z*nor_f.y; tet[i].F_kron[f].kron[2][2]=nor_f.z*nor_f.z;
|
||
|
||
}
|
||
|
||
count=0;
|
||
for(int e=0;e<3;e++)
|
||
{
|
||
for(int e2=e+1;e2<4;e2++)
|
||
{
|
||
v1=vert[tet[i].ver[e]].vt;
|
||
v2=vert[tet[i].ver[e2]].vt;
|
||
find_left(t1,t2,e,e2);
|
||
ref1=vert[tet[i].ver[t1]].vt;
|
||
ref2=vert[tet[i].ver[t2]].vt;
|
||
|
||
re_order2(v1,v2,ref1,ref2);
|
||
|
||
tet[i].E_len[count] = Dis_point3d(v1,v2);
|
||
|
||
edge12 = v2-v1;
|
||
edge21 = v1-v2;
|
||
|
||
nA=cross(edge12,ref1-v1); nor_nA=nor_point3d(nA);
|
||
n12=cross(edge12,nA); nor_n12=nor_point3d(n12);
|
||
|
||
|
||
nB=cross(edge21,ref2-v2); nor_nB=nor_point3d(nB);
|
||
n21=cross(edge21,nB); nor_n21=nor_point3d(n21);
|
||
/*
|
||
for(int g=0;g<3;g++)
|
||
{
|
||
for(int j=0;j<3;j++)
|
||
{
|
||
//nor_nAn12 = *(kron_v(nor_nA,nor_n12)+g*3+j);
|
||
//nor_nBn21 = *(kron_v(nor_nB,nor_n21)+g*3+j);
|
||
//tet[i].E_kron[count].kron[g][j] = nor_nAn12 + nor_nBn21;
|
||
tet[i].E_kron[count].kron[g][j] = 0.1;
|
||
}
|
||
}
|
||
*/
|
||
nor_nAn12[0][0]=nor_nA.x*nor_n12.x; nor_nAn12[0][1]=nor_nA.x*nor_n12.y; nor_nAn12[0][2]=nor_nA.x*nor_n12.z;
|
||
nor_nAn12[1][0]=nor_nA.y*nor_n12.x; nor_nAn12[1][1]=nor_nA.y*nor_n12.y; nor_nAn12[1][2]=nor_nA.y*nor_n12.z;
|
||
nor_nAn12[2][0]=nor_nA.z*nor_n12.x; nor_nAn12[2][1]=nor_nA.z*nor_n12.y; nor_nAn12[2][2]=nor_nA.z*nor_n12.z;
|
||
|
||
nor_nBn21[0][0]=nor_nB.x*nor_n21.x; nor_nBn21[0][1]=nor_nB.x*nor_n21.y; nor_nBn21[0][2]=nor_nB.x*nor_n21.z;
|
||
nor_nBn21[1][0]=nor_nB.y*nor_n21.x; nor_nBn21[1][1]=nor_nB.y*nor_n21.y; nor_nBn21[1][2]=nor_nB.y*nor_n21.z;
|
||
nor_nBn21[2][0]=nor_nB.z*nor_n21.x; nor_nBn21[2][1]=nor_nB.z*nor_n21.y; nor_nBn21[2][2]=nor_nB.z*nor_n21.z;
|
||
|
||
for(int g=0;g<3;g++)
|
||
{
|
||
for(int j=0;j<3;j++)
|
||
{
|
||
tet[i].E_kron[count].kron[g][j] = nor_nAn12[g][j] + nor_nBn21[g][j];
|
||
}
|
||
}
|
||
|
||
count++;
|
||
}
|
||
}
|
||
}
|
||
finish=clock();
|
||
cout<<(double)(finish-start)/CLOCKS_PER_SEC<<" s"<<endl;
|
||
|
||
/*ofstream testout("testout2.txt");
|
||
for(int i=0;i<tetra_sum;i++)
|
||
{
|
||
testout<<tet[i].ver[0]<<" "<<tet[i].ver[1]<<" "<<tet[i].ver[2]<<" "<<tet[i].ver[3]<<" "<<tet[i].attribute[0]<<endl;
|
||
for(int j=0;j<6;j++)
|
||
{
|
||
testout<<tet[i].E_len[j]<<" ";
|
||
}testout<<endl;
|
||
for(int m=0;m<4;m++)
|
||
{
|
||
for(int p=0;p<3;p++)
|
||
{
|
||
for(int q=0;q<3;q++)
|
||
{
|
||
testout<<tet[i].F_kron[m].kron[p][q]<<" ";
|
||
}
|
||
testout<<endl;
|
||
}
|
||
testout<<endl;
|
||
}
|
||
testout<<"**********************************"<<endl;
|
||
|
||
for(int m=0;m<6;m++)
|
||
{
|
||
for(int p=0;p<3;p++)
|
||
{
|
||
for(int q=0;q<3;q++)
|
||
{
|
||
testout<<tet[i].E_kron[m].kron[p][q]<<" ";
|
||
}
|
||
testout<<endl;
|
||
}
|
||
testout<<endl;
|
||
}
|
||
}
|
||
testout.close();*/
|
||
return 0;
|
||
}
|
||
/************************************************************************/
|
||
double Tetra_G::cal_tetra_gc(point3d ob_posi)
|
||
{
|
||
int count;
|
||
double cal_data;
|
||
double Le,wf,face_sum,edge_sum;
|
||
double Dv1,Dv2;
|
||
point3d re;
|
||
point3d r_ijk[3];
|
||
double L_ijk[3];
|
||
|
||
cal_data=0;
|
||
for(int i=0;i<tetra_sum;i++)
|
||
{
|
||
if(tet[i].attribute[0]==0.0) cal_data += 0.0;
|
||
else
|
||
{
|
||
face_sum=0;
|
||
for(int f=0;f<4;f++)
|
||
{
|
||
r_ijk[0]=vert[tet[i].ordered_ver[f][0]].vt - ob_posi;
|
||
r_ijk[1]=vert[tet[i].ordered_ver[f][1]].vt - ob_posi;
|
||
r_ijk[2]=vert[tet[i].ordered_ver[f][2]].vt - ob_posi;
|
||
|
||
L_ijk[0]=L_point3d(r_ijk[0]);
|
||
L_ijk[1]=L_point3d(r_ijk[1]);
|
||
L_ijk[2]=L_point3d(r_ijk[2]);
|
||
|
||
wf =2*atan2(dot(r_ijk[0],cross(r_ijk[1],r_ijk[2])),
|
||
L_ijk[0]*L_ijk[1]*L_ijk[2]+L_ijk[0]*dot(r_ijk[1],r_ijk[2])+L_ijk[1]*dot(r_ijk[2],r_ijk[0])+L_ijk[2]*dot(r_ijk[0],r_ijk[1]));
|
||
|
||
face_sum+= (tet[i].F_kron[f].kron[2][0]*r_ijk[0].x+tet[i].F_kron[f].kron[2][1]*r_ijk[0].y+tet[i].F_kron[f].kron[2][2]*r_ijk[0].z)*wf;
|
||
}
|
||
|
||
edge_sum=0;
|
||
count=0;
|
||
for(int e=0;e<3;e++)
|
||
{
|
||
for(int e2=e+1;e2<4;e2++)
|
||
{
|
||
Dv1=Dis_point3d(vert[tet[i].ver[e]].vt,ob_posi);
|
||
Dv2=Dis_point3d(vert[tet[i].ver[e2]].vt,ob_posi);
|
||
|
||
re=vert[tet[i].ver[e]].vt-ob_posi;
|
||
|
||
Le=log((Dv1+Dv2+tet[i].E_len[count])/(Dv1+Dv2-tet[i].E_len[count]));
|
||
|
||
edge_sum+= (tet[i].E_kron[count].kron[2][0]*re.x+tet[i].E_kron[count].kron[2][1]*re.y+tet[i].E_kron[count].kron[2][2]*re.z)*Le;
|
||
|
||
count++;
|
||
}
|
||
}
|
||
|
||
cal_data += G0*tet[i].attribute[0]*(face_sum-edge_sum);
|
||
}
|
||
}
|
||
return cal_data;
|
||
}
|
||
|
||
int Tetra_G::cal_tetra_ggc(point3d ob_posi,double& temp_data,double& temp_data2,double& temp_data3)
|
||
{
|
||
int count;
|
||
double cal_data[3];
|
||
double Le,wf,face_sum[3],edge_sum[3];
|
||
double Dv1,Dv2;
|
||
point3d re;
|
||
point3d r_ijk[3];
|
||
double L_ijk[3];
|
||
|
||
cal_data[0]=0;
|
||
cal_data[1]=0;
|
||
cal_data[2]=0;
|
||
for(int i=0;i<tetra_sum;i++)
|
||
{
|
||
if(tet[i].attribute[0]==0.0){
|
||
cal_data[0] += 0.0;
|
||
cal_data[1] += 0.0;
|
||
cal_data[2] += 0.0;
|
||
}
|
||
else
|
||
{
|
||
face_sum[0]=0;
|
||
face_sum[1]=0;
|
||
face_sum[2]=0;
|
||
for(int f=0;f<4;f++)
|
||
{
|
||
r_ijk[0]=vert[tet[i].ordered_ver[f][0]].vt - ob_posi;
|
||
r_ijk[1]=vert[tet[i].ordered_ver[f][1]].vt - ob_posi;
|
||
r_ijk[2]=vert[tet[i].ordered_ver[f][2]].vt - ob_posi;
|
||
|
||
L_ijk[0]=L_point3d(r_ijk[0]);
|
||
L_ijk[1]=L_point3d(r_ijk[1]);
|
||
L_ijk[2]=L_point3d(r_ijk[2]);
|
||
|
||
wf =2*atan2(dot(r_ijk[0],cross(r_ijk[1],r_ijk[2])),
|
||
L_ijk[0]*L_ijk[1]*L_ijk[2]+L_ijk[0]*dot(r_ijk[1],r_ijk[2])+L_ijk[1]*dot(r_ijk[2],r_ijk[0])+L_ijk[2]*dot(r_ijk[0],r_ijk[1]));
|
||
|
||
face_sum[0]+=tet[i].F_kron[f].kron[2][0]*wf;
|
||
face_sum[1]+=tet[i].F_kron[f].kron[2][1]*wf;
|
||
face_sum[2]+=tet[i].F_kron[f].kron[2][2]*wf;
|
||
}
|
||
|
||
edge_sum[0]=0;
|
||
edge_sum[1]=0;
|
||
edge_sum[2]=0;
|
||
count=0;
|
||
for(int e=0;e<3;e++)
|
||
{
|
||
for(int e2=e+1;e2<4;e2++)
|
||
{
|
||
Dv1=Dis_point3d(vert[tet[i].ver[e]].vt,ob_posi);
|
||
Dv2=Dis_point3d(vert[tet[i].ver[e2]].vt,ob_posi);
|
||
|
||
re=vert[tet[i].ver[e]].vt-ob_posi;
|
||
|
||
Le=log((Dv1+Dv2+tet[i].E_len[count])/(Dv1+Dv2-tet[i].E_len[count]));
|
||
|
||
edge_sum[0]+=tet[i].E_kron[count].kron[2][0]*Le;
|
||
edge_sum[1]+=tet[i].E_kron[count].kron[2][1]*Le;
|
||
edge_sum[2]+=tet[i].E_kron[count].kron[2][2]*Le;
|
||
|
||
count++;
|
||
}
|
||
}
|
||
|
||
cal_data[0] += 1e+4*G0*tet[i].attribute[0]*(edge_sum[0]-face_sum[0]);
|
||
cal_data[1] += 1e+4*G0*tet[i].attribute[0]*(edge_sum[1]-face_sum[1]);
|
||
cal_data[2] += 1e+4*G0*tet[i].attribute[0]*(edge_sum[2]-face_sum[2]);
|
||
}
|
||
}
|
||
temp_data=cal_data[0];
|
||
temp_data2=cal_data[1];
|
||
temp_data3=cal_data[2];
|
||
return 0;
|
||
}
|
||
|
||
double Tetra_G::cal_tetra_gs(point3d ob_posi,sphere_point ob_posi_s)
|
||
{
|
||
int count;
|
||
double cal_data;
|
||
double Le,wf,face_sum,edge_sum;
|
||
double Dv1,Dv2;
|
||
point3d re;
|
||
point3d r_ijk[3];
|
||
double L_ijk[3];
|
||
|
||
cal_data=0;
|
||
for(int i=0;i<tetra_sum;i++)
|
||
{
|
||
if(tet[i].attribute[0]==0.0) cal_data += 0.0;
|
||
else
|
||
{
|
||
face_sum=0;
|
||
for(int f=0;f<4;f++)
|
||
{
|
||
r_ijk[0]=vert[tet[i].ordered_ver[f][0]].vt - ob_posi;
|
||
r_ijk[1]=vert[tet[i].ordered_ver[f][1]].vt - ob_posi;
|
||
r_ijk[2]=vert[tet[i].ordered_ver[f][2]].vt - ob_posi;
|
||
|
||
L_ijk[0]=L_point3d(r_ijk[0]);
|
||
L_ijk[1]=L_point3d(r_ijk[1]);
|
||
L_ijk[2]=L_point3d(r_ijk[2]);
|
||
|
||
wf =2*atan2(dot(r_ijk[0],cross(r_ijk[1],r_ijk[2])),
|
||
L_ijk[0]*L_ijk[1]*L_ijk[2]+L_ijk[0]*dot(r_ijk[1],r_ijk[2])+L_ijk[1]*dot(r_ijk[2],r_ijk[0])+L_ijk[2]*dot(r_ijk[0],r_ijk[1]));
|
||
|
||
face_sum+= (martix_point3d(r_ijk[0],tet[i].F_kron[f].kron[0]).x*sin((0.5-ob_posi_s.thet/180)*pi)*cos((2+ob_posi_s.phi/180)*pi)+
|
||
martix_point3d(r_ijk[0],tet[i].F_kron[f].kron[0]).y*sin((0.5-ob_posi_s.thet/180)*pi)*sin((2+ob_posi_s.phi/180)*pi)+
|
||
martix_point3d(r_ijk[0],tet[i].F_kron[f].kron[0]).z*cos((0.5-ob_posi_s.thet/180)*pi))*wf;
|
||
}
|
||
|
||
edge_sum=0;
|
||
count=0;
|
||
for(int e=0;e<3;e++)
|
||
{
|
||
for(int e2=e+1;e2<4;e2++)
|
||
{
|
||
Dv1=Dis_point3d(vert[tet[i].ver[e]].vt,ob_posi);
|
||
Dv2=Dis_point3d(vert[tet[i].ver[e2]].vt,ob_posi);
|
||
|
||
re=vert[tet[i].ver[e]].vt-ob_posi;
|
||
|
||
Le=log((Dv1+Dv2+tet[i].E_len[count])/(Dv1+Dv2-tet[i].E_len[count]));
|
||
|
||
edge_sum+= (martix_point3d(re,tet[i].E_kron[count].kron[0]).x*sin((0.5-ob_posi_s.thet/180)*pi)*cos((2+ob_posi_s.phi/180)*pi)+
|
||
martix_point3d(re,tet[i].E_kron[count].kron[0]).y*sin((0.5-ob_posi_s.thet/180)*pi)*sin((2+ob_posi_s.phi/180)*pi)+
|
||
martix_point3d(re,tet[i].E_kron[count].kron[0]).z*cos((0.5-ob_posi_s.thet/180)*pi))*Le;
|
||
|
||
|
||
count++;
|
||
}
|
||
}
|
||
|
||
cal_data += G0*tet[i].attribute[0]*(edge_sum-face_sum);
|
||
}
|
||
}
|
||
return cal_data;
|
||
}
|
||
|
||
int Tetra_G::cal_tetra_ggs(point3d ob_posi,sphere_point ob_posi_s,double& temp_data,double& temp_data2,double& temp_data3)
|
||
{
|
||
int count;
|
||
double* face_temp;
|
||
double* edge_temp;
|
||
double R[3][3];
|
||
double cal_data[3];
|
||
double Le,wf,face_sum[3],edge_sum[3];
|
||
double Dv1,Dv2;
|
||
point3d re;
|
||
point3d r_ijk[3];
|
||
double L_ijk[3];
|
||
|
||
R[0][0] = sin((0.5-ob_posi_s.thet/180)*pi)*cos((2+ob_posi_s.phi/180)*pi); R[0][1] = sin((0.5-ob_posi_s.thet/180)*pi)*sin((2+ob_posi_s.phi/180)*pi); R[0][2] = cos((0.5-ob_posi_s.thet/180)*pi);
|
||
R[1][0] = cos((0.5-ob_posi_s.thet/180)*pi)*cos((2+ob_posi_s.phi/180)*pi); R[1][1] = cos((0.5-ob_posi_s.thet/180)*pi)*sin((2+ob_posi_s.phi/180)*pi); R[1][2] = -1*sin((0.5-ob_posi_s.thet/180)*pi);
|
||
R[2][0] = -1*sin((2+ob_posi_s.phi/180)*pi); R[2][1] = cos((2+ob_posi_s.phi/180)*pi); R[2][2] = 0;
|
||
|
||
cal_data[0]=0;
|
||
cal_data[1]=0;
|
||
cal_data[2]=0;
|
||
for(int i=0;i<tetra_sum;i++)
|
||
{
|
||
if(tet[i].attribute[0]==0.0){
|
||
cal_data[0] += 0.0;
|
||
cal_data[1] += 0.0;
|
||
cal_data[2] += 0.0;
|
||
}
|
||
else
|
||
{
|
||
face_sum[0]=0;
|
||
face_sum[1]=0;
|
||
face_sum[2]=0;
|
||
for(int f=0;f<4;f++)
|
||
{
|
||
r_ijk[0]=vert[tet[i].ordered_ver[f][0]].vt - ob_posi;
|
||
r_ijk[1]=vert[tet[i].ordered_ver[f][1]].vt - ob_posi;
|
||
r_ijk[2]=vert[tet[i].ordered_ver[f][2]].vt - ob_posi;
|
||
|
||
L_ijk[0]=L_point3d(r_ijk[0]);
|
||
L_ijk[1]=L_point3d(r_ijk[1]);
|
||
L_ijk[2]=L_point3d(r_ijk[2]);
|
||
|
||
wf =2*atan2(dot(r_ijk[0],cross(r_ijk[1],r_ijk[2])),
|
||
L_ijk[0]*L_ijk[1]*L_ijk[2]+L_ijk[0]*dot(r_ijk[1],r_ijk[2])+L_ijk[1]*dot(r_ijk[2],r_ijk[0])+L_ijk[2]*dot(r_ijk[0],r_ijk[1]));
|
||
|
||
face_temp = martix_martix(martix_martix(R[0],tet[i].F_kron[f].kron[0]),martix_T(R[0]));
|
||
face_sum[0]+= *(face_temp) * wf;
|
||
face_sum[1]+= *(face_temp+1) * wf;
|
||
face_sum[2]+= *(face_temp+2) * wf;
|
||
}
|
||
|
||
edge_sum[0]=0;
|
||
edge_sum[1]=0;
|
||
edge_sum[2]=0;
|
||
count=0;
|
||
for(int e=0;e<3;e++)
|
||
{
|
||
for(int e2=e+1;e2<4;e2++)
|
||
{
|
||
Dv1=Dis_point3d(vert[tet[i].ver[e]].vt,ob_posi);
|
||
Dv2=Dis_point3d(vert[tet[i].ver[e2]].vt,ob_posi);
|
||
|
||
re=vert[tet[i].ver[e]].vt-ob_posi;
|
||
|
||
Le=log((Dv1+Dv2+tet[i].E_len[count])/(Dv1+Dv2-tet[i].E_len[count]));
|
||
|
||
edge_temp = martix_martix(martix_martix(R[0],tet[i].E_kron[count].kron[0]),martix_T(R[0]));
|
||
edge_sum[0]+= *(edge_temp) * Le;
|
||
edge_sum[1]+= *(edge_temp+1) * Le;
|
||
edge_sum[2]+= *(edge_temp+2) * Le;
|
||
|
||
count++;
|
||
}
|
||
}
|
||
|
||
cal_data[0] += 1e+4*G0*tet[i].attribute[0]*(edge_sum[0]-face_sum[0]);
|
||
cal_data[1] += 1e+4*G0*tet[i].attribute[0]*(edge_sum[1]-face_sum[1]);
|
||
cal_data[2] += 1e+4*G0*tet[i].attribute[0]*(edge_sum[2]-face_sum[2]);
|
||
}
|
||
}
|
||
temp_data=cal_data[0];
|
||
temp_data2=cal_data[1];
|
||
temp_data3=cal_data[2];
|
||
return 0;
|
||
}
|
||
/************************************************************************/
|
||
int Tetra_G::cal_total_g(int cal_type,string filename)
|
||
{
|
||
int i;
|
||
cout<<"calculating gravity or magnetic filed, expected time-consuming: "<<once_time*tetra_sum*fie_sum<<" s...";
|
||
start = clock();
|
||
if(cal_type==1)
|
||
{
|
||
res_reg Res(fie_sum);
|
||
_Obdata = new double [fie_sum];
|
||
#pragma omp parallel for private(i) schedule(runtime)//对四面体网络在不同测点的计算值执行并行计算
|
||
for(i=0;i<fie_sum;i++)
|
||
{
|
||
_Obdata[i]=cal_tetra_gc(fie[i]);
|
||
}
|
||
|
||
finish=clock();
|
||
cout<<"done! "<<(double)(finish-start)/CLOCKS_PER_SEC<<" s"<<endl;
|
||
Res.res_add(_Obdata,fie_sum);
|
||
if(Res.check(fie_sum))
|
||
{
|
||
system("pause");
|
||
exit(0);
|
||
}
|
||
if(Res.savedat(filename,fie_sum,fie))
|
||
{
|
||
system("pause");
|
||
exit(0);
|
||
}
|
||
}
|
||
else if(cal_type==2)
|
||
{
|
||
res_reg Res(fie_sum);
|
||
res_reg Res2(fie_sum);
|
||
res_reg Res3(fie_sum);
|
||
_Obdata = new double [fie_sum];
|
||
_Obdata2 = new double [fie_sum];
|
||
_Obdata3 = new double [fie_sum];
|
||
#pragma omp parallel for private(i) schedule(runtime)//对四面体网络在不同测点的计算值执行并行计算
|
||
for(i=0;i<fie_sum;i++)
|
||
{
|
||
cal_tetra_ggc(fie[i],_Obdata[i],_Obdata2[i],_Obdata3[i]);
|
||
}
|
||
|
||
finish=clock();
|
||
cout<<"done! "<<(double)(finish-start)/CLOCKS_PER_SEC<<" s"<<endl;
|
||
Res.res_add(_Obdata,fie_sum);
|
||
Res2.res_add(_Obdata2,fie_sum);
|
||
Res3.res_add(_Obdata3,fie_sum);
|
||
if(Res.check(fie_sum)||Res2.check(fie_sum)||Res3.check(fie_sum))
|
||
{
|
||
system("pause");
|
||
exit(0);
|
||
}
|
||
if(Res.savedat(filename + "_gx",fie_sum,fie)||Res2.savedat(filename + "_gy",fie_sum,fie)||Res3.savedat(filename + "_gz",fie_sum,fie))
|
||
{
|
||
system("pause");
|
||
exit(0);
|
||
}
|
||
}
|
||
else if(cal_type==3)
|
||
{
|
||
res_reg Res(fie_sum);
|
||
_Obdata = new double [fie_sum];
|
||
#pragma omp parallel for private(i) schedule(runtime)//对四面体网络在不同测点的计算值执行并行计算
|
||
for(i=0;i<fie_sum;i++)
|
||
{
|
||
_Obdata[i]=cal_tetra_gs(fie[i],s_point[i]);
|
||
}
|
||
|
||
finish=clock();
|
||
cout<<"done! "<<(double)(finish-start)/CLOCKS_PER_SEC<<" s"<<endl;
|
||
Res.res_add(_Obdata,fie_sum);
|
||
if(Res.check(fie_sum))
|
||
{
|
||
system("pause");
|
||
exit(0);
|
||
}
|
||
if(Res.savedat(filename,fie_sum,s_point))
|
||
{
|
||
system("pause");
|
||
exit(0);
|
||
}
|
||
}
|
||
else if(cal_type==4)
|
||
{
|
||
res_reg Res(fie_sum);
|
||
res_reg Res2(fie_sum);
|
||
res_reg Res3(fie_sum);
|
||
_Obdata = new double [fie_sum];
|
||
_Obdata2 = new double [fie_sum];
|
||
_Obdata3 = new double [fie_sum];
|
||
#pragma omp parallel for private(i) schedule(runtime)//对四面体网络在不同测点的计算值执行并行计算
|
||
for(i=0;i<fie_sum;i++)
|
||
{
|
||
cal_tetra_ggs(fie[i],s_point[i],_Obdata[i],_Obdata2[i],_Obdata3[i]);
|
||
}
|
||
|
||
finish=clock();
|
||
cout<<"done! "<<(double)(finish-start)/CLOCKS_PER_SEC<<" s"<<endl;
|
||
Res.res_add(_Obdata,fie_sum);
|
||
Res2.res_add(_Obdata2,fie_sum);
|
||
Res3.res_add(_Obdata3,fie_sum);
|
||
if(Res.check(fie_sum)||Res2.check(fie_sum)||Res3.check(fie_sum))
|
||
{
|
||
system("pause");
|
||
exit(0);
|
||
}
|
||
if(Res.savedat(filename + "_gr",fie_sum,s_point)||Res2.savedat(filename + "_gthet",fie_sum,s_point)||Res3.savedat(filename + "_gphi",fie_sum,s_point))
|
||
{
|
||
system("pause");
|
||
exit(0);
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
#endif |