netgen-mesher 6.2.2506.post35.dev0__cp314-cp314-win_amd64.whl

netgen/libngpy/_stl.pyi

@@ -0,0 +1,131 @@
+"""
+pybind stl module
+"""
+from __future__ import annotations
+import netgen.libngpy._meshing
+import typing
+__all__: list[str] = ['LoadSTLGeometry', 'STLGeometry']
+class STLGeometry(netgen.libngpy._meshing.NetgenGeometry):
+    def Draw(self) -> None:
+        ...
+    def GenerateMesh(self, mp: netgen.libngpy._meshing.MeshingParameters = None, mesh: netgen.libngpy._meshing.Mesh = None, **kwargs) -> netgen.libngpy._meshing.Mesh:
+        """
+        Meshing Parameters
+        -------------------
+        
+        maxh: float = 1e10
+          Global upper bound for mesh size.
+        
+        grading: float = 0.3
+          Mesh grading how fast the local mesh size can change.
+        
+        meshsizefilename: str = None
+          Load meshsize from file. Can set local mesh size for points
+          and along edges. File must have the format:
+        
+            nr_points
+            x1, y1, z1, meshsize
+            x2, y2, z2, meshsize
+            ...
+            xn, yn, zn, meshsize
+        
+            nr_edges
+            x11, y11, z11, x12, y12, z12, meshsize
+            ...
+            xn1, yn1, zn1, xn2, yn2, zn2, meshsize
+        
+        segmentsperedge: float = 1.
+          Minimal number of segments per edge.
+        
+        quad_dominated: bool = False
+          Quad-dominated surface meshing.
+        
+        blockfill: bool = True
+          Do fast blockfilling.
+        
+        filldist: float = 0.1
+          Block fill up to distance
+        
+        delaunay: bool = True
+          Use delaunay meshing.
+        
+        delaunay2d : bool = True
+          Use delaunay meshing for 2d geometries.
+        
+        Optimization Parameters
+        -----------------------
+        
+        optimize3d: str = "cmdmustm"
+          3d optimization strategy:
+            m .. move nodes
+            M .. move nodes, cheap functional
+            s .. swap faces
+            c .. combine elements
+            d .. divide elements
+            p .. plot, no pause
+            P .. plot, Pause
+            h .. Histogramm, no pause
+            H .. Histogramm, pause
+        
+        optsteps3d: int = 3
+          Number of 3d optimization steps.
+        
+        optimize2d: str = "smcmSmcmSmcm"
+          2d optimization strategy:
+            s .. swap, opt 6 lines/node
+            S .. swap, optimal elements
+            m .. move nodes
+            p .. plot, no pause
+            P .. plot, pause
+            c .. combine
+        
+        optsteps2d: int = 3
+          Number of 2d optimization steps.
+        
+        elsizeweight: float = 0.2
+          Weight of element size w.r.t. element shape in optimization.
+        
+        
+        STL Specific Meshing Parameters
+        -------------------------------
+        
+        yangle: float = 30.
+          Angle for edge detection
+        
+        contyangle: float = 20.
+          Edges continue if angle > contyangle
+        
+        edgecornerangle: float = 60.
+          Angle of geometry edge at which the mesher should set a point.
+        
+        closeedgefac: Optional[float] = 1.
+          Factor for meshing close edges, if None it is disabled.
+        
+        minedgelen: Optional[float] = 0.001
+          Minimum edge length to be used for dividing edges to mesh points. If
+          None this is disabled.
+        """
+    def GetDirtyTrigs(self, **kwargs) -> None:
+        ...
+    def GetVicinity(self, node: typing.SupportsInt, size: typing.SupportsInt, node_type: str = 'trig') -> STLGeometry:
+        ...
+    def MovePointToMiddle(self, arg0: typing.SupportsInt, arg1: typing.SupportsInt) -> None:
+        ...
+    def Save(self, arg0: os.PathLike | str | bytes) -> None:
+        ...
+    def SmoothDirtyTrigs(self, **kwargs) -> None:
+        ...
+    def __getstate__(self) -> tuple:
+        ...
+    @typing.overload
+    def __init__(self) -> None:
+        ...
+    @typing.overload
+    def __init__(self, filename: str, surface: bool = False) -> None:
+        ...
+    def __setstate__(self, arg0: tuple) -> None:
+        ...
+    def _visualizationData(self) -> dict:
+        ...
+def LoadSTLGeometry(arg0: str) -> STLGeometry:
+    ...

