add icfd model:driven cavity

Author: zhangzhanqun

examples/ICFD/icfd_driven_cavity.py

@@ -0,0 +1,69 @@
+"""
+Driven cavity
+=============
+
+This example shows the universally famous driven cavity case tested with the second order steady solver and for Re=1000.
+"""
+
+import os
+import sys
+
+
+from ansys.dyna.core.pre.dynasolution import DynaSolution
+from ansys.dyna.core.pre.dynaicfd import (
+    DynaICFD,
+    MatICFD,
+    ICFDPart,
+    Curve,
+    ICFDVolumePart,
+    MeshedVolume,
+    ICFDAnalysis,
+    ICFD_AnalysisType,
+    ICFD_MessageLevel,
+    ICFDDOF
+)
+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.driven_cavity + os.sep
+fns.append(path + "driven_cavity.k")
+solution.open_files(fns)
+icfd = DynaICFD()
+solution.add(icfd)
+
+icfdanalysis = ICFDAnalysis()
+icfdanalysis.set_type(analysis_type=ICFD_AnalysisType.STEADY_STATE_ANALYSIS)
+icfdanalysis.set_output(messagelevel=ICFD_MessageLevel.FULL_OUTPUT_INFORMATION,iteration_interval=250)
+icfdanalysis.set_steady_state(max_iteration=2500,momentum_tol_limit=1e-8,pressure_tol_limit=1e-8,velocity_relax_param=1,pressure_relax_param=1)
+icfd.add(icfdanalysis)
+
+# define model
+mat = MatICFD(flow_density=1, dynamic_viscosity=0.001)
+
+part1 = ICFDPart(1)
+part1.set_material(mat)
+part1.set_prescribed_velocity(dof=ICFDDOF.X, motion=Curve(x=[0, 10000], y=[1, 1]))
+icfd.parts.add(part1)
+
+part2 = ICFDPart(2)
+part2.set_material(mat)
+part2.set_non_slip()
+icfd.parts.add(part2)
+
+partvol = ICFDVolumePart(surfaces=[1, 2])
+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])
+icfd.add(meshvol)
+
+solution.create_database_binary(dt=250)
+solution.save_file()

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

@@ -479,6 +479,16 @@ def __init__(self, channel):
                 request_serializer=kwprocess__pb2.ICFDControlOutputRequest.SerializeToString,
                 response_deserializer=kwprocess__pb2.ICFDControlOutputReply.FromString,
                 )
+        self.ICFDCreateControlSteady = channel.unary_unary(
+                '/kwgrpc.kwC2S/ICFDCreateControlSteady',
+                request_serializer=kwprocess__pb2.ICFDControlSteadyRequest.SerializeToString,
+                response_deserializer=kwprocess__pb2.ICFDControlSteadyReply.FromString,
+                )
+        self.ICFDCreateControlFSI = channel.unary_unary(
+                '/kwgrpc.kwC2S/ICFDCreateControlFSI',
+                request_serializer=kwprocess__pb2.ICFDControlFSIRequest.SerializeToString,
+                response_deserializer=kwprocess__pb2.ICFDControlFSIReply.FromString,
+                )
         self.ICFDCreateControlTurbulence = channel.unary_unary(
                 '/kwgrpc.kwC2S/ICFDCreateControlTurbulence',
                 request_serializer=kwprocess__pb2.ICFDControlTurbulenceRequest.SerializeToString,
@@ -559,6 +569,11 @@ def __init__(self, channel):
                 request_serializer=kwprocess__pb2.ICFDBdyNonSlipRequest.SerializeToString,
                 response_deserializer=kwprocess__pb2.ICFDBdyNonSlipReply.FromString,
                 )
