diff --git a/lib/potential/gm_regular_grid.cpp b/lib/potential/gm_regular_grid.cpp
index 22dbc0d..d08324b 100644
--- a/lib/potential/gm_regular_grid.cpp
+++ b/lib/potential/gm_regular_grid.cpp
@@ -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];
 			}
 		}
 	}
diff --git a/lib/potential/gm_regular_mesh_2d.cpp b/lib/potential/gm_regular_mesh_2d.cpp
index fb5ac61..306fea2 100644
--- a/lib/potential/gm_regular_mesh_2d.cpp
+++ b/lib/potential/gm_regular_mesh_2d.cpp
@@ -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];
 			}
 		}
 	}
diff --git a/lib/potential/gm_regular_mesh_3d.cpp b/lib/potential/gm_regular_mesh_3d.cpp
index e1e256a..fbf49e7 100644
--- a/lib/potential/gm_regular_mesh_3d.cpp
+++ b/lib/potential/gm_regular_mesh_3d.cpp
@@ -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];
 			}
 		}
 	}
diff --git a/lib/potential/gm_regular_mesh_sph_3d.cpp b/lib/potential/gm_regular_mesh_sph_3d.cpp
index b8fb4ec..4aada01 100644
--- a/lib/potential/gm_regular_mesh_sph_3d.cpp
+++ b/lib/potential/gm_regular_mesh_sph_3d.cpp
@@ -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];
 			}
 		}
 	}
diff --git a/lib/potential/gm_tet_mesh.cpp b/lib/potential/gm_tet_mesh.cpp
index 36669c4..95d97f4 100644
--- a/lib/potential/gm_tet_mesh.cpp
+++ b/lib/potential/gm_tet_mesh.cpp
@@ -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
 	{
diff --git a/tool/gridmanager-potential/gridmanager-potential.cpp b/tool/gridmanager-potential/gridmanager-potential.cpp
index aa5d090..5dea932 100644
--- a/tool/gridmanager-potential/gridmanager-potential.cpp
+++ b/tool/gridmanager-potential/gridmanager-potential.cpp
@@ -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();
     }