Merge remote-tracking branch 'origin/zhanqun/dyna-prev4' into main

Author: wenhuiuy

examples/ICFD/icfd_dam_break.py

@@ -0,0 +1,81 @@
+"""
+Dam break
+=========
+
+This example shows a simple free surface example using the ICFD solver. A column of water collapses under the load of gravity.
+"""
+
+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,
+    Gravity,
+    GravityOption,
+    Compressible
+)
+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.dam_break + os.sep
+fns.append(path + "dam_break.k")
+solution.open_files(fns)
+solution.set_termination(termination_time=50)
+icfd = DynaICFD()
+solution.add(icfd)
+
+icfdanalysis = ICFDAnalysis()
+icfdanalysis.set_timestep()
+icfd.add(icfdanalysis)
+
+# define model
+mat1 = MatICFD(flow_density=1000, dynamic_viscosity=0.001)
+mat2 = MatICFD(flag=Compressible.VACUUM)
+
+part1 = ICFDPart(1)
+part1.set_material(mat1)
+part1.set_free_slip()
+icfd.parts.add(part1)
+
+part2 = ICFDPart(2)
+part2.set_material(mat2)
+part2.set_free_slip()
+icfd.parts.add(part2)
+
+part3 = ICFDPart(3)
+part3.set_material(mat1)
+icfd.parts.add(part3)
+
+g = Gravity(dir=GravityOption.DIR_Y, load=Curve(x=[0, 10000], y=[9.81, 9.81]))
+icfd.add(g)
+
+partvol1 = ICFDVolumePart(surfaces=[1, 3])
+partvol1.set_material(mat1)
+icfd.parts.add(partvol1)
+
+partvol2 = ICFDVolumePart(surfaces=[2, 3])
+partvol2.set_material(mat2)
+icfd.parts.add(partvol2)
+# define the volume space that will be meshed,The boundaries
+# of the volume are the surfaces "spids"
+meshvol = MeshedVolume(surfaces=[1, 2])
+meshvol.set_fluid_interfaces([3])
+icfd.add(meshvol)
+
+solution.create_database_binary(dt=0.2)
+solution.save_file()

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