+        self.ICFDCreateBdyFSI = channel.unary_unary(
+                '/kwgrpc.kwC2S/ICFDCreateBdyFSI',
+                request_serializer=kwprocess__pb2.ICFDBdyFSIRequest.SerializeToString,
+                response_deserializer=kwprocess__pb2.ICFDBdyFSIReply.FromString,
+                )
         self.ICFDCreateInit = channel.unary_unary(
                 '/kwgrpc.kwC2S/ICFDCreateInit',
                 request_serializer=kwprocess__pb2.ICFDInitRequest.SerializeToString,
@@ -1326,6 +1341,18 @@ def ICFDCreateControlOutput(self, request, context):
         context.set_details('Method not implemented!')
         raise NotImplementedError('Method not implemented!')
 
+    def ICFDCreateControlSteady(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 ICFDCreateControlFSI(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 ICFDCreateControlTurbulence(self, request, context):
         """Missing associated documentation comment in .proto file."""
         context.set_code(grpc.StatusCode.UNIMPLEMENTED)
@@ -1422,6 +1449,12 @@ def ICFDCreateBdyNonSlip(self, request, context):
         context.set_details('Method not implemented!')
         raise NotImplementedError('Method not implemented!')
 
+    def ICFDCreateBdyFSI(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 ICFDCreateInit(self, request, context):
         """Missing associated documentation comment in .proto file."""
         context.set_code(grpc.StatusCode.UNIMPLEMENTED)
@@ -2124,6 +2157,16 @@ def add_kwC2SServicer_to_server(servicer, server):
                     request_deserializer=kwprocess__pb2.ICFDControlOutputRequest.FromString,
                     response_serializer=kwprocess__pb2.ICFDControlOutputReply.SerializeToString,
             ),
+            'ICFDCreateControlSteady': grpc.unary_unary_rpc_method_handler(
+                    servicer.ICFDCreateControlSteady,
+                    request_deserializer=kwprocess__pb2.ICFDControlSteadyRequest.FromString,
+                    response_serializer=kwprocess__pb2.ICFDControlSteadyReply.SerializeToString,
+            ),
+            'ICFDCreateControlFSI': grpc.unary_unary_rpc_method_handler(
+                    servicer.ICFDCreateControlFSI,
+                    request_deserializer=kwprocess__pb2.ICFDControlFSIRequest.FromString,
+                    response_serializer=kwprocess__pb2.ICFDControlFSIReply.SerializeToString,
+            ),
             'ICFDCreateControlTurbulence': grpc.unary_unary_rpc_method_handler(
                     servicer.ICFDCreateControlTurbulence,
                     request_deserializer=kwprocess__pb2.ICFDControlTurbulenceRequest.FromString,
@@ -2204,6 +2247,11 @@ def add_kwC2SServicer_to_server(servicer, server):
                     request_deserializer=kwprocess__pb2.ICFDBdyNonSlipRequest.FromString,
                     response_serializer=kwprocess__pb2.ICFDBdyNonSlipReply.SerializeToString,
             ),
+            'ICFDCreateBdyFSI': grpc.unary_unary_rpc_method_handler(
+                    servicer.ICFDCreateBdyFSI,
+                    request_deserializer=kwprocess__pb2.ICFDBdyFSIRequest.FromString,
+                    response_serializer=kwprocess__pb2.ICFDBdyFSIReply.SerializeToString,
+            ),
             'ICFDCreateInit': grpc.unary_unary_rpc_method_handler(
                     servicer.ICFDCreateInit,
                     request_deserializer=kwprocess__pb2.ICFDInitRequest.FromString,
@@ -3985,6 +4033,40 @@ def ICFDCreateControlOutput(request,
             options, channel_credentials,
             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
+    @staticmethod
+    def ICFDCreateControlSteady(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/ICFDCreateControlSteady',
+            kwprocess__pb2.ICFDControlSteadyRequest.SerializeToString,
+            kwprocess__pb2.ICFDControlSteadyReply.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def ICFDCreateControlFSI(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/ICFDCreateControlFSI',
+            kwprocess__pb2.ICFDControlFSIRequest.SerializeToString,
+            kwprocess__pb2.ICFDControlFSIReply.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
     @staticmethod
     def ICFDCreateControlTurbulence(request,
             target,
@@ -4257,6 +4339,23 @@ def ICFDCreateBdyNonSlip(request,
             options, channel_credentials,
             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
+    @staticmethod
+    def ICFDCreateBdyFSI(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/ICFDCreateBdyFSI',
+            kwprocess__pb2.ICFDBdyFSIRequest.SerializeToString,
+            kwprocess__pb2.ICFDBdyFSIReply.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
     @staticmethod
     def ICFDCreateInit(request,
             target,

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

@@ -2009,13 +2009,37 @@ def ICFDCreateControlGeneral(self, request, context):
 
     def ICFDCreateControlOutput(self, request, context):
         msgl = request.msgl
-        card1 = str(msgl)
+        itout = request.itout
+        card1 = str(msgl) + ",0,0,0,," + str(itout)
         newk = "*ICFD_CONTROL_OUTPUT\n" + card1
         self.kwdproc.newkeyword(newk)
         msg = "ICFD Control Output Created..."
         print(msg)
         return kwprocess_pb2.ICFDControlOutputReply(answer=0)
 
+    def ICFDCreateControlSteady(self, request, context):
+        its = request.its
+        tol1 = request.tol1
+        tol2 = request.tol2
+        tol3 = request.tol3
+        rel1 = request.rel1
+        rel2 = request.rel2
+        card1 = str(its) + "," + str(tol1) + "," + str(tol2) + "," + str(tol3) + "," + str(rel1) + "," + str(rel2) + ",1.0"
+        newk = "*ICFD_CONTROL_STEADY\n" + card1
+        self.kwdproc.newkeyword(newk)
+        msg = "ICFD Control Steady Created..."
+        print(msg)
+        return kwprocess_pb2.ICFDControlSteadyReply(answer=0)
+
+    def ICFDCreateControlFSI(self, request, context):
+        owc = request.owc
+        card1 = str(owc)
+        newk = "*ICFD_CONTROL_FSI\n" + card1
+        self.kwdproc.newkeyword(newk)
+        msg = "ICFD Control FSI Created..."
+        print(msg)
+        return kwprocess_pb2.ICFDControlFSIReply(answer=0)
+
     def ICFDCreateControlTurbulence(self, request, context):
         tmod = request.tmod
         card1 = str(tmod)
@@ -2204,6 +2228,15 @@ def ICFDCreateBdyNonSlip(self, request, context):
         print(msg)
         return kwprocess_pb2.ICFDBdyNonSlipReply(answer=0)
 
+    def ICFDCreateBdyFSI(self, request, context):
+        pid = request.pid
+        card1 = str(pid)
+        newk = "*ICFD_BOUNDARY_FSI\n" + card1
+        self.kwdproc.newkeyword(newk)
+        msg = "ICFD boundary FSI " + str(pid) + " Created..."
+        print(msg)
+        return kwprocess_pb2.ICFDBdyFSIReply(answer=0)
+
     def ICFDCreateInit(self, request, context):
         pid = request.pid
         vx = request.vx

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

@@ -207,15 +207,88 @@ class ICFD_SurfRemeshMethod(Enum):
     CURVATURE_PRESERVING = 2
 
 
+class ICFD_AnalysisType(Enum):
+    TURNOFF_ICFD_SOLVER = -1
+    TRANSIENT_ANALYSIS = 0
+    STEADY_STATE_ANALYSIS = 1
+
+
+class ICFD_MessageLevel(Enum):
+    TIMESTEP_INFORMATION = 0
+    FULL_OUTPUT_INFORMATION = 4
+
+
 class ICFDAnalysis:
     """Activate ICFD analysis and define associated control parameters."""
 
     def __init__(self):
         self.defined_timestep = False
         self.defined_volumemesh = False
         self.defined_surfmesh = False
+        self.defined_type = False
+        self.defined_output = False
+        self.defined_steady_state = False
         self.stub = DynaBase.get_stub()
 
+    def set_type(self, analysis_type=ICFD_AnalysisType.TRANSIENT_ANALYSIS):
+        """Specify the type of CFD analysis.
+
+        Parameters
+        ----------
+        analysis_type : ICFD_AnalysisType
+            Analysis type.
+        """
+        self.defined_type = True
+        self.atype = analysis_type.value
+
+    def set_output(self, messagelevel=ICFD_MessageLevel.TIMESTEP_INFORMATION, iteration_interval=0):
+        """Modify default values for screen and file outputs related to this fluid solver only.
+
+        Parameters
+        ----------
+        messagelevel : ICFD_MessageLevel
+            Message level.
+        iteration_interval : int
+            Iteration interval to print the output.
+        """
+        self.defined_output = True
+        self.msgl = messagelevel.value
+        self.itout = iteration_interval
+
+    def set_steady_state(
+        self,
+        max_iteration=1e6,
+        momentum_tol_limit=1e-3,
+        pressure_tol_limit=1e-3,
+        temperature_tol_limit=1e-3,
+        velocity_relax_param=0.3,
+        pressure_relax_param=0.7,
+    ):
+        """Specify convergence options for the steady state solver.
+
+        Parameters
+        ----------
+        max_iteration : int
+            Maximum number of iterations to reach convergence.
+        momentum_tol_limit : float
+            Tolerance limits for the momentum equations.
+        pressure_tol_limit : float
+            Tolerance limits for the pressure equations.
+        temperature_tol_limit : float
+            Tolerance limits for the temperature equations.
+        velocity_relax_param : float
+            Relaxation parameters for the velocity.
+        pressure_relax_param : float
+            Relaxation parameters for the pressure.
+        """
+        self.defined_steady_state = True
+        self.its = max_iteration
+        self.tol1 = momentum_tol_limit
+        self.tol2 = pressure_tol_limit
+        self.tol3 = temperature_tol_limit
+        self.rel1 = velocity_relax_param
+        self.rel2 = pressure_relax_param
+
     def set_timestep(self, timestep=0):
         """Set time step for the fluid problem.
 
@@ -257,6 +330,16 @@ def create(self):
             self.stub.ICFDCreateControlMesh(ICFDControlMeshRequest(mgsf=self.mgsf))
         if self.defined_surfmesh:
             self.stub.ICFDCreateControlSurfMesh(ICFDControlSurfMeshRequest(rsrf=self.rsrf))
+        if self.defined_type:
+            self.stub.ICFDCreateControlGeneral(ICFDControlGeneralRequest(atype=self.atype, mtype=0, dvcl=0, rdvcl=0))
+        if self.defined_output:
+            self.stub.ICFDCreateControlOutput(ICFDControlOutputRequest(msgl=self.msgl, itout=self.itout))
+        if self.defined_steady_state:
+            self.stub.ICFDCreateControlSteady(
+                ICFDControlSteadyRequest(
+                    its=self.its, tol1=self.tol1, tol2=self.tol2, tol3=self.tol3, rel1=self.rel1, rel2=self.rel2
+                )
+            )
 
 
 class Compressible(Enum):

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

@@ -23,6 +23,7 @@
 thermal_flow = os.path.join(_module_path, "icfd", "thermal_flow")
 free_convection_flow = os.path.join(_module_path, "icfd", "free_convection_flow")
 dam_break = os.path.join(_module_path, "icfd", "dam_break")
+driven_cavity = os.path.join(_module_path, "icfd", "driven_cavity")
 
 iga_sample = os.path.join(_module_path, "iga", "iga_sample")
 camry_rc = os.path.join(_module_path, "implicit", "camry_rc")