0912 修改surfParam

CAE_Solution/src/acis/cmdmainprocess.cpp

@@ -515,114 +515,114 @@ Spa3dpm::Parameters cmdMainProcess::setADIParamTo3dpm(const DPM_ADIParam &p)
     Spa3dpm::Parameters cadsurfParams;
     //cadsurfParams.SetParam("global_physical_size", "0.01"); // default: ModelDiagonal/100
     //cadsurfParams.SetParam("element_order", "quadratic");
-    if (!p.surfParam.SurfStyle.isEmpty())
+    if (!p.surfParam_.SurfStyle.isEmpty())
     {
-        cadsurfParams.SetParam("element_generation", p.surfParam.SurfStyle.toLatin1().data());//"full_quad");//"quad_dominant");
+        cadsurfParams.SetParam("element_generation", p.surfParam_.SurfStyle.toLatin1().data());//"full_quad");//"quad_dominant");
     }
-    if (!p.surfParam.max_size.isEmpty())
+    if (!p.surfParam_.max_size.isEmpty())
     {
-        cadsurfParams.SetParam("max_size", p.surfParam.max_size.toLatin1().data());//"full_quad");//"quad_dominant");
+        cadsurfParams.SetParam("max_size", p.surfParam_.max_size.toLatin1().data());//"full_quad");//"quad_dominant");
     }
-    if (!p.surfParam.min_size.isEmpty())
+    if (!p.surfParam_.min_size.isEmpty())
     {
-        cadsurfParams.SetParam("min_size", p.surfParam.min_size.toLatin1().data());//"full_quad");//"quad_dominant");
+        cadsurfParams.SetParam("min_size", p.surfParam_.min_size.toLatin1().data());//"full_quad");//"quad_dominant");
     }
-    if (!p.surfParam.Global_physical_size.isEmpty())
+    if (!p.surfParam_.Global_physical_size.isEmpty())
     {
-        cadsurfParams.SetParam("global_physical_size", p.surfParam.Global_physical_size.toLatin1().data());//"full_quad");//"quad_dominant");
+        cadsurfParams.SetParam("global_physical_size", p.surfParam_.Global_physical_size.toLatin1().data());//"full_quad");//"quad_dominant");
     }
-    if (!p.surfParam.gradation.isEmpty())
+    if (!p.surfParam_.gradation.isEmpty())
     {
-        cadsurfParams.SetParam("gradation", p.surfParam.gradation.toLatin1().data());//"full_quad");//"quad_dominant");
+        cadsurfParams.SetParam("gradation", p.surfParam_.gradation.toLatin1().data());//"full_quad");//"quad_dominant");
     }
 
     //optim
-    if (!p.surfParam.element_order.isEmpty())
+    if (!p.surfParam_.element_order.isEmpty())
     {
         //"full_quad");//"quad_dominant");
-        if (p.surfParam.element_order=="quadratic" )
+        if (p.surfParam_.element_order=="quadratic" )
         {
-            cadsurfParams.SetParam("element_order", p.surfParam.element_order.toLatin1().data());
-            if (!p.surfParam.scaled_jacobian_threshold_value.isEmpty())
+            cadsurfParams.SetParam("element_order", p.surfParam_.element_order.toLatin1().data());
+            if (!p.surfParam_.scaled_jacobian_threshold_value.isEmpty())
             {
-                cadsurfParams.SetParam("scaled_jacobian_threshold_value", p.surfParam.scaled_jacobian_threshold_value.toLatin1().data());
+                cadsurfParams.SetParam("scaled_jacobian_threshold_value", p.surfParam_.scaled_jacobian_threshold_value.toLatin1().data());
             }
 
         }
     }
-    if (!p.surfParam.remove_duplicate_cad_faces.isEmpty()&& p.surfParam.remove_duplicate_cad_faces=="no")
+    if (!p.surfParam_.remove_duplicate_cad_faces.isEmpty()&& p.surfParam_.remove_duplicate_cad_faces=="no")
     {
-        cadsurfParams.SetParam("remove_duplicate_cad_faces", p.surfParam.remove_duplicate_cad_faces.toLatin1().data());
+        cadsurfParams.SetParam("remove_duplicate_cad_faces", p.surfParam_.remove_duplicate_cad_faces.toLatin1().data());
     }
-    if (!p.surfParam.correct_surface_intersections.isEmpty())
+    if (!p.surfParam_.correct_surface_intersections.isEmpty())
     {
-        if (p.surfParam.correct_surface_intersections=="no"&& p.surfParam.optimisation=="yes")
+        if (p.surfParam_.correct_surface_intersections=="no"&& p.surfParam_.optimisation=="yes")
         {
-            cadsurfParams.SetParam("correct_surface_intersections", p.surfParam.correct_surface_intersections.toLatin1().data());
-            cadsurfParams.SetParam("optimisation", p.surfParam.optimisation.toLatin1().data());
+            cadsurfParams.SetParam("correct_surface_intersections", p.surfParam_.correct_surface_intersections.toLatin1().data());
+            cadsurfParams.SetParam("optimisation", p.surfParam_.optimisation.toLatin1().data());
         }
     }
 
     //more setting
-    if (!p.surfParam.debug.isEmpty())
+    if (!p.surfParam_.debug.isEmpty())
     {
-        cadsurfParams.SetParam("debug", p.surfParam.debug.toLatin1().data());
+        cadsurfParams.SetParam("debug", p.surfParam_.debug.toLatin1().data());
     }
-    if (!p.surfParam.closed_geometry.isEmpty())
+    if (!p.surfParam_.closed_geometry.isEmpty())
     {
-        cadsurfParams.SetParam("closed_geometry", p.surfParam.closed_geometry.toLatin1().data());
+        cadsurfParams.SetParam("closed_geometry", p.surfParam_.closed_geometry.toLatin1().data());
     }