netgen/meshing.py

@@ -0,0 +1,65 @@
+from .libngpy._meshing import *
+from pyngcore import MPI_Comm
+
+class _MeshsizeObject:
+    @property
+    def very_coarse(self):
+        return MeshingParameters(curvaturesafety=1,
+                                 segmentsperedge=0.3,
+                                 grading=0.7,
+                                 chartdistfac=0.8,
+                                 linelengthfac=0.2,
+                                 closeedgefac=0.5,
+                                 minedgelen=0.002,
+                                 surfmeshcurvfac=1.,
+                                 optsteps3d=5)
+    @property
+    def coarse(self):
+        return MeshingParameters(curvaturesafety=1.5,
+                                 segmentsperedge=0.5,
+                                 grading=0.5,
+                                 chartdistfac=1,
+                                 linelengthfac=0.35,
+                                 closeedgefac=1,
+                                 minedgelen=0.02,
+                                 surfmeshcurvfac=1.5,
+                                 optsteps3d=5)
+    @property
+    def moderate(self):
+        return MeshingParameters(curvaturesafety=2,
+                                 segmentsperedge=1,
+                                 grading=0.3,
+                                 chartdistfac=1.5,
+                                 linelengthfac=0.5,
+                                 closeedgefac=2,
+                                 minedgelen=0.2,
+                                 surfmeshcurvfac=2.,
+                                 optsteps3d=5)
+    @property
+    def fine(self):
+        return MeshingParameters(curvaturesafety=3,
+                                 segmentsperedge=2,
+                                 grading=0.2,
+                                 chartdistfac=2,
+                                 linelengthfac=1.5,
+                                 closeedgefac=3.5,
+                                 minedgelen=1.,
+                                 surfmeshcurvfac=3.,
+                                 optsteps3d=5)
+
+    @property
+    def very_fine(self):
+        return  MeshingParameters(curvaturesafety=5,
+                                  segmentsperedge=3,
+                                  grading=0.1,
+                                  chartdistfac=5,
+                                  linelengthfac=3,
+                                  closeedgefac=5,
+                                  minedgelen=2.,
+                                  surfmeshcurvfac=5.,
+                                  optsteps3d=5)
+
+meshsize = _MeshsizeObject()
+
+
+clearsol = ClearSolutionClass()

netgen/occ.py

@@ -0,0 +1,52 @@
+""" Netgen OCC documentation 
+
+This module provides the Netgen OCCGeometry class, as well as Python wrappers 
+for OpenCascade functionality. This allows the construction from scratch, as well as
+editing geometries imported via STEP format.
+
+Most of the classes are directly py-wrapped from the OCCT classes. 
+For more detailed documentation consult the OCCT docs, a good starting point is
+https://dev.opencascade.org/doc/refman/html/class_b_rep_builder_a_p_i___make_shape.html
+"""
+
+from .config import USE_OCC
+if not USE_OCC:
+    raise ImportError("Netgen was not built with Opencascade support")
+
+from .libngpy._NgOCC import *
+from .meshing import meshsize, IdentificationType
+
+
+gp_Ax3 = Axes
+gp_Ax1 = Axis
+
+Translation = gp_Trsf.Translation
+Rotation = gp_Trsf.Rotation
+Mirror = gp_Trsf.Mirror
+
+
+def Rectangle(l,w): return WorkPlane().Rectangle(l,w)
+def MoveTo(x,y): return WorkPlane().MoveTo(x,y)
+def LineTo(x,y): return WorkPlane().LineTo(x,y)
+def Line(l): return WorkPlane().Line(l)    
+
+
+unit_square_shape = WorkPlane().Line(1, name="bottom").Rotate(90) \
+  .Line(1, name="right").Rotate(90) \
+  .Line(1, name="top").Rotate(90) \
+  .Line(1, name="left").Rotate(90).Face()
+
+unit_square = OCCGeometry(unit_square_shape, dim=2)
+
+
+
+uc_shape = Box((0,0,0),(1,1,1))
+uc_shape.faces.Max(X).name = "front"
+uc_shape.faces.Min(X).name = "back"
+uc_shape.faces.Max(Y).name = "right"
+uc_shape.faces.Min(Y).name = "left"
+uc_shape.faces.Max(Z).name = "top"
+uc_shape.faces.Min(Z).name = "bottom"
+    
+unit_cube = OCCGeometry(uc_shape)
+

