add icfd model:mesh adaptivity

Author: zhangzhanqun

examples/ICFD/icfd_mesh_adaptivity.py

@@ -0,0 +1,84 @@
+"""
+Mesh Adaptivity
+===============
+
+This example shows a simple ICFD problem with adaptivity.
+"""
+
+import os
+import sys
+
+
+from ansys.dyna.core.pre.dynasolution import DynaSolution
+from ansys.dyna.core.pre.dynaicfd import (
+    DynaICFD,
+    MatICFD,
+    ICFDPart,
+    ICFDDOF,
+    Curve,
+    ICFDVolumePart,
+    MeshedVolume,
+    ICFDAnalysis
+)
+from ansys.dyna.core.pre import examples
+
+
+hostname = "localhost"
+if len(sys.argv) > 1:
+    hostname = sys.argv[1]
+
+solution = DynaSolution(hostname)
+# Import the initial mesh data(nodes and elements)
+fns = []
+path = examples.mesh_adaptivity + os.sep
+fns.append(path + "mesh_adaptivity.k")
+solution.open_files(fns)
+solution.set_termination(termination_time=40)
+icfd = DynaICFD()
+solution.add(icfd)
+
+icfdanalysis = ICFDAnalysis()
+icfdanalysis.set_timestep()
+icfdanalysis.set_mesh_adaptivity(min_mesh_size=0.02,max_mesh_size=0.2,max_perceptual_error=2,num_iteration=10)
+icfd.add(icfdanalysis)
+
+# define model
+mat = MatICFD(flow_density=1.0, dynamic_viscosity=0.005)
+
+part_inflow = ICFDPart(1)
+part_inflow.set_material(mat)
+part_inflow.set_prescribed_velocity(dof=ICFDDOF.X, motion=Curve(x=[0, 10000], y=[1, 1]))
+part_inflow.set_prescribed_velocity(dof=ICFDDOF.Y, motion=Curve(x=[0, 10000], y=[0, 0]))
+icfd.parts.add(part_inflow)
+
+part_outflow = ICFDPart(2)
+part_outflow.set_material(mat)
+part_outflow.set_prescribed_pressure(pressure=Curve(x=[0, 10000], y=[0, 0]))
+icfd.parts.add(part_outflow)
+
+part_symmetric = ICFDPart(3)
+part_symmetric.set_material(mat)
+part_symmetric.set_free_slip()
+icfd.parts.add(part_symmetric)
+
+part_wall = ICFDPart(4)
+part_wall.set_material(mat)
+part_wall.set_non_slip()
+part_wall.compute_drag_force()
+part_wall.set_boundary_layer(number=2)
+icfd.parts.add(part_wall)
+
+part_meshsize = ICFDPart(5)
+part_meshsize.set_material(mat)
+icfd.parts.add(part_meshsize)
+
+partvol = ICFDVolumePart(surfaces=[1, 2, 3, 4])
+partvol.set_material(mat)
+icfd.parts.add(partvol)
+# define the volume space that will be meshed,The boundaries
+# of the volume are the surfaces "spids"
+meshvol = MeshedVolume(surfaces=[1, 2, 3, 4])
+icfd.add(meshvol)
+
+solution.create_database_binary(dt=0.5)
+solution.save_file()

src/ansys/dyna/core/pre/Server/kwprocess_pb2.py

@@ -514,6 +514,11 @@ def __init__(self, channel):
                 request_serializer=kwprocess__pb2.ICFDControlMeshRequest.SerializeToString,
                 response_deserializer=kwprocess__pb2.ICFDControlMeshReply.FromString,
                 )