-    if (!p.surfParam.anisotropic_ratio.isEmpty())
+    if (!p.surfParam_.anisotropic_ratio.isEmpty())
     {
-        cadsurfParams.SetParam("anisotropic_ratio", p.surfParam.anisotropic_ratio.toLatin1().data());
+        cadsurfParams.SetParam("anisotropic_ratio", p.surfParam_.anisotropic_ratio.toLatin1().data());
     }
 
-    if (!p.surfParam.bad_surface_element_aspect_ratio.isEmpty())
+    if (!p.surfParam_.bad_surface_element_aspect_ratio.isEmpty())
     {
-        cadsurfParams.SetParam("bad_surface_element_aspect_ratio", p.surfParam.bad_surface_element_aspect_ratio.toLatin1().data());
+        cadsurfParams.SetParam("bad_surface_element_aspect_ratio", p.surfParam_.bad_surface_element_aspect_ratio.toLatin1().data());
     }
 
-    if (!p.surfParam.chordal_error.isEmpty())
+    if (!p.surfParam_.chordal_error.isEmpty())
     {
-        cadsurfParams.SetParam("chordal_error", p.surfParam.chordal_error.toLatin1().data());
+        cadsurfParams.SetParam("chordal_error", p.surfParam_.chordal_error.toLatin1().data());
     }
-    if (!p.surfParam.closed_geometry.isEmpty())
+    if (!p.surfParam_.closed_geometry.isEmpty())
     {
-        cadsurfParams.SetParam("closed_geometry", p.surfParam.closed_geometry.toLatin1().data());
+        cadsurfParams.SetParam("closed_geometry", p.surfParam_.closed_geometry.toLatin1().data());
     }
-    if (!p.surfParam.discard_input_topology.isEmpty())
+    if (!p.surfParam_.discard_input_topology.isEmpty())
     {
-        cadsurfParams.SetParam("discard_input_topology", p.surfParam.discard_input_topology.toLatin1().data());
+        cadsurfParams.SetParam("discard_input_topology", p.surfParam_.discard_input_topology.toLatin1().data());
     }
-    if (!p.surfParam.create_tag_on_collision.isEmpty())
+    if (!p.surfParam_.create_tag_on_collision.isEmpty())
     {
-        cadsurfParams.SetParam("create_tag_on_collision", p.surfParam.create_tag_on_collision.toLatin1().data());
+        cadsurfParams.SetParam("create_tag_on_collision", p.surfParam_.create_tag_on_collision.toLatin1().data());
     }
-    if (!p.surfParam.chordal_error.isEmpty())
+    if (!p.surfParam_.chordal_error.isEmpty())
     {
-        cadsurfParams.SetParam("chordal_error", ADIParam_.surfParam.chordal_error.toLatin1().data());
+        cadsurfParams.SetParam("chordal_error", ADIParam_.surfParam_.chordal_error.toLatin1().data());
         printf("chordal_error set\n");
     }
-    if (!p.surfParam.geometric_approximation_angle.isEmpty())
+    if (!p.surfParam_.geometric_approximation_angle.isEmpty())
     {
-        cadsurfParams.SetParam("geometric_approximation_angle", ADIParam_.surfParam.geometric_approximation_angle.toLatin1().data());
+        cadsurfParams.SetParam("geometric_approximation_angle", ADIParam_.surfParam_.geometric_approximation_angle.toLatin1().data());
         printf("geometric_approximation_angle set\n");
     }
     //--mg
