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

tmp update

Browse Source
This commit is contained in:
张壹 2025-01-13 14:32:02 +08:00
parent 8844f191e7
commit e67ec1a28d
6 changed files with 168 additions and 219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

131
lib/potential/gm_regular_grid.cpp
View File

@ -44,9 +44,9 @@ gctl::gm_regular_grid::gm_regular_grid(std::string in_name, std::string in_info,
void gctl::gm_regular_grid::gradient(std::string datname, std::string gradname, gravitational_field_type_e c_type, int order)
{
meshdata *data_ptr = get_data(datname);
mesh_data_value_e value_type = data_ptr->get_valtype();
mesh_data_type_e data_type = data_ptr->get_dattype();
meshdata &data = get_data(datname);
mesh_data_value_e value_type = data.valtype_;
mesh_data_type_e data_type = data.loctype_;
if(value_type != Scalar)
{
@ -59,16 +59,13 @@ void gctl::gm_regular_grid::gradient(std::string datname, std::string gradname,
}
// 检查是否存在与梯度数据同名的数据 若有则检查是否需要重新建立数据
meshdata *new_data_ptr = add_data(gradname, data_type, true, value_type);
array<double> *inval_ptr = (array<double>*) data_ptr->get_datval_ptr();
array<double> *outval_ptr = (array<double>*) new_data_ptr->get_datval_ptr();
meshdata &new_data = add_data(data_type, value_type, gradname, 0.0);
gctl::array<double> ingrid_ex;
int M = -1, N = -1;
int ori_row, ori_col;
if (data_type == NodeData) gctl::cosine_extrapolate_2d(*inval_ptr, ingrid_ex, rg_ynum, rg_xnum, M, N, ori_row, ori_col);
else gctl::cosine_extrapolate_2d(*inval_ptr, ingrid_ex, rg_ynum-1, rg_xnum-1, M, N, ori_row, ori_col);
if (data_type == NodeData) gctl::cosine_extrapolate_2d(data.datval_, ingrid_ex, rg_ynum, rg_xnum, M, N, ori_row, ori_col);
else gctl::cosine_extrapolate_2d(data.datval_, ingrid_ex, rg_ynum-1, rg_xnum-1, M, N, ori_row, ori_col);
fftw_complex *in = (fftw_complex*) fftw_malloc(sizeof(fftw_complex)*M*N);
fftw_complex *out= (fftw_complex*) fftw_malloc(sizeof(fftw_complex)*M*N);
@ -173,7 +170,7 @@ void gctl::gm_regular_grid::gradient(std::string datname, std::string gradname,
{
for (int j = 0; j < rg_xnum; j++)
{
outval_ptr->at(i*rg_xnum+j) = ingrid_ex[(i+ori_row)*N+j+ori_col];
new_data.datval_[i*rg_xnum+j] = ingrid_ex[(i+ori_row)*N+j+ori_col];
}
}
}
@ -183,7 +180,7 @@ void gctl::gm_regular_grid::gradient(std::string datname, std::string gradname,
{
for (int j = 0; j < rg_xnum-1; j++)
{
outval_ptr->at(i*(rg_xnum-1)+j) = ingrid_ex[(i+ori_row)*N+j+ori_col];
new_data.datval_[i*(rg_xnum-1)+j] = ingrid_ex[(i+ori_row)*N+j+ori_col];
}
}
}
@ -196,9 +193,9 @@ void gctl::gm_regular_grid::gradient(std::string datname, std::string gradname,
void gctl::gm_regular_grid::rtp(std::string datname, std::string rtpname, double inc, double dec)
{
meshdata *data_ptr = get_data(datname);
mesh_data_value_e value_type = data_ptr->get_valtype();
mesh_data_type_e data_type = data_ptr->get_dattype();
meshdata &data = get_data(datname);
mesh_data_value_e value_type = data.valtype_;
mesh_data_type_e data_type = data.loctype_;
if(value_type != Scalar)
{
@ -207,16 +204,13 @@ void gctl::gm_regular_grid::rtp(std::string datname, std::string rtpname, double
}
// 检查是否存在与梯度数据同名的数据 若有则检查是否需要重新建立数据
meshdata *new_data_ptr = add_data(rtpname, data_type, true, value_type);
array<double> *inval_ptr = (array<double>*) data_ptr->get_datval_ptr();
array<double> *outval_ptr = (array<double>*) new_data_ptr->get_datval_ptr();
meshdata &new_data = add_data(data_type, value_type, rtpname, 0.0);
gctl::array<double> ingrid_ex;
int M = -1, N = -1;
int ori_row, ori_col;
if (data_type == NodeData) gctl::cosine_extrapolate_2d(*inval_ptr, ingrid_ex, rg_ynum, rg_xnum, M, N, ori_row, ori_col);
else gctl::cosine_extrapolate_2d(*inval_ptr, ingrid_ex, rg_ynum-1, rg_xnum-1, M, N, ori_row, ori_col);
if (data_type == NodeData) gctl::cosine_extrapolate_2d(data.datval_, ingrid_ex, rg_ynum, rg_xnum, M, N, ori_row, ori_col);
else gctl::cosine_extrapolate_2d(data.datval_, ingrid_ex, rg_ynum-1, rg_xnum-1, M, N, ori_row, ori_col);
fftw_complex *in = (fftw_complex*) fftw_malloc(sizeof(fftw_complex)*M*N);
fftw_complex *out= (fftw_complex*) fftw_malloc(sizeof(fftw_complex)*M*N);
@ -312,7 +306,7 @@ void gctl::gm_regular_grid::rtp(std::string datname, std::string rtpname, double
{
for (int j = 0; j < rg_xnum; j++)
{
outval_ptr->at(i*rg_xnum+j) = ingrid_ex[(i+ori_row)*N+j+ori_col];
new_data.datval_[i*rg_xnum+j] = ingrid_ex[(i+ori_row)*N+j+ori_col];
}
}
}
@ -322,7 +316,7 @@ void gctl::gm_regular_grid::rtp(std::string datname, std::string rtpname, double
{
for (int j = 0; j < rg_xnum-1; j++)
{
outval_ptr->at(i*(rg_xnum-1)+j) = ingrid_ex[(i+ori_row)*N+j+ori_col];
new_data.datval_[i*(rg_xnum-1)+j] = ingrid_ex[(i+ori_row)*N+j+ori_col];
}
}
}
@ -337,17 +331,17 @@ void gctl::gm_regular_grid::drtp(std::string datname, std::string incname,
std::string decname, std::string drtpname, int order)
{
// 首先获取数据并确定所有数据类型和格式都是一致的
meshdata *md_ptr = get_data(datname);
mesh_data_value_e dat_valtype = md_ptr->get_valtype();
mesh_data_type_e dat_datype = md_ptr->get_dattype();
meshdata *md_ptr = get_data_ptr(datname);
mesh_data_value_e dat_valtype = md_ptr->valtype_;
mesh_data_type_e dat_datype = md_ptr->loctype_;
md_ptr = get_data(incname);
mesh_data_value_e inc_valtype = md_ptr->get_valtype();
mesh_data_type_e inc_datype = md_ptr->get_dattype();
md_ptr = get_data_ptr(incname);
mesh_data_value_e inc_valtype = md_ptr->valtype_;
mesh_data_type_e inc_datype = md_ptr->loctype_;
md_ptr = get_data(decname);
mesh_data_value_e dec_valtype = md_ptr->get_valtype();
mesh_data_type_e dec_datype = md_ptr->get_dattype();
md_ptr = get_data_ptr(decname);
mesh_data_value_e dec_valtype = md_ptr->valtype_;
mesh_data_type_e dec_datype = md_ptr->loctype_;
std::string err_str;
if (dat_valtype != Scalar)
@ -363,32 +357,35 @@ void gctl::gm_regular_grid::drtp(std::string datname, std::string incname,
}
// 获取数据指针
md_ptr = get_data(datname);
array<double> *dat_ptr = (array<double>*) md_ptr->get_datval_ptr();
md_ptr = get_data_ptr(datname);
array<double> *dat_ptr = &md_ptr->datval_;
md_ptr = get_data(incname);
array<double> *inc_ptr = (array<double>*) md_ptr->get_datval_ptr();
md_ptr = get_data_ptr(incname);
array<double> *inc_ptr = &md_ptr->datval_;
md_ptr = get_data(decname);
array<double> *dec_ptr = (array<double>*) md_ptr->get_datval_ptr();
md_ptr = get_data_ptr(decname);
array<double> *dec_ptr = &md_ptr->datval_;
// 检查是否存在同名的数据 若有则检查是否需要重新建立数据
md_ptr = add_data(drtpname, dat_datype, true, dat_valtype);
add_data(dat_datype, dat_valtype, drtpname, 0.0);
md_ptr = get_data_ptr(drtpname);
// 获取数据指针
array<double> *drtp_ptr = (array<double>*) md_ptr->get_datval_ptr();
array<double> *drtp_ptr = &md_ptr->datval_;
// 新建临时数据并获取数据指针
std::string tmp_name = drtpname+"tmp";
md_ptr = add_data(tmp_name, dat_datype, true, dat_valtype);
array<double> *tmp_ptr = (array<double>*) md_ptr->get_datval_ptr();
add_data(dat_datype, dat_valtype, tmp_name, 0.0);
md_ptr = get_data_ptr(tmp_name);
array<double> *tmp_ptr = &md_ptr->datval_;
std::string diff1_name = drtpname+"diff1";
md_ptr = add_data(diff1_name, dat_datype, true, dat_valtype);
array<double> *diff1_ptr = (array<double>*) md_ptr->get_datval_ptr();
add_data(dat_datype, dat_valtype, diff1_name, 0.0);
md_ptr = get_data_ptr(diff1_name);
array<double> *diff1_ptr = &md_ptr->datval_;
std::string diff2_name = drtpname+"diff2";
md_ptr = add_data(diff2_name, dat_datype, true, dat_valtype);
array<double> *diff2_ptr = (array<double>*) md_ptr->get_datval_ptr();
add_data(dat_datype, dat_valtype, diff2_name, 0.0);
array<double> *diff2_ptr = &md_ptr->datval_;
// 计算平均磁化参数
double meaninc = 0.0, meandec = 0.0;
@ -461,9 +458,9 @@ void gctl::gm_regular_grid::drtp(std::string datname, std::string incname,
void gctl::gm_regular_grid::conti(std::string datname, std::string retname, double height)
{
meshdata *data_ptr = get_data(datname);
mesh_data_value_e value_type = data_ptr->get_valtype();
mesh_data_type_e data_type = data_ptr->get_dattype();
meshdata &data = get_data(datname);
mesh_data_value_e value_type = data.valtype_;
mesh_data_type_e data_type = data.loctype_;
if(value_type != Scalar)
{
@ -471,16 +468,13 @@ void gctl::gm_regular_grid::conti(std::string datname, std::string retname, doub
}
// 检查是否存在与梯度数据同名的数据 若有则检查是否需要重新建立数据
meshdata *new_data_ptr = add_data(retname, data_type, true, value_type);
array<double> *inval_ptr = (array<double>*) data_ptr->get_datval_ptr();
array<double> *outval_ptr = (array<double>*) new_data_ptr->get_datval_ptr();
meshdata &new_data = add_data(data_type, value_type, retname, 0.0);
gctl::array<double> ingrid_ex;
int M = -1, N = -1;
int ori_row, ori_col;
if (data_type == NodeData) gctl::cosine_extrapolate_2d(*inval_ptr, ingrid_ex, rg_ynum, rg_xnum, M, N, ori_row, ori_col);
else gctl::cosine_extrapolate_2d(*inval_ptr, ingrid_ex, rg_ynum-1, rg_xnum-1, M, N, ori_row, ori_col);
if (data_type == NodeData) gctl::cosine_extrapolate_2d(data.datval_, ingrid_ex, rg_ynum, rg_xnum, M, N, ori_row, ori_col);
else gctl::cosine_extrapolate_2d(data.datval_, ingrid_ex, rg_ynum-1, rg_xnum-1, M, N, ori_row, ori_col);
fftw_complex *in = (fftw_complex*) fftw_malloc(sizeof(fftw_complex)*M*N);
fftw_complex *out= (fftw_complex*) fftw_malloc(sizeof(fftw_complex)*M*N);
@ -544,7 +538,7 @@ void gctl::gm_regular_grid::conti(std::string datname, std::string retname, doub
{
for (int j = 0; j < rg_xnum; j++)
{
outval_ptr->at(i*rg_xnum+j) = ingrid_ex[(i+ori_row)*N+j+ori_col];
new_data.datval_[i*rg_xnum+j] = ingrid_ex[(i+ori_row)*N+j+ori_col];
}
}
}
@ -554,7 +548,7 @@ void gctl::gm_regular_grid::conti(std::string datname, std::string retname, doub
{
for (int j = 0; j < rg_xnum-1; j++)
{
outval_ptr->at(i*(rg_xnum-1)+j) = ingrid_ex[(i+ori_row)*N+j+ori_col];
new_data.datval_[i*(rg_xnum-1)+j] = ingrid_ex[(i+ori_row)*N+j+ori_col];
}
}
}
@ -569,9 +563,9 @@ void gctl::gm_regular_grid::conti(std::string datname, std::string retname, doub
void gctl::gm_regular_grid::trend(std::string datname, std::string regname, std::string resname, int wx_size, int wy_size, int x_order, int y_order)
{
meshdata *data_ptr = get_data(datname);
mesh_data_value_e value_type = data_ptr->get_valtype();
mesh_data_type_e data_type = data_ptr->get_dattype();
meshdata &data = get_data(datname);
mesh_data_value_e value_type = data.valtype_;
mesh_data_type_e data_type = data.loctype_;
if(value_type != Scalar)
{
@ -579,11 +573,8 @@ void gctl::gm_regular_grid::trend(std::string datname, std::string regname, std:
}
// 检查是否存在与趋势场局部场数据同名的数据 若有则检查是否需要重新建立数据
meshdata *reg_data_ptr = add_data(regname, data_type, true, value_type);
meshdata *res_data_ptr = add_data(resname, data_type, true, value_type);
array<double> *inval_ptr = (array<double>*) data_ptr->get_datval_ptr();
array<double> *regval_ptr = (array<double>*) reg_data_ptr->get_datval_ptr();
array<double> *resval_ptr = (array<double>*) res_data_ptr->get_datval_ptr();
meshdata &reg_data = add_data(data_type, value_type, regname, 0.0);
meshdata &res_data = add_data(data_type, value_type, resname, 0.0);
matrix<double> data_mat;
if (data_type == NodeData)
@ -593,7 +584,7 @@ void gctl::gm_regular_grid::trend(std::string datname, std::string regname, std:
{
for (size_t j = 0; j < rg_xnum; j++)
{
data_mat[i][j] = inval_ptr->at(i*rg_xnum+j);
data_mat[i][j] = data.datval_[i*rg_xnum+j];
}
}
}
@ -604,7 +595,7 @@ void gctl::gm_regular_grid::trend(std::string datname, std::string regname, std:
{
for (size_t j = 0; j < rg_xnum-1; j++)
{
data_mat[i][j] = inval_ptr->at(i*(rg_xnum-1)+j);
data_mat[i][j] = data.datval_[i*(rg_xnum-1)+j];
}
}
}
@ -617,8 +608,8 @@ void gctl::gm_regular_grid::trend(std::string datname, std::string regname, std:
{
for (size_t j = 0; j < rg_xnum; j++)
{
regval_ptr->at(i*rg_xnum+j) = data_mat[i][j];
resval_ptr->at(i*rg_xnum+j) = inval_ptr->at(i*rg_xnum+j) - data_mat[i][j];
reg_data.datval_[i*rg_xnum+j] = data_mat[i][j];
res_data.datval_[i*rg_xnum+j] = data.datval_[i*rg_xnum+j] - data_mat[i][j];
}
}
}
@ -628,8 +619,8 @@ void gctl::gm_regular_grid::trend(std::string datname, std::string regname, std:
{
for (size_t j = 0; j < rg_xnum-1; j++)
{
regval_ptr->at(i*(rg_xnum-1)+j) = data_mat[i][j];
resval_ptr->at(i*(rg_xnum-1)+j) = inval_ptr->at(i*(rg_xnum-1)+j) - data_mat[i][j];
reg_data.datval_[i*(rg_xnum-1)+j] = data_mat[i][j];
res_data.datval_[i*(rg_xnum-1)+j] = data.datval_[i*(rg_xnum-1)+j] - data_mat[i][j];
}
}
}

11
lib/potential/gm_regular_mesh_2d.cpp
View File

@ -48,16 +48,15 @@ void gctl::grav_regular_mesh_2d::gobser(array<double> &out_data, std::string dat
{
array<double> rho(get_elenum(), 0.0);
meshdata *data_ptr = get_data(data_name);
mesh_data_value_e vtype = data_ptr->get_valtype();
meshdata &data = get_data(data_name);
mesh_data_value_e vtype = data.valtype_;
if (vtype == Scalar)
{
array<double> *val_ptr = (array<double>*) data_ptr->get_datval_ptr();
for (int i = 0; i < val_ptr->size(); i++)
for (int i = 0; i < data.datval_.size(); i++)
{
if (!std::isnan(val_ptr->at(i)))
if (!std::isnan(data.datval_[i]))
{
rho[i] = val_ptr->at(i);
rho[i] = data.datval_[i];
}
}
}

33
lib/potential/gm_regular_mesh_3d.cpp
View File

@ -48,16 +48,15 @@ void gctl::gm_regular_mesh_3d::gobser(array<double> &out_data, std::string data_
{
array<double> rho(get_elenum(), 0.0);
meshdata *data_ptr = get_data(data_name);
mesh_data_value_e vtype = data_ptr->get_valtype();
meshdata &data = get_data(data_name);
mesh_data_value_e vtype = data.valtype_;
if (vtype == Scalar)
{
array<double> *val_ptr = (array<double>*) data_ptr->get_datval_ptr();
for (int i = 0; i < val_ptr->size(); i++)
for (int i = 0; i < data.datval_.size(); i++)
{
if (!std::isnan(val_ptr->at(i)))
if (!std::isnan(data.datval_[i]))
{
rho[i] = val_ptr->at(i);
rho[i] = data.datval_[i];
}
}
}
@ -116,16 +115,15 @@ void gctl::gm_regular_mesh_3d::magobser(array<double> &out_data, std::string dat
{
array<double> sus(get_elenum(), 0.0);
meshdata *data_ptr = get_data(data_name);
mesh_data_value_e vtype = data_ptr->get_valtype();
meshdata &data = get_data(data_name);
mesh_data_value_e vtype = data.valtype_;
if (vtype == Scalar)
{
array<double> *val_ptr = (array<double>*) data_ptr->get_datval_ptr();
for (int i = 0; i < val_ptr->size(); i++)
for (int i = 0; i < data.datval_.size(); i++)
{
if (!std::isnan(val_ptr->at(i)))
if (!std::isnan(data.datval_[i]))
{
sus[i] = val_ptr->at(i);
sus[i] = data.datval_[i];
}
}
}
@ -156,16 +154,15 @@ void gctl::gm_regular_mesh_3d::magobser(array<double> &out_data, std::string dat
{
array<double> sus(get_elenum(), 0.0);
meshdata *data_ptr = get_data(data_name);
mesh_data_value_e vtype = data_ptr->get_valtype();
meshdata &data = get_data(data_name);
mesh_data_value_e vtype = data.valtype_;
if (vtype == Scalar)
{
array<double> *val_ptr = (array<double>*) data_ptr->get_datval_ptr();
for (int i = 0; i < val_ptr->size(); i++)
for (int i = 0; i < data.datval_.size(); i++)
{
if (!std::isnan(val_ptr->at(i)))
if (!std::isnan(data.datval_[i]))
{
sus[i] = val_ptr->at(i);
sus[i] = data.datval_[i];
}
}
}

22
lib/potential/gm_regular_mesh_sph_3d.cpp
View File

@ -50,16 +50,15 @@ void gctl::gm_regular_mesh_sph_3d::gobser(array<double> &out_data, std::string d
{
array<double> rho(get_elenum(), 0.0);
meshdata *data_ptr = get_data(data_name);
mesh_data_value_e vtype = data_ptr->get_valtype();
meshdata &data = get_data(data_name);
mesh_data_value_e vtype = data.valtype_;
if (vtype == Scalar)
{
array<double> *val_ptr = (array<double>*) data_ptr->get_datval_ptr();
for (int i = 0; i < val_ptr->size(); i++)
for (int i = 0; i < data.datval_.size(); i++)
{
if (!std::isnan(val_ptr->at(i)))
if (!std::isnan(data.datval_[i]))
{
rho[i] = val_ptr->at(i);
rho[i] = data.datval_[i];
}
}
}
@ -104,16 +103,15 @@ void gctl::gm_regular_mesh_sph_3d::magobser(array<double> &out_data, std::string
{
array<double> sus(get_elenum(), 0.0);
meshdata *data_ptr = get_data(data_name);
mesh_data_value_e vtype = data_ptr->get_valtype();
meshdata &data = get_data(data_name);
mesh_data_value_e vtype = data.valtype_;
if (vtype == Scalar)
{
array<double> *val_ptr = (array<double>*) data_ptr->get_datval_ptr();
for (int i = 0; i < val_ptr->size(); i++)
for (int i = 0; i < data.datval_.size(); i++)
{
if (!std::isnan(val_ptr->at(i)))
if (!std::isnan(data.datval_[i]))
{
sus[i] = val_ptr->at(i);
sus[i] = data.datval_[i];
}
}
}

174
lib/potential/gm_tet_mesh.cpp
View File

@ -66,16 +66,15 @@ void gctl::gm_tetrahedron_mesh::gobser(array<double> &out_obs, std::string data_
{
array<double> rho(get_elenum(), 0.0);
meshdata *data_ptr = get_data(data_name);
mesh_data_value_e vtype = data_ptr->get_valtype();
meshdata &data = get_data(data_name);
mesh_data_value_e vtype = data.valtype_;
if (vtype == Scalar)
{
array<double> *val_ptr = (array<double>*) data_ptr->get_datval_ptr();
for (int i = 0; i < val_ptr->size(); i++)
for (int i = 0; i < data.datval_.size(); i++)
{
if (!std::isnan(val_ptr->at(i)))
if (!std::isnan(data.datval_[i]))
{
rho[i] = val_ptr->at(i);
rho[i] = data.datval_[i];
}
}
}
@ -101,16 +100,15 @@ void gctl::gm_tetrahedron_mesh::gobser(array<point3dc> &out_obs, std::string dat
{
array<double> rho(get_elenum(), 0.0);
meshdata *data_ptr = get_data(data_name);
mesh_data_value_e vtype = data_ptr->get_valtype();
meshdata &data = get_data(data_name);
mesh_data_value_e vtype = data.valtype_;
if (vtype == Scalar)
{
array<double> *val_ptr = (array<double>*) data_ptr->get_datval_ptr();
for (int i = 0; i < val_ptr->size(); i++)
for (int i = 0; i < data.datval_.size(); i++)
{
if (!std::isnan(val_ptr->at(i)))
if (!std::isnan(data.datval_[i]))
{
rho[i] = val_ptr->at(i);
rho[i] = data.datval_[i];
}
}
}
@ -136,16 +134,15 @@ void gctl::gm_tetrahedron_mesh::gobser(array<tensor> &out_obs, std::string data_
{
array<double> rho(get_elenum(), 0.0);
meshdata *data_ptr = get_data(data_name);
mesh_data_value_e vtype = data_ptr->get_valtype();
meshdata &data = get_data(data_name);
mesh_data_value_e vtype = data.valtype_;
if (vtype == Scalar)
{
array<double> *val_ptr = (array<double>*) data_ptr->get_datval_ptr();
for (int i = 0; i < val_ptr->size(); i++)
for (int i = 0; i < data.datval_.size(); i++)
{
if (!std::isnan(val_ptr->at(i)))
if (!std::isnan(data.datval_[i]))
{
rho[i] = val_ptr->at(i);
rho[i] = data.datval_[i];
}
}
}
@ -171,16 +168,15 @@ void gctl::gm_tetrahedron_mesh::gobser(array<double> &out_obs, std::string data_
{
array<double> rho(get_elenum(), 0.0);
meshdata *data_ptr = get_data(data_name);
mesh_data_value_e vtype = data_ptr->get_valtype();
meshdata &data = get_data(data_name);
mesh_data_value_e vtype = data.valtype_;
if (vtype == Scalar)
{
array<double> *val_ptr = (array<double>*) data_ptr->get_datval_ptr();
for (int i = 0; i < val_ptr->size(); i++)
for (int i = 0; i < data.datval_.size(); i++)
{
if (!std::isnan(val_ptr->at(i)))
if (!std::isnan(data.datval_[i]))
{
rho[i] = val_ptr->at(i);
rho[i] = data.datval_[i];
}
}
}
@ -206,16 +202,15 @@ void gctl::gm_tetrahedron_mesh::gobser(array<point3dc> &out_obs, std::string dat
{
array<double> rho(get_elenum(), 0.0);
meshdata *data_ptr = get_data(data_name);
mesh_data_value_e vtype = data_ptr->get_valtype();
meshdata &data = get_data(data_name);
mesh_data_value_e vtype = data.valtype_;
if (vtype == Scalar)
{
array<double> *val_ptr = (array<double>*) data_ptr->get_datval_ptr();
for (int i = 0; i < val_ptr->size(); i++)
for (int i = 0; i < data.datval_.size(); i++)
{
if (!std::isnan(val_ptr->at(i)))
if (!std::isnan(data.datval_[i]))
{
rho[i] = val_ptr->at(i);
rho[i] = data.datval_[i];
}
}
}
@ -241,16 +236,15 @@ void gctl::gm_tetrahedron_mesh::gobser(array<tensor> &out_obs, std::string data_
{
array<double> rho(get_elenum(), 0.0);
meshdata *data_ptr = get_data(data_name);
mesh_data_value_e vtype = data_ptr->get_valtype();
meshdata &data = get_data(data_name);
mesh_data_value_e vtype = data.valtype_;
if (vtype == Scalar)
{
array<double> *val_ptr = (array<double>*) data_ptr->get_datval_ptr();
for (int i = 0; i < val_ptr->size(); i++)
for (int i = 0; i < data.datval_.size(); i++)
{
if (!std::isnan(val_ptr->at(i)))
if (!std::isnan(data.datval_[i]))
{
rho[i] = val_ptr->at(i);
rho[i] = data.datval_[i];
}
}
}
@ -275,19 +269,18 @@ void gctl::gm_tetrahedron_mesh::gobser(array<tensor> &out_obs, std::string data_
void gctl::gm_tetrahedron_mesh::magkernel(matrix<double> &out_kernel, std::string sus_name, const array<point3dc> &obsp,
double inclina_deg, double declina_deg, verbose_type_e verbose)
{
meshdata *data_ptr = get_data(sus_name);
mesh_data_value_e vtype = data_ptr->get_valtype();
meshdata &data = get_data(sus_name);
mesh_data_value_e vtype = data.valtype_;
array<double> sus(get_elenum(), 0.0);
if (vtype == Scalar)
{
array<double> *val_ptr = (array<double>*) data_ptr->get_datval_ptr();
for (int i = 0; i < val_ptr->size(); i++)
for (int i = 0; i < data.datval_.size(); i++)
{
if (!std::isnan(val_ptr->at(i)))
if (!std::isnan(data.datval_[i]))
{
sus[i] = val_ptr->at(i);
sus[i] = data.datval_[i];
}
}
}
@ -312,19 +305,18 @@ void gctl::gm_tetrahedron_mesh::magkernel(matrix<double> &out_kernel, std::strin
void gctl::gm_tetrahedron_mesh::magkernel(matrix<point3dc> &out_kernel, std::string sus_name, const array<point3dc> &obsp,
double inclina_deg, double declina_deg, verbose_type_e verbose)
{
meshdata *data_ptr = get_data(sus_name);
mesh_data_value_e vtype = data_ptr->get_valtype();
meshdata &data = get_data(sus_name);
mesh_data_value_e vtype = data.valtype_;
array<double> sus(get_elenum(), 0.0);
if (vtype == Scalar)
{
array<double> *val_ptr = (array<double>*) data_ptr->get_datval_ptr();
for (int i = 0; i < val_ptr->size(); i++)
for (int i = 0; i < data.datval_.size(); i++)
{
if (!std::isnan(val_ptr->at(i)))
if (!std::isnan(data.datval_[i]))
{
sus[i] = val_ptr->at(i);
sus[i] = data.datval_[i];
}
}
}
@ -349,19 +341,18 @@ void gctl::gm_tetrahedron_mesh::magkernel(matrix<point3dc> &out_kernel, std::str
void gctl::gm_tetrahedron_mesh::magkernel(matrix<tensor> &out_kernel, std::string sus_name, const array<point3dc> &obsp,
double inclina_deg, double declina_deg, verbose_type_e verbose)
{
meshdata *data_ptr = get_data(sus_name);
mesh_data_value_e vtype = data_ptr->get_valtype();
meshdata &data = get_data(sus_name);
mesh_data_value_e vtype = data.valtype_;
array<double> sus(get_elenum(), 0.0);
if (vtype == Scalar)
{
array<double> *val_ptr = (array<double>*) data_ptr->get_datval_ptr();
for (int i = 0; i < val_ptr->size(); i++)
for (int i = 0; i < data.datval_.size(); i++)
{
if (!std::isnan(val_ptr->at(i)))
if (!std::isnan(data.datval_[i]))
{
sus[i] = val_ptr->at(i);
sus[i] = data.datval_[i];
}
}
}
@ -386,19 +377,18 @@ void gctl::gm_tetrahedron_mesh::magkernel(matrix<tensor> &out_kernel, std::strin
void gctl::gm_tetrahedron_mesh::magobser(array<double> &out_obs, std::string sus_name, const array<point3dc> &obsp,
double inclina_deg, double declina_deg, verbose_type_e verbose)
{
meshdata *data_ptr = get_data(sus_name);
mesh_data_value_e vtype = data_ptr->get_valtype();
meshdata &data = get_data(sus_name);
mesh_data_value_e vtype = data.valtype_;
array<double> sus(get_elenum(), 0.0);
if (vtype == Scalar)
{
array<double> *val_ptr = (array<double>*) data_ptr->get_datval_ptr();
for (int i = 0; i < val_ptr->size(); i++)
for (int i = 0; i < data.datval_.size(); i++)
{
if (!std::isnan(val_ptr->at(i)))
if (!std::isnan(data.datval_[i]))
{
sus[i] = val_ptr->at(i);
sus[i] = data.datval_[i];
}
}
}
@ -423,19 +413,18 @@ void gctl::gm_tetrahedron_mesh::magobser(array<double> &out_obs, std::string sus
void gctl::gm_tetrahedron_mesh::magobser(array<point3dc> &out_obs, std::string sus_name, const array<point3dc> &obsp,
double inclina_deg, double declina_deg, verbose_type_e verbose)
{
meshdata *data_ptr = get_data(sus_name);
mesh_data_value_e vtype = data_ptr->get_valtype();
meshdata &data = get_data(sus_name);
mesh_data_value_e vtype = data.valtype_;
array<double> sus(get_elenum(), 0.0);
if (vtype == Scalar)
{
array<double> *val_ptr = (array<double>*) data_ptr->get_datval_ptr();
for (int i = 0; i < val_ptr->size(); i++)
for (int i = 0; i < data.datval_.size(); i++)
{
if (!std::isnan(val_ptr->at(i)))
if (!std::isnan(data.datval_[i]))
{
sus[i] = val_ptr->at(i);
sus[i] = data.datval_[i];
}
}
}
@ -460,19 +449,18 @@ void gctl::gm_tetrahedron_mesh::magobser(array<point3dc> &out_obs, std::string s
void gctl::gm_tetrahedron_mesh::magobser(array<tensor> &out_obs, std::string sus_name, const array<point3dc> &obsp,
double inclina_deg, double declina_deg, verbose_type_e verbose)
{
meshdata *data_ptr = get_data(sus_name);
mesh_data_value_e vtype = data_ptr->get_valtype();
meshdata &data = get_data(sus_name);
mesh_data_value_e vtype = data.valtype_;
array<double> sus(get_elenum(), 0.0);
if (vtype == Scalar)
{
array<double> *val_ptr = (array<double>*) data_ptr->get_datval_ptr();
for (int i = 0; i < val_ptr->size(); i++)
for (int i = 0; i < data.datval_.size(); i++)
{
if (!std::isnan(val_ptr->at(i)))
if (!std::isnan(data.datval_[i]))
{
sus[i] = val_ptr->at(i);
sus[i] = data.datval_[i];
}
}
}
@ -496,20 +484,12 @@ void gctl::gm_tetrahedron_mesh::magobser(array<tensor> &out_obs, std::string sus
void gctl::gm_tetrahedron_mesh::magobser(array<double> &out_obs, std::string magz_name, const array<point3dc> &obsp, verbose_type_e verbose)
{
meshdata *data_ptr;
mesh_data_value_e vtype;
array<point3dc> magz(get_elenum(), point3dc(0.0, 0.0, 0.0));
data_ptr = get_data(magz_name);
vtype = data_ptr->get_valtype();
meshdata &data = get_data(magz_name);
mesh_data_value_e vtype = data.valtype_;
if (vtype == Vector)
{
array<point3dc> *val_ptr = (array<point3dc>*) data_ptr->get_datval_ptr();
for (int i = 0; i < val_ptr->size(); i++)
{
magz[i] = val_ptr->at(i);
}
magz = data.export_vector();
}
else
{
@ -531,20 +511,12 @@ void gctl::gm_tetrahedron_mesh::magobser(array<double> &out_obs, std::string mag
void gctl::gm_tetrahedron_mesh::magobser(array<point3dc> &out_obs, std::string magz_name, const array<point3dc> &obsp, verbose_type_e verbose)
{
meshdata *data_ptr;
mesh_data_value_e vtype;
array<point3dc> magz(get_elenum(), point3dc(0.0, 0.0, 0.0));
data_ptr = get_data(magz_name);
vtype = data_ptr->get_valtype();
meshdata &data = get_data(magz_name);
mesh_data_value_e vtype = data.valtype_;
if (vtype == Vector)
{
array<point3dc> *val_ptr = (array<point3dc>*) data_ptr->get_datval_ptr();
for (int i = 0; i < val_ptr->size(); i++)
{
magz[i] = val_ptr->at(i);
}
magz = data.export_vector();
}
else
{
@ -566,20 +538,12 @@ void gctl::gm_tetrahedron_mesh::magobser(array<point3dc> &out_obs, std::string m
void gctl::gm_tetrahedron_mesh::magobser(array<tensor> &out_obs, std::string magz_name, const array<point3dc> &obsp, verbose_type_e verbose)
{
meshdata *data_ptr;
mesh_data_value_e vtype;
array<point3dc> magz(get_elenum(), point3dc(0.0, 0.0, 0.0));
data_ptr = get_data(magz_name);
vtype = data_ptr->get_valtype();
meshdata &data = get_data(magz_name);
mesh_data_value_e vtype = data.valtype_;
if (vtype == Vector)
{
array<point3dc> *val_ptr = (array<point3dc>*) data_ptr->get_datval_ptr();
for (int i = 0; i < val_ptr->size(); i++)
{
magz[i] = val_ptr->at(i);
}
magz = data.export_vector();
}
else
{

16
tool/gridmanager-potential/gridmanager-potential.cpp
View File

@ -372,8 +372,7 @@ void save_gmsh(const std::vector<std::string> &cmd_units)
// save gmsh <file>
if (cmd_units.size() < 3) throw std::runtime_error("save: insufficient parameters.");
rg.save_gmsh(cmd_units[2], NodeData, OverWrite, NotPacked);
rg.save_gmsh(cmd_units[2], ElemData, Append, NotPacked);
rg.save_gmsh(cmd_units[2], OverWrite, NotPacked);
return;
}
@ -622,16 +621,16 @@ void data_output(const std::vector<std::string> &cmd_units)
{
for (size_t i = 1; i < copy_str.size(); i++)
{
data_ptr = rg.get_data(copy_str[i]);
data_ptr->set_output(true);
data_ptr = rg.get_data_ptr(copy_str[i]);
data_ptr->output_ok_ = true;
}
}
else if (copy_str[0] == "disable")
{
for (size_t i = 1; i < copy_str.size(); i++)
{
data_ptr = rg.get_data(copy_str[i]);
data_ptr->set_output(false);
data_ptr = rg.get_data_ptr(copy_str[i]);
data_ptr->output_ok_ = false;
}
}
else throw std::runtime_error("data-output: invalid operation type.");
@ -649,7 +648,8 @@ void data_rename(const std::vector<std::string> &cmd_units)
copy_str[i - 1] = cmd_units[i];
}
rg.rename_data(copy_str[0], copy_str[1]);
meshdata &data = rg.get_data(copy_str[0]);
data.name_ = copy_str[1];
return;
}
@ -692,7 +692,7 @@ void get_stats(const std::vector<std::string> &cmd_units)
std::vector<double> stats;
for (size_t i = 0; i < copy_str.size(); i++)
{
data_ptr = rg.get_data(copy_str[i]);
data_ptr = rg.get_data_ptr(copy_str[i]);
data_ptr->show_info();
data_ptr->show_stats();
}