+        self.ICFDCreateControlAdapt = channel.unary_unary(
+                '/kwgrpc.kwC2S/ICFDCreateControlAdapt',
+                request_serializer=kwprocess__pb2.ICFDControlAdaptRequest.SerializeToString,
+                response_deserializer=kwprocess__pb2.ICFDControlAdaptReply.FromString,
+                )
         self.ICFDCreateControlSurfMesh = channel.unary_unary(
                 '/kwgrpc.kwC2S/ICFDCreateControlSurfMesh',
                 request_serializer=kwprocess__pb2.ICFDControlSurfMeshRequest.SerializeToString,
@@ -1398,6 +1403,12 @@ def ICFDCreateControlMesh(self, request, context):
         context.set_details('Method not implemented!')
         raise NotImplementedError('Method not implemented!')
 
+    def ICFDCreateControlAdapt(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
     def ICFDCreateControlSurfMesh(self, request, context):
         """Missing associated documentation comment in .proto file."""
         context.set_code(grpc.StatusCode.UNIMPLEMENTED)
@@ -2225,6 +2236,11 @@ def add_kwC2SServicer_to_server(servicer, server):
                     request_deserializer=kwprocess__pb2.ICFDControlMeshRequest.FromString,
                     response_serializer=kwprocess__pb2.ICFDControlMeshReply.SerializeToString,
             ),
+            'ICFDCreateControlAdapt': grpc.unary_unary_rpc_method_handler(
+                    servicer.ICFDCreateControlAdapt,
+                    request_deserializer=kwprocess__pb2.ICFDControlAdaptRequest.FromString,
+                    response_serializer=kwprocess__pb2.ICFDControlAdaptReply.SerializeToString,
+            ),
             'ICFDCreateControlSurfMesh': grpc.unary_unary_rpc_method_handler(
                     servicer.ICFDCreateControlSurfMesh,
                     request_deserializer=kwprocess__pb2.ICFDControlSurfMeshRequest.FromString,
@@ -4200,6 +4216,23 @@ def ICFDCreateControlMesh(request,
             options, channel_credentials,
             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
+    @staticmethod
+    def ICFDCreateControlAdapt(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/kwgrpc.kwC2S/ICFDCreateControlAdapt',
+            kwprocess__pb2.ICFDControlAdaptRequest.SerializeToString,
+            kwprocess__pb2.ICFDControlAdaptReply.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
     @staticmethod
     def ICFDCreateControlSurfMesh(request,
             target,

src/ansys/dyna/core/pre/Server/kwprocess_pb2_grpc.py

@@ -2096,6 +2096,18 @@ def ICFDCreateControlMesh(self, request, context):
         print(msg)
         return kwprocess_pb2.ICFDControlMeshReply(answer=0)
 
+    def ICFDCreateControlAdapt(self, request, context):
+        minh = request.minh
+        maxh = request.maxh
+        err = request.err
+        nit = request.nit
+        card1 = str(minh) + "," + str(maxh) + "," + str(err) + ",0," + str(nit)
+        newk = "*ICFD_CONTROL_ADAPT\n" + card1
+        self.kwdproc.newkeyword(newk)
+        msg = "ICFD_CONTROL_ADAPT Created..."
+        print(msg)
+        return kwprocess_pb2.ICFDControlAdaptReply(answer=0)
+
     def ICFDCreateControlSurfMesh(self, request, context):
         rsrf = request.rsrf
         card1 = str(rsrf)

src/ansys/dyna/core/pre/Server/kwserver.py

@@ -224,6 +224,7 @@ def __init__(self):
         self.defined_output = False
         self.defined_steady_state = False
         self.defined_coupling_dem = False
+        self.defined_mesh_adapt = False
         self.stub = DynaBase.get_stub()
 
     def set_type(self, analysis_type=ICFD_AnalysisType.TRANSIENT_ANALYSIS):
@@ -307,6 +308,26 @@ def set_volume_mesh(self, mesh_growth_scale_factor=1.41):
         self.defined_volumemesh = True
         self.mgsf = mesh_growth_scale_factor
 
+    def set_mesh_adaptivity(self, min_mesh_size=0, max_mesh_size=0, max_perceptual_error=0, num_iteration=0):
+        """Activate the adaptive mesh refinement feature..
+
+        Parameters
+        ----------
+        min_mesh_size : float
+            Minimum mesh size allowed to the mesh generator.
+        max_mesh_size : float
+            Maximum mesh size.
+        max_perceptual_error : float
+            Maximum perceptual error allowed in the whole domain.
+        num_iteration : int
+            Number of iterations before a forced remeshing.
+        """
+        self.defined_mesh_adapt = True
+        self.minh = min_mesh_size
+        self.maxh = max_mesh_size
+        self.err = max_perceptual_error
+        self.nit = num_iteration
+
     def set_surface_mesh(self, remesh_method=ICFD_SurfRemeshMethod.LAPLACIAN_SMOOTHING):
         """Enable automatic surface re-meshing.
 
@@ -370,6 +391,10 @@ def create(self):
             self.stub.ICFDCreateControlDEMCoupling(
                 ICFDControlDEMCouplingRequest(ctype=self.ctype, bt=self.bt, dt=self.dt, sf=self.sf, form=self.form)
             )
+        if self.defined_mesh_adapt:
+            self.stub.ICFDCreateControlAdapt(
+                ICFDControlAdaptRequest(minh=self.minh, maxh=self.maxh, err=self.err, nit=self.nit)
+            )
 
 
 class Compressible(Enum):

src/ansys/dyna/core/pre/dynaicfd.py

@@ -26,6 +26,7 @@
 weak_fsi = os.path.join(_module_path, "icfd", "weak_fsi")
 strong_fsi = os.path.join(_module_path, "icfd", "strong_fsi")
 imposed_move = os.path.join(_module_path, "icfd", "imposed_move")
+mesh_adaptivity = os.path.join(_module_path, "icfd", "mesh_adaptivity")
 dem_coupling = os.path.join(_module_path, "icfd", "dem_coupling")
 
 iga_sample = os.path.join(_module_path, "iga", "iga_sample")