-    if (!p.surfParam.physical_size_mode.isEmpty()&& p.surfParam.physical_size_mode=="local"){
+    if (!p.surfParam_.physical_size_mode.isEmpty()&& p.surfParam_.physical_size_mode=="local"){
         USE_LOCAL_PHYSICAL_SIZE = 1;
         printf("print the physical_size_mode");
-        //}else{ //if (p.surfParam.physical_size_mode=="global"){
-    }else if (!p.surfParam.physical_size_mode.isEmpty()){
-        cadsurfParams.SetParam("physical_size_mode", p.surfParam.physical_size_mode.toLatin1().data());
+        //}else{ //if (p.surfParam_.physical_size_mode=="global"){
+    }else if (!p.surfParam_.physical_size_mode.isEmpty()){
+        cadsurfParams.SetParam("physical_size_mode", p.surfParam_.physical_size_mode.toLatin1().data());
     }
-    if (!p.surfParam.geometric_size_mode.isEmpty() && p.surfParam.geometric_size_mode == "local") {
+    if (!p.surfParam_.geometric_size_mode.isEmpty() && p.surfParam_.geometric_size_mode == "local") {
         USE_LOCAL_PHYSICAL_SIZE = 2;
         printf("print the geometric_size_mode");
-        //}else {//if (p.surfParam.geometric_size_mode == "global") {
-    }else if (!p.surfParam.geometric_size_mode.isEmpty()) {
-        cadsurfParams.SetParam("geometric_size_mode", p.surfParam.geometric_size_mode.toLatin1().data());
-        printf("*** geometric_size_mode: %s\n", p.surfParam.geometric_size_mode.toLatin1().data());
+        //}else {//if (p.surfParam_.geometric_size_mode == "global") {
+    }else if (!p.surfParam_.geometric_size_mode.isEmpty()) {
+        cadsurfParams.SetParam("geometric_size_mode", p.surfParam_.geometric_size_mode.toLatin1().data());
+        printf("*** geometric_size_mode: %s\n", p.surfParam_.geometric_size_mode.toLatin1().data());
     }
     return cadsurfParams;
 }
@@ -775,25 +775,25 @@ void cmdMainProcess::CreateLocalSizeMap()
     {
 
         // Apply physical size functions, sizemaps应用物理尺寸函数、尺寸映射
-        //if (!ADIParam_.surfParam.physical_size_mode.isEmpty())
+        //if (!ADIParam_.surfParam_.physical_size_mode.isEmpty())
         //{
-        cadsurfParams_.SetParam("physical_size_mode", ADIParam_.surfParam.physical_size_mode.toLatin1().data());
+        cadsurfParams_.SetParam("physical_size_mode", ADIParam_.surfParam_.physical_size_mode.toLatin1().data());
         //}
         // default: "none"; when use_local_physical_size需要設置為 "local"
         // Create a sizemap associated with faces创建与面关联的尺寸映射
         SampleUtils_ = new DPMvolClass();
-        if (ADIParam_.surfParam.Global_physical_size.isEmpty())
+        if (ADIParam_.surfParam_.Global_physical_size.isEmpty())
         {
             printf("error : global_physical_size is empty!\n");
             return;
         }
 
-        SampleUtils_->setGlobelSize(ADIParam_.surfParam.Global_physical_size.toDouble());
+        SampleUtils_->setGlobelSize(ADIParam_.surfParam_.Global_physical_size.toDouble());
         // Get pointer to native MeshGems cad_t object
         meshgems_cad_t *mg_cad = cadsurf_.GetMeshgemsCadPtr();
-        if (!ADIParam_.surfParam.physicalSizeFaceId.isEmpty())
+        if (!ADIParam_.surfParam_.physicalSizeFaceId.isEmpty())
         {
-            SampleUtils_->SetLocalSizeData(2, ADIParam_.surfParam.physicalSizeFaceId);//"1,10;2,4;");
+            SampleUtils_->SetLocalSizeData(2, ADIParam_.surfParam_.physicalSizeFaceId);//"1,10;2,4;");
             szmp_iso_face_t_ = meshgems_sizemap_new(mg_cad, meshgems_sizemap_type_iso_cad_face, SampleUtils_->size_iso_face, SampleUtils_);
             if (!szmp_iso_face_t_) sys_error(MESHGEMS_STATUS_NOMEM);
 #ifdef ADI_DEBUG_PRINT
@@ -803,9 +803,9 @@ void cmdMainProcess::CreateLocalSizeMap()
 
 
         // Create a sizemap associated with edges
-        if (!ADIParam_.surfParam.physicalSizeEdgeId.isEmpty())
+        if (!ADIParam_.surfParam_.physicalSizeEdgeId.isEmpty())
         {
-            SampleUtils_->SetLocalSizeData(1, ADIParam_.surfParam.physicalSizeEdgeId);
+            SampleUtils_->SetLocalSizeData(1, ADIParam_.surfParam_.physicalSizeEdgeId);
             szmp_iso_edge_t_ = meshgems_sizemap_new(mg_cad, meshgems_sizemap_type_iso_cad_edge, SampleUtils_->size_iso_edge, SampleUtils_); //SampleUtils_.size_iso_edge, 0);
             if (!szmp_iso_edge_t_) sys_error(MESHGEMS_STATUS_NOMEM);
 #ifdef ADI_DEBUG_PRINT
@@ -813,9 +813,9 @@ void cmdMainProcess::CreateLocalSizeMap()
 #endif
         }
         // Create a sizemap associated with point
-        if (!ADIParam_.surfParam.physicalSizePointId.isEmpty())
+        if (!ADIParam_.surfParam_.physicalSizePointId.isEmpty())
         {
-            SampleUtils_->SetLocalSizeData(0, ADIParam_.surfParam.physicalSizePointId);
+            SampleUtils_->SetLocalSizeData(0, ADIParam_.surfParam_.physicalSizePointId);
             szmp_iso_point_t_ = meshgems_sizemap_new(mg_cad, meshgems_sizemap_type_iso_cad_point, SampleUtils_->size_iso_point, SampleUtils_);
             if (!szmp_iso_point_t_) sys_error(MESHGEMS_STATUS_NOMEM);
             printf("Sizemap point ok \n");
@@ -840,26 +840,26 @@ void cmdMainProcess::CreateLocalSizeMap()
 
 
         // Apply physical size functions, sizemaps
-        //if (!ADIParam_.surfParam.physical_size_mode.isEmpty())
+        //if (!ADIParam_.surfParam_.physical_size_mode.isEmpty())
         //{
-        cadsurfParams_.SetParam("geometric_size_mode", ADIParam_.surfParam.geometric_size_mode.toLatin1().data());
+        cadsurfParams_.SetParam("geometric_size_mode", ADIParam_.surfParam_.geometric_size_mode.toLatin1().data());
         //}
         // default: "none"; when use_local_physical_size需要設置為 "local"
         // Create a sizemap associated with faces
 
 
         SampleUtils_ = new DPMvolClass();
-        if (ADIParam_.surfParam.Global_physical_size.isEmpty())
+        if (ADIParam_.surfParam_.Global_physical_size.isEmpty())
         {
             printf("error : global_physical_size is empty!");
             return;
         }
-        SampleUtils_->setGlobelSize(ADIParam_.surfParam.Global_physical_size.toDouble());
+        SampleUtils_->setGlobelSize(ADIParam_.surfParam_.Global_physical_size.toDouble());
         // Get pointer to native MeshGems cad_t object
         meshgems_cad_t *mg_cad = cadsurf_.GetMeshgemsCadPtr();
-        if (!ADIParam_.surfParam.geometricSizeFaceId.isEmpty())
+        if (!ADIParam_.surfParam_.geometricSizeFaceId.isEmpty())
         {
-            SampleUtils_->SetLocalSizeData(2, ADIParam_.surfParam.geometricSizeFaceId);//"1,10;2,4;");
+            SampleUtils_->SetLocalSizeData(2, ADIParam_.surfParam_.geometricSizeFaceId);//"1,10;2,4;");
             szmp_iso_face_t_ = meshgems_sizemap_new(mg_cad, meshgems_sizemap_type_iso_cad_face, SampleUtils_->size_iso_face, SampleUtils_);
             if (!szmp_iso_face_t_) sys_error(MESHGEMS_STATUS_NOMEM);
 #ifdef ADI_DEBUG_PRINT
@@ -869,9 +869,9 @@ void cmdMainProcess::CreateLocalSizeMap()
 
 
         // Create a sizemap associated with edges
-        if (!ADIParam_.surfParam.geometricSizeEdgeId.isEmpty())
+        if (!ADIParam_.surfParam_.geometricSizeEdgeId.isEmpty())
         {
-            SampleUtils_->SetLocalSizeData(1, ADIParam_.surfParam.geometricSizeEdgeId);
+            SampleUtils_->SetLocalSizeData(1, ADIParam_.surfParam_.geometricSizeEdgeId);
             szmp_iso_edge_t_ = meshgems_sizemap_new(mg_cad, meshgems_sizemap_type_iso_cad_edge, SampleUtils_->size_iso_edge, SampleUtils_); //SampleUtils_.size_iso_edge, 0);
             if (!szmp_iso_edge_t_) sys_error(MESHGEMS_STATUS_NOMEM);
 #ifdef ADI_DEBUG_PRINT
@@ -879,9 +879,9 @@ void cmdMainProcess::CreateLocalSizeMap()
 #endif
         }
         // Create a sizemap associated with point创建与点关联的尺寸映射
-        if (!ADIParam_.surfParam.geometricSizePointId.isEmpty())
+        if (!ADIParam_.surfParam_.geometricSizePointId.isEmpty())
         {
-            SampleUtils_->SetLocalSizeData(0, ADIParam_.surfParam.geometricSizePointId);
+            SampleUtils_->SetLocalSizeData(0, ADIParam_.surfParam_.geometricSizePointId);
             szmp_iso_point_t_ = meshgems_sizemap_new(mg_cad, meshgems_sizemap_type_iso_cad_point, SampleUtils_->size_iso_point, SampleUtils_);
             if (!szmp_iso_point_t_) sys_error(MESHGEMS_STATUS_NOMEM);
             printf("Sizemap point ok \n");

CAE_Solution/src/acis/dataclass.h

@@ -166,7 +166,7 @@ class DPM_ADIParam
 public:
     int style;
     bool bCleanerSection;
-    surfParam surfParam;
+    surfParam surfParam_;
     cleanerParam clrParam;
     TetraParam tetraParam;
     HexaParam hexaParam;
@@ -177,37 +177,37 @@ public:
     {
         strResultFormat = ".vtk";
         style = 0;//0->面网格，1->四面体网格，2->六面体网格
-        surfParam.SurfStyle ="";
-        surfParam.max_size ="";
-        surfParam.min_size ="";
-        surfParam.element_order = "";//单元阶数选择（“linear”、“quadratio”）
-        surfParam.anisotropic_ratio = "";//异性率（default 0）
-        surfParam.bad_surface_element_aspect_ratio = "";//纵横比（default 1000）
-        surfParam.correct_surface_intersections = "";//纠正表面相交（default yes）
-        surfParam.chordal_error = "";//弦误差（default D）
-        surfParam.debug = "";//debugbool（default no）
-        surfParam.closed_geometry = "";//bool(default no关闭几何)
-        surfParam.discard_input_topology = "";//bool（default no）离散输入拓扑
-        surfParam.create_tag_on_collision = "";//bool(default yes)创建新标签来描述标签冲突
-        surfParam.enforce_cad_edge_sizes = "";//仅当 与gradation相结合时有效
-        surfParam.force_bad_surface_element_removal = "";//bool（default no）
-        surfParam.geometric_size_mode = "";//(default none)
-        surfParam.jacobian_rectification_respect_geometry = "";//default yes
-        surfParam.manifold_geometry = "";//bool(default no)
-        surfParam.max_number_of_points_per_patch = "";//int(default 100000)
-        surfParam.merge_edges = "";//bool(default yes)合并小边来优化几何图形
-        surfParam.metric = "";//(default isotropic)
-        surfParam.optimisation = "";//bool (default yes)when "correct_surface_intersections==yes,not useful"
-        surfParam.optimise_tiny_edges = "";//bool (default no)
+        surfParam_.SurfStyle ="";
+        surfParam_.max_size ="";
+        surfParam_.min_size ="";
+        surfParam_.element_order = "";//单元阶数选择（“linear”、“quadratio”）
+        surfParam_.anisotropic_ratio = "";//异性率（default 0）
+        surfParam_.bad_surface_element_aspect_ratio = "";//纵横比（default 1000）
+        surfParam_.correct_surface_intersections = "";//纠正表面相交（default yes）
+        surfParam_.chordal_error = "";//弦误差（default D）
+        surfParam_.debug = "";//debugbool（default no）
+        surfParam_.closed_geometry = "";//bool(default no关闭几何)
+        surfParam_.discard_input_topology = "";//bool（default no）离散输入拓扑
+        surfParam_.create_tag_on_collision = "";//bool(default yes)创建新标签来描述标签冲突
+        surfParam_.enforce_cad_edge_sizes = "";//仅当 与gradation相结合时有效
+        surfParam_.force_bad_surface_element_removal = "";//bool（default no）
+        surfParam_.geometric_size_mode = "";//(default none)
+        surfParam_.jacobian_rectification_respect_geometry = "";//default yes
+        surfParam_.manifold_geometry = "";//bool(default no)
+        surfParam_.max_number_of_points_per_patch = "";//int(default 100000)
+        surfParam_.merge_edges = "";//bool(default yes)合并小边来优化几何图形
+        surfParam_.metric = "";//(default isotropic)
+        surfParam_.optimisation = "";//bool (default yes)when "correct_surface_intersections==yes,not useful"
+        surfParam_.optimise_tiny_edges = "";//bool (default no)
         //--use mg
-        surfParam.physical_size_mode = "";//(default none)"local"、“global”
-        surfParam.physicalSizeEdgeId = "";
-        surfParam.physicalSizeFaceId = "";
-        surfParam.physicalSizePointId = "";
-        surfParam.geometric_size_mode = "";//(default none)"local"、“global”
-        surfParam.geometricSizeEdgeId = "";
-        surfParam.geometricSizeFaceId = "";
-        surfParam.geometricSizePointId = "";
+        surfParam_.physical_size_mode = "";//(default none)"local"、“global”
+        surfParam_.physicalSizeEdgeId = "";
+        surfParam_.physicalSizeFaceId = "";
+        surfParam_.physicalSizePointId = "";
+        surfParam_.geometric_size_mode = "";//(default none)"local"、“global”
+        surfParam_.geometricSizeEdgeId = "";
+        surfParam_.geometricSizeFaceId = "";
+        surfParam_.geometricSizePointId = "";
 
         //--clean
         clrParam.use_default_settings_for = "";

CAE_Solution/src/acis/rwritefile.cpp

@@ -676,22 +676,22 @@ bool CRWriteFile::ReadXmlParamFile(DPM_ADIParam &ADIParam, const char*fileName)
                     strParamTmp = m.attribute("max_size");
                     if (!strParamTmp.isEmpty())
                     {
-                        ADIParam.surfParam.max_size = strParamTmp;
+                        ADIParam.surfParam_.max_size = strParamTmp;
                     }
                     strParamTmp = m.attribute("min_size");
                     if (!strParamTmp.isEmpty())
                     {
-                        ADIParam.surfParam.min_size = strParamTmp;
+                        ADIParam.surfParam_.min_size = strParamTmp;
                     }
                     strParamTmp = m.attribute("surfStyle");
                     if (!strParamTmp.isEmpty())
                     {
-                        ADIParam.surfParam.SurfStyle = strParamTmp;
+                        ADIParam.surfParam_.SurfStyle = strParamTmp;
                     }
                     strParamTmp = m.attribute("global_physical_size");
                     if (!strParamTmp.isEmpty())
                     {
-                        ADIParam.surfParam.Global_physical_size = strParamTmp;
+                        ADIParam.surfParam_.Global_physical_size = strParamTmp;
                     }
                     ADIParam.style = 0;
                     printf("Read surfParam Ok! \n");
@@ -700,31 +700,31 @@ bool CRWriteFile::ReadXmlParamFile(DPM_ADIParam &ADIParam, const char*fileName)
                     strParamTmp = m.attribute("gradation");
                     if (!strParamTmp.isEmpty())
                     {
-                        ADIParam.surfParam.gradation = strParamTmp;
+                        ADIParam.surfParam_.gradation = strParamTmp;
                         printf("gradation set! \n");
                     }
-                    ADIParam.surfParam.anisotropic_ratio = m.attribute("anisotropic_ratio");
-                    ADIParam.surfParam.chordal_error = m.attribute("chordal_error");
-                    ADIParam.surfParam.geometric_approximation_angle = m.attribute("geometric_approximation_angle");
-                    ADIParam.surfParam.debug = m.attribute("debug");
-                    ADIParam.surfParam.closed_geometry = m.attribute("closed_geometry");
-                    ADIParam.surfParam.enforce_cad_edge_sizes = m.attribute("enforce_cad_edge_sizes");
-                    ADIParam.surfParam.force_bad_surface_element_removal = m.attribute("force_bad_surface_element_removal");
-                    ADIParam.surfParam.discard_input_topology = m.attribute("discard_input_topology");
-                    ADIParam.surfParam.create_tag_on_collision = m.attribute("create_tag_on_collision");
+                    ADIParam.surfParam_.anisotropic_ratio = m.attribute("anisotropic_ratio");
+                    ADIParam.surfParam_.chordal_error = m.attribute("chordal_error");
+                    ADIParam.surfParam_.geometric_approximation_angle = m.attribute("geometric_approximation_angle");
+                    ADIParam.surfParam_.debug = m.attribute("debug");
+                    ADIParam.surfParam_.closed_geometry = m.attribute("closed_geometry");
+                    ADIParam.surfParam_.enforce_cad_edge_sizes = m.attribute("enforce_cad_edge_sizes");
+                    ADIParam.surfParam_.force_bad_surface_element_removal = m.attribute("force_bad_surface_element_removal");
+                    ADIParam.surfParam_.discard_input_topology = m.attribute("discard_input_topology");
+                    ADIParam.surfParam_.create_tag_on_collision = m.attribute("create_tag_on_collision");
                     printf("Read surfParam1 Ok! \n");
                 }
                 else if (titleParam == "surfParam2") {
                     strParamTmp = m.attribute("element_order");
                     if (!strParamTmp.isEmpty())
                     {
-                        ADIParam.surfParam.element_order = strParamTmp;
+                        ADIParam.surfParam_.element_order = strParamTmp;
                     }
-                    ADIParam.surfParam.element_order = m.attribute("element_order");
-                    ADIParam.surfParam.remove_duplicate_cad_faces = m.attribute("remove_duplicate_cad_faces");
-                    ADIParam.surfParam.scaled_jacobian_threshold_value = m.attribute("scaled_jacobian_threshold_value");
-                    ADIParam.surfParam.optimisation = m.attribute("optimisation");
-                    ADIParam.surfParam.correct_surface_intersections = m.attribute("correct_surface_intersections");
+                    ADIParam.surfParam_.element_order = m.attribute("element_order");
+                    ADIParam.surfParam_.remove_duplicate_cad_faces = m.attribute("remove_duplicate_cad_faces");
+                    ADIParam.surfParam_.scaled_jacobian_threshold_value = m.attribute("scaled_jacobian_threshold_value");
+                    ADIParam.surfParam_.optimisation = m.attribute("optimisation");
+                    ADIParam.surfParam_.correct_surface_intersections = m.attribute("correct_surface_intersections");
                     printf("Read surfParam2 Ok! \n");
                 }
                 else if (titleParam == "mgPhysical") {//mg
@@ -739,7 +739,7 @@ bool CRWriteFile::ReadXmlParamFile(DPM_ADIParam &ADIParam, const char*fileName)
                             strParamTmp = Physical_m.attribute("physical_size_mode");
                             if (!strParamTmp.isEmpty() && strParamTmp == "local")//局部变量
                             {
-                                ADIParam.surfParam.physical_size_mode = strParamTmp;
+                                ADIParam.surfParam_.physical_size_mode = strParamTmp;
 
                                 QDomNode PhysicalNode0 = mgPhysicalList.at(kk);
                                 QDomElement Physical_m0 = PhysicalNode0.toElement();
@@ -756,23 +756,23 @@ bool CRWriteFile::ReadXmlParamFile(DPM_ADIParam &ADIParam, const char*fileName)
                                         strParamTmp = Physical_m1.attribute("face_id");
                                         if (!strParamTmp.isEmpty())
                                         {
-                                            ADIParam.surfParam.physicalSizeFaceId = strParamTmp;
+                                            ADIParam.surfParam_.physicalSizeFaceId = strParamTmp;
                                         }
                                         strParamTmp = Physical_m1.attribute("edge_id");
                                         if (!strParamTmp.isEmpty())
                                         {
-                                            ADIParam.surfParam.physicalSizeEdgeId = strParamTmp;
+                                            ADIParam.surfParam_.physicalSizeEdgeId = strParamTmp;
                                         }
                                         strParamTmp = Physical_m1.attribute("point_id");
                                         if (!strParamTmp.isEmpty())
                                         {
-                                            ADIParam.surfParam.physicalSizePointId = strParamTmp;
+                                            ADIParam.surfParam_.physicalSizePointId = strParamTmp;
                                         }
                                     }
                                 }
                             }
                             else if (!strParamTmp.isEmpty()) {
-                                ADIParam.surfParam.physical_size_mode = strParamTmp;
+                                ADIParam.surfParam_.physical_size_mode = strParamTmp;
                                 break;
                             }
                         }
@@ -780,17 +780,17 @@ bool CRWriteFile::ReadXmlParamFile(DPM_ADIParam &ADIParam, const char*fileName)
                             strParamTmp = Physical_m.attribute("face_id");
                             if (!strParamTmp.isEmpty())
                             {
-                                ADIParam.surfParam.physicalSizeFaceId = strParamTmp;
+                                ADIParam.surfParam_.physicalSizeFaceId = strParamTmp;
                             }
                             strParamTmp = Physical_m.attribute("edge_id");
                             if (!strParamTmp.isEmpty())
                             {
-                                ADIParam.surfParam.physicalSizeEdgeId = strParamTmp;
+                                ADIParam.surfParam_.physicalSizeEdgeId = strParamTmp;
                             }
                             strParamTmp = Physical_m.attribute("point_id");
                             if (!strParamTmp.isEmpty())
                             {
-                                ADIParam.surfParam.physicalSizePointId = strParamTmp;
+                                ADIParam.surfParam_.physicalSizePointId = strParamTmp;
                             }
                         }
                     }
@@ -808,7 +808,7 @@ bool CRWriteFile::ReadXmlParamFile(DPM_ADIParam &ADIParam, const char*fileName)
                             strParamTmp = Physical_m.attribute("geometric_size_mode");
                             if (!strParamTmp.isEmpty() && strParamTmp == "local")//局部变量
                             {
-                                ADIParam.surfParam.geometric_size_mode = strParamTmp;
+                                ADIParam.surfParam_.geometric_size_mode = strParamTmp;
 
                                 QDomNode PhysicalNode0 = mgPhysicalList.at(kk);
                                 QDomElement Physical_m0 = PhysicalNode0.toElement();
@@ -825,23 +825,23 @@ bool CRWriteFile::ReadXmlParamFile(DPM_ADIParam &ADIParam, const char*fileName)
                                         strParamTmp = Physical_m1.attribute("face_id");
                                         if (!strParamTmp.isEmpty())
                                         {
-                                            ADIParam.surfParam.geometricSizeFaceId = strParamTmp;
+                                            ADIParam.surfParam_.geometricSizeFaceId = strParamTmp;
                                         }
                                         strParamTmp = Physical_m1.attribute("edge_id");
                                         if (!strParamTmp.isEmpty())
                                         {
-                                            ADIParam.surfParam.geometricSizeEdgeId = strParamTmp;
+                                            ADIParam.surfParam_.geometricSizeEdgeId = strParamTmp;
                                         }
                                         strParamTmp = Physical_m1.attribute("point_id");
                                         if (!strParamTmp.isEmpty())
                                         {
-                                            ADIParam.surfParam.geometricSizePointId = strParamTmp;
+                                            ADIParam.surfParam_.geometricSizePointId = strParamTmp;
                                         }
                                     }
                                 }
                             }
                             else if (!strParamTmp.isEmpty()) {
-                                ADIParam.surfParam.geometric_size_mode = strParamTmp;
+                                ADIParam.surfParam_.geometric_size_mode = strParamTmp;
                                 break;
                             }
                         }