netgen/read_gmsh.py

@@ -0,0 +1,259 @@
+from netgen.meshing import *
+
+def ReadGmsh(filename):
+    if not filename.endswith(".msh"):
+        filename += ".msh"
+    meshdim = 1
+    with open(filename, 'r') as f:
+        while f.readline().split()[0] != "$Elements":
+            pass
+        nelem = int(f.readline())
+        for i in range(nelem):
+            line = f.readline()
+            eltype = int(line.split()[1])
+            if eltype > 1 and eltype != 15:
+                meshdim = 2
+            if eltype > 3 and eltype != 15:
+                meshdim = 3
+                break
+
+    f = open(filename, 'r')
+    mesh = Mesh(dim=meshdim)
+
+    pointmap = {}
+    facedescriptormap = {}
+    namemap = { 0 : { 0 : "default" },
+                1: { 0 : "default" },
+                2: { 0 : "default" },
+                3: { 0 : "default" } }
+    materialmap = {}
+    bbcmap = {}
+    bbbcmap = {}
+    
+
+    segm = 1
+    trig = 2
+    quad = 3
+    tet = 4
+    hex = 5
+    prism = 6
+    pyramid = 7
+    segm3 = 8      # 2nd order line
+    trig6 = 9      # 2nd order trig
+    tet10 = 11     # 2nd order tet
+    point = 15
+    quad8 = 16     # 2nd order quad
+    hex20 = 17     # 2nd order hex
+    prism15 = 18   # 2nd order prism
+    pyramid13 = 19 # 2nd order pyramid
+    segms = [segm, segm3]
+    trigs = [trig, trig6]
+    quads = [quad, quad8]
+    tets = [tet, tet10]
+    hexes = [hex, hex20]
+    prisms = [prism, prism15]
+    pyramids = [pyramid, pyramid13]
+    elem0d = [point]
+    elem1d = segms
+    elem2d = trigs + quads
+    elem3d = tets + hexes + prisms + pyramids
+
+    num_nodes_map = { segm : 2,
+                      trig : 3,
+                      quad : 4,
+                      tet : 4,
+                      hex : 8,
+                      prism : 6,
+                      pyramid : 5,
+                      segm3 : 3,
+                      trig6 : 6,
+                      tet10 : 10,
+                      point : 1,
+                      quad8 : 8,
+                      hex20 : 20,
+                      prism15 : 18,
+                      pyramid13 : 19 }
+
+    while True:
+        line = f.readline()
+        if line == "":
+            break
+
+        if line.split()[0] == "$PhysicalNames":
+            print('WARNING: Physical groups detected - Be sure to define them for every geometrical entity.')
+            numnames = int(f.readline())
+            for i in range(numnames):
+                f.readline
+                line = f.readline()
+                namemap[int(line.split()[0])][int(line.split()[1])] = line.split()[2][1:-1]
+
+        if line.split()[0] == "$Nodes":
+            num = int(f.readline().split()[0])
+            for i in range(num):
+                line = f.readline()
+                nodenum, x, y, z = line.split()[0:4]
+                pnum = mesh.Add(MeshPoint(Pnt(float(x), float(y), float(z))))
+                pointmap[int(nodenum)] = pnum
+
+        if line.split()[0] == "$Elements":
+            num = int(f.readline().split()[0])
+
+            for i in range(num):
+                line = f.readline().split()
+                elmnum = int(line[0])
+                elmtype = int(line[1])
+                numtags = int(line[2])
+                # the first tag is the physical group nr, the second tag is the group nr of the dim
+                tags = [int(line[3 + k]) for k in range(numtags)]
+
+                if elmtype not in num_nodes_map:
+                    raise Exception("element type", elmtype, "not implemented")
+                num_nodes = num_nodes_map[elmtype]
+
+                nodenums = line[3 + numtags:3 + numtags + num_nodes]
+                nodenums2 = [pointmap[int(nn)] for nn in nodenums]
+
+
+                if elmtype in elem0d:
+                    if meshdim == 3:
+                        if tags[1] in bbbcmap:
+                            index = bbbcmap[tags[1]]
+                        else:
+                            index = len(bbbcmap) + 1
+                            if len(namemap):
+                                mesh.SetCD3Name(index, namemap[0][tags[0]])
+                            else:
+                                mesh.SetCD3Name(index, "point" + str(tags[1]))
+                            bbbcmap[tags[1]] = index
+                    elif meshdim == 2:
+                        if tags[1] in bbcmap:
+                            index = bbcmap[tags[1]]
+                        else:
+                            index = len(bbcmap) + 1
+                            if len(namemap):
+                                mesh.SetCD2Name(index, namemap[0][tags[0]])
+                            else:
+                                mesh.SetCD2Name(index, "point" + str(tags[1]))
+                            bbcmap[tags[1]] = index
+                    else:
+                        if tags[1] in facedescriptormap.keys():
+                            index = facedescriptormap[tags[1]]
+                        else:
+                            index = len(facedescriptormap) + 1
+                            fd = FaceDescriptor(bc=index)
+                            if len(namemap):
+                                fd.bcname = namemap[0][tags[0]]
+                            else:
+                                fd.bcname = 'point' + str(tags[1])
+                            mesh.SetBCName(index - 1, fd.bcname)
+                            mesh.Add(fd)
+                            facedescriptormap[tags[1]] = index
+
+                    mesh.Add(Element0D(nodenums2[0], index=index))
+
+                
+                if elmtype in elem1d:
+                    if meshdim == 3:
+                        if tags[1] in bbcmap:
+                            index = bbcmap[tags[1]]
+                        else:
+                            index = len(bbcmap) + 1
+                            if len(namemap):
+                                mesh.SetCD2Name(index, namemap[1][tags[0]])
+                            else:
+                                mesh.SetCD2Name(index, "line" + str(tags[1]))
+                            bbcmap[tags[1]] = index
+
+                    elif meshdim == 2:
+                        if tags[1] in facedescriptormap.keys():
+                            index = facedescriptormap[tags[1]]
+                        else:
+                            index = len(facedescriptormap) + 1
+                            fd = FaceDescriptor(bc=index)
+                            if len(namemap):
+                                fd.bcname = namemap[1][tags[0]]
+                            else:
+                                fd.bcname = 'line' + str(tags[1])
+                            mesh.SetBCName(index - 1, fd.bcname)
+                            mesh.Add(fd)
+                            facedescriptormap[tags[1]] = index
+                    else:
+                        if tags[1] in materialmap:
+                            index = materialmap[tags[1]]
+                        else:
+                            index = len(materialmap) + 1
+                            if len(namemap):
+                                mesh.SetMaterial(index, namemap[1][tags[0]])
+                            else:
+                                mesh.SetMaterial(index, "line" + str(tags[1]))
+                            materialmap[tags[1]] = index
+
+                    mesh.Add(Element1D(index=index, vertices=nodenums2))
+
+                if elmtype in elem2d:  # 2d elements
+                    if meshdim == 3:
+                        if tags[1] in facedescriptormap.keys():
+                            index = facedescriptormap[tags[1]]
+                        else:
+                            index = len(facedescriptormap) + 1
+                            fd = FaceDescriptor(bc=index)
+                            if len(namemap):
+                                fd.bcname = namemap[2][tags[0]]
+                            else:
+                                fd.bcname = "surf" + str(tags[1])
+                            mesh.SetBCName(index - 1, fd.bcname)
+                            mesh.Add(fd)
+                            facedescriptormap[tags[1]] = index
+                    else:
+                        if tags[1] in materialmap:
+                            index = materialmap[tags[1]]
+                        else:
+                            index = len(materialmap) + 1
+                            if len(namemap):
+                                mesh.SetMaterial(index, namemap[2][tags[0]])
+                            else:
+                                mesh.SetMaterial(index, "surf" + str(tags[1]))
+                            materialmap[tags[1]] = index
+
+                    if elmtype in trigs:
+                        ordering = [i for i in range(3)]
+                        if elmtype == trig6:
+                            ordering += [4,5,3]
+                    if elmtype in quads:
+                        ordering = [i for i in range(4)]
+                        if elmtype == quad8:
+                            ordering += [4, 6, 7, 5]
+                    mesh.Add(Element2D(index, [nodenums2[i] for i in ordering]))
+
+                if elmtype in elem3d:  # volume elements
+                    if tags[1] in materialmap:
+                        index = materialmap[tags[1]]
+                    else:
+                        index = len(materialmap) + 1
+                        if len(namemap):
+                            mesh.SetMaterial(index, namemap[3][tags[0]])
+                        else:
+                            mesh.SetMaterial(index, "vol" + str(tags[1]))
+                        materialmap[tags[1]] = index
+
+                    nodenums2 = [pointmap[int(nn)] for nn in nodenums]
+
+                    if elmtype in tets:
+                        ordering = [0,1,2,3]
+                        if elmtype == tet10:
+                            ordering += [4,6,7,5,9,8]
+                    elif elmtype in hexes:
+                        ordering = [0,1,5,4,3,2,6,7]
+                        if elmtype == hex20:
+                            ordering += [8,16,10,12,13,19,15,14,9,11,18,17]
+                    elif elmtype in prisms:
+                        ordering = [0,2,1,3,5,4]
+                        if elmtype == prism15:
+                            ordering += [7,6,9,8,11,10,13,12,14]
+                    elif elmtype in pyramids:
+                        ordering = [3,2,1,0,4]
+                        if elmtype == pyramid13:
+                            ordering += [10,5,6,8,12,11,9,7]
+                    mesh.Add(Element3D(index, [nodenums2[i] for i in ordering]))
+
+    return mesh

netgen/read_meshio.py

@@ -0,0 +1,22 @@
+from netgen.meshing import *
+
+def ReadViaMeshIO(filename):
+    import meshio
+    import numpy as np
+    
+    # print ("reading via meshio:", filename)
+
+    m = meshio.read(filename)
+    pts = m.points
+    
+    mesh = Mesh(dim=pts.shape[1])
+    # mesh.AddPoints ( np.asarray(pts, dtype=np.float64) )  # needed for correct little/big endian
+    mesh.AddPoints ( pts )  
+
+    fd = mesh.Add (FaceDescriptor(bc=1))
+    for cb in m.cells:
+        # mesh.AddElements(dim=cb.dim, index=1, data=np.asarray(cb.data, dtype=np.int32), base=0)
+        mesh.AddElements(dim=cb.dim, index=1, data=cb.data, base=0)
+            
+    return mesh
+

netgen/stl.py

@@ -0,0 +1,2 @@
+from netgen.libngpy._stl import *
+from .meshing import meshsize

netgen/version.py

@@ -0,0 +1,2 @@
+__version__ = "6.2.2506.post35.dev0"
+__package_name__ = "netgen-mesher"