@@ -849,17 +849,17 @@ bool CRWriteFile::ReadXmlParamFile(DPM_ADIParam &ADIParam, const char*fileName)
                             strParamTmp = Physical_m.attribute("face_id");
                             if (!strParamTmp.isEmpty())
                             {
-                                ADIParam.surfParam.physicalSizeFaceId = strParamTmp;
+                                ADIParam.surfParam_.physicalSizeFaceId = strParamTmp;
                             }
                             strParamTmp = Physical_m.attribute("edge_id");
                             if (!strParamTmp.isEmpty())
                             {
-                                ADIParam.surfParam.physicalSizeEdgeId = strParamTmp;
+                                ADIParam.surfParam_.physicalSizeEdgeId = strParamTmp;
                             }
                             strParamTmp = Physical_m.attribute("point_id");
                             if (!strParamTmp.isEmpty())
                             {
-                                ADIParam.surfParam.physicalSizePointId = strParamTmp;
+                                ADIParam.surfParam_.physicalSizePointId = strParamTmp;
                             }
                         }
                     }
@@ -980,62 +980,62 @@ bool CRWriteFile::ReadXmlParam(DPM_ADIParam &ADIParam, boostJsonObject *object)
     if(!object->da_struct->strResultFormat.empty())
         ADIParam.strResultFormat = QString::fromStdString(object->da_struct->strResultFormat);
     if(object->da_struct->surfParam0){
-        ADIParam.surfParam.max_size = QString::fromStdString(object->da_struct->surfParam->max_size);
-        ADIParam.surfParam.min_size = QString::fromStdString(object->da_struct->surfParam->min_size);
-        ADIParam.surfParam.SurfStyle = QString::fromStdString(object->da_struct->surfParam->SurfStyle);
-        ADIParam.surfParam.Global_physical_size = QString::fromStdString(object->da_struct->surfParam->Global_physical_size);
+        ADIParam.surfParam_.max_size = QString::fromStdString(object->da_struct->surfParam->max_size);
+        ADIParam.surfParam_.min_size = QString::fromStdString(object->da_struct->surfParam->min_size);
+        ADIParam.surfParam_.SurfStyle = QString::fromStdString(object->da_struct->surfParam->SurfStyle);
+        ADIParam.surfParam_.Global_physical_size = QString::fromStdString(object->da_struct->surfParam->Global_physical_size);
     }
     //surfparam1
     if(object->da_struct->surfParam1){
-        ADIParam.surfParam.gradation = QString::fromStdString(object->da_struct->surfParam->gradation);
-        ADIParam.surfParam.anisotropic_ratio = QString::fromStdString(object->da_struct->surfParam->anisotropic_ratio);
-        ADIParam.surfParam.chordal_error = QString::fromStdString(object->da_struct->surfParam->chordal_error);
-        ADIParam.surfParam.geometric_approximation_angle = QString::fromStdString(object->da_struct->surfParam->geometric_approximation_angle);
-        ADIParam.surfParam.debug = QString::fromStdString(object->da_struct->surfParam->Debug);
-        ADIParam.surfParam.closed_geometry = QString::fromStdString(object->da_struct->surfParam->closed_geometry);
-        ADIParam.surfParam.enforce_cad_edge_sizes = QString::fromStdString(object->da_struct->surfParam->enforce_cad_edge_sizes);
-        ADIParam.surfParam.force_bad_surface_element_removal = QString::fromStdString(object->da_struct->surfParam->force_bad_surface_element_removal);
-        ADIParam.surfParam.discard_input_topology = QString::fromStdString(object->da_struct->surfParam->discard_input_topology);
-        ADIParam.surfParam.create_tag_on_collision = QString::fromStdString(object->da_struct->surfParam->create_tag_on_collision);
+        ADIParam.surfParam_.gradation = QString::fromStdString(object->da_struct->surfParam->gradation);
+        ADIParam.surfParam_.anisotropic_ratio = QString::fromStdString(object->da_struct->surfParam->anisotropic_ratio);
+        ADIParam.surfParam_.chordal_error = QString::fromStdString(object->da_struct->surfParam->chordal_error);
+        ADIParam.surfParam_.geometric_approximation_angle = QString::fromStdString(object->da_struct->surfParam->geometric_approximation_angle);
+        ADIParam.surfParam_.debug = QString::fromStdString(object->da_struct->surfParam->Debug);
+        ADIParam.surfParam_.closed_geometry = QString::fromStdString(object->da_struct->surfParam->closed_geometry);
+        ADIParam.surfParam_.enforce_cad_edge_sizes = QString::fromStdString(object->da_struct->surfParam->enforce_cad_edge_sizes);
+        ADIParam.surfParam_.force_bad_surface_element_removal = QString::fromStdString(object->da_struct->surfParam->force_bad_surface_element_removal);
+        ADIParam.surfParam_.discard_input_topology = QString::fromStdString(object->da_struct->surfParam->discard_input_topology);
+        ADIParam.surfParam_.create_tag_on_collision = QString::fromStdString(object->da_struct->surfParam->create_tag_on_collision);
     }
     //surfparam2
     if(object->da_struct->surfParam2){
-        ADIParam.surfParam.element_order = QString::fromStdString(object->da_struct->surfParam->element_order);
-        ADIParam.surfParam.remove_duplicate_cad_faces = QString::fromStdString(object->da_struct->surfParam->remove_duplicate_cad_faces);
-        ADIParam.surfParam.scaled_jacobian_threshold_value = QString::fromStdString(object->da_struct->surfParam->scaled_jacobian_threshold_value);
-        ADIParam.surfParam.optimisation = QString::fromStdString(object->da_struct->surfParam->optimisation);
-        ADIParam.surfParam.correct_surface_intersections = QString::fromStdString(object->da_struct->surfParam->correct_surface_intersections);
+        ADIParam.surfParam_.element_order = QString::fromStdString(object->da_struct->surfParam->element_order);
+        ADIParam.surfParam_.remove_duplicate_cad_faces = QString::fromStdString(object->da_struct->surfParam->remove_duplicate_cad_faces);
+        ADIParam.surfParam_.scaled_jacobian_threshold_value = QString::fromStdString(object->da_struct->surfParam->scaled_jacobian_threshold_value);
+        ADIParam.surfParam_.optimisation = QString::fromStdString(object->da_struct->surfParam->optimisation);
+        ADIParam.surfParam_.correct_surface_intersections = QString::fromStdString(object->da_struct->surfParam->correct_surface_intersections);
     }
 #if 0
     //mgPhysical
     if(object->da_struct->mgPhysical_){
         if(object->da_struct->mgPhysical_type == "physical"){
-            ADIParam.surfParam.physical_size_mode = QString::fromStdString(object->da_struct->surfParam->physical_size_mode);
-            if(ADIParam.surfParam.physical_size_mode == "local"){
-                ADIParam.surfParam.physicalSizeFaceId = QString::fromStdString(object->da_struct->surfParam->physicalSizeFaceId);
-                ADIParam.surfParam.physicalSizeEdgeId = QString::fromStdString(object->da_struct->surfParam->physicalSizeEdgeId);
-                ADIParam.surfParam.physicalSizePointId = QString::fromStdString(object->da_struct->surfParam->physicalSizePointId);
+            ADIParam.surfParam_.physical_size_mode = QString::fromStdString(object->da_struct->surfParam->physical_size_mode);
+            if(ADIParam.surfParam_.physical_size_mode == "local"){
+                ADIParam.surfParam_.physicalSizeFaceId = QString::fromStdString(object->da_struct->surfParam->physicalSizeFaceId);
+                ADIParam.surfParam_.physicalSizeEdgeId = QString::fromStdString(object->da_struct->surfParam->physicalSizeEdgeId);
+                ADIParam.surfParam_.physicalSizePointId = QString::fromStdString(object->da_struct->surfParam->physicalSizePointId);
             }
         }else if(object->da_struct->mgPhysical_type == "param"){
-            ADIParam.surfParam.physicalSizeFaceId = QString::fromStdString(object->da_struct->surfParam->physicalSizeFaceId);
-            ADIParam.surfParam.physicalSizeEdgeId = QString::fromStdString(object->da_struct->surfParam->physicalSizeEdgeId);
-            ADIParam.surfParam.physicalSizePointId = QString::fromStdString(object->da_struct->surfParam->physicalSizePointId);
+            ADIParam.surfParam_.physicalSizeFaceId = QString::fromStdString(object->da_struct->surfParam->physicalSizeFaceId);
+            ADIParam.surfParam_.physicalSizeEdgeId = QString::fromStdString(object->da_struct->surfParam->physicalSizeEdgeId);
+            ADIParam.surfParam_.physicalSizePointId = QString::fromStdString(object->da_struct->surfParam->physicalSizePointId);
         }
     }
     //mgGeometry
     if(object->da_struct->mgGeometry_){
         if(object->da_struct->mgGeometry_type == "Geometry"){
-            ADIParam.surfParam.geometric_size_mode = QString::fromStdString(object->da_struct->surfParam->geometric_size_mode);
-            if(ADIParam.surfParam.geometric_size_mode == "local"){
-                ADIParam.surfParam.geometricSizeFaceId = QString::fromStdString(object->da_struct->surfParam->geometricSizeFaceId);
-                ADIParam.surfParam.geometricSizeEdgeId = QString::fromStdString(object->da_struct->surfParam->geometricSizeEdgeId);
-                ADIParam.surfParam.geometricSizePointId = QString::fromStdString(object->da_struct->surfParam->geometricSizePointId);
+            ADIParam.surfParam_.geometric_size_mode = QString::fromStdString(object->da_struct->surfParam->geometric_size_mode);
+            if(ADIParam.surfParam_.geometric_size_mode == "local"){
+                ADIParam.surfParam_.geometricSizeFaceId = QString::fromStdString(object->da_struct->surfParam->geometricSizeFaceId);
+                ADIParam.surfParam_.geometricSizeEdgeId = QString::fromStdString(object->da_struct->surfParam->geometricSizeEdgeId);
+                ADIParam.surfParam_.geometricSizePointId = QString::fromStdString(object->da_struct->surfParam->geometricSizePointId);
             }
         }else if(object->da_struct->mgGeometry_type == "param")
         {
-            ADIParam.surfParam.physicalSizeFaceId = QString::fromStdString(object->da_struct->surfParam->physicalSizeFaceId);
-            ADIParam.surfParam.physicalSizeEdgeId = QString::fromStdString(object->da_struct->surfParam->physicalSizeEdgeId);
-            ADIParam.surfParam.physicalSizePointId = QString::fromStdString(object->da_struct->surfParam->physicalSizePointId);
+            ADIParam.surfParam_.physicalSizeFaceId = QString::fromStdString(object->da_struct->surfParam->physicalSizeFaceId);
+            ADIParam.surfParam_.physicalSizeEdgeId = QString::fromStdString(object->da_struct->surfParam->physicalSizeEdgeId);
+            ADIParam.surfParam_.physicalSizePointId = QString::fromStdString(object->da_struct->surfParam->physicalSizePointId);
         }
     }
 #endif