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

netgen/libngpy/__init__.pyi

@@ -0,0 +1,7 @@
+from __future__ import annotations
+from . import _NgOCC
+from . import _csg
+from . import _geom2d
+from . import _meshing
+from . import _stl
+__all__: list[str] = list()

netgen/libngpy/_csg.pyi

@@ -0,0 +1,259 @@
+"""
+pybind csg module
+"""
+from __future__ import annotations
+import netgen.libngpy._meshing
+import typing
+__all__: list[str] = ['And', 'CSGeometry', 'Cone', 'Cylinder', 'Ellipsoid', 'EllipticCone', 'Extrusion', 'Or', 'OrthoBrick', 'Plane', 'Polyhedron', 'Revolution', 'Save', 'Solid', 'Sphere', 'SplineCurve2d', 'SplineCurve3d', 'SplineSurface', 'Torus', 'ZRefinement']
+class CSGeometry(netgen.libngpy._meshing.NetgenGeometry):
+    def Add(self, solid: Solid, bcmod: list = [], maxh: typing.SupportsFloat = 1e+99, col: tuple = (), transparent: bool = False, layer: typing.SupportsInt = 1) -> int:
+        ...
+    def AddPoint(self, arg0: netgen.libngpy._meshing.Point3d, arg1: typing.SupportsInt | str) -> CSGeometry:
+        ...
+    def AddSplineSurface(self, SplineSurface: SplineSurface) -> None:
+        ...
+    def AddSurface(self, surface: Solid, solid: Solid) -> None:
+        ...
+    @typing.overload
+    def CloseSurfaces(self, solid1: Solid, solid2: Solid, slices: list) -> None:
+        ...
+    @typing.overload
+    def CloseSurfaces(self, solid1: Solid, solid2: Solid, reflevels: typing.SupportsInt = 2, domain: Solid = None) -> None:
+        ...
+    def Draw(self) -> None:
+        ...
+    def GenerateMesh(self, mp: netgen.libngpy._meshing.MeshingParameters = 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.
+        """
+    def GetSolids(self) -> list:
+        ...
+    def GetTransparent(self, tlonr: typing.SupportsInt) -> bool:
+        ...
+    def GetVisible(self, tlonr: typing.SupportsInt) -> bool:
+        ...
+    def NameEdge(self, arg0: Solid, arg1: Solid, arg2: str) -> None:
+        ...
+    def PeriodicSurfaces(self, solid1: Solid, solid2: Solid, trafo: netgen.libngpy._meshing.Trafo = ...) -> None:
+        ...
+    def Save(self, arg0: str) -> None:
+        ...
+    def SetBoundingBox(self, pmin: netgen.libngpy._meshing.Point3d, pmax: netgen.libngpy._meshing.Point3d) -> None:
+        ...
+    def SetTransparent(self, tlonr: typing.SupportsInt, transparent: bool) -> None:
+        ...
+    def SetVisible(self, tlonr: typing.SupportsInt, visible: bool) -> None:
+        ...
+    def SingularEdge(self, arg0: Solid, arg1: Solid, arg2: typing.SupportsFloat) -> None:
+        ...
+    def SingularFace(self, solid: Solid, surfaces: Solid = None, factor: typing.SupportsFloat = 0.25) -> None:
+        ...
+    def SingularPoint(self, arg0: Solid, arg1: Solid, arg2: Solid, arg3: typing.SupportsFloat) -> None:
+        ...
+    def __getstate__(self) -> tuple:
+        ...
+    @typing.overload
+    def __init__(self) -> None:
+        ...
+    @typing.overload
+    def __init__(self, filename: str) -> None:
+        ...
+    def __setstate__(self, arg0: tuple) -> None:
+        ...
+    def _visualizationData(self) -> dict:
+        ...
+    @property
+    def ntlo(self) -> int:
+        ...
+class Solid:
+    def __add__(self, arg0: Solid) -> Solid:
+        ...
+    def __mul__(self, arg0: Solid) -> Solid:
+        ...
+    def __str__(self) -> str:
+        ...
+    def __sub__(self, arg0: Solid) -> Solid:
+        ...
+    @typing.overload
+    def bc(self, arg0: typing.SupportsInt) -> Solid:
+        ...
+    @typing.overload
+    def bc(self, arg0: str) -> Solid:
+        ...
+    def col(self, arg0: list) -> Solid:
+        ...
+    @typing.overload
+    def mat(self, arg0: str) -> Solid:
+        ...
+    @typing.overload
+    def mat(self) -> str:
+        ...
+    def maxh(self, arg0: typing.SupportsFloat) -> Solid:
+        ...
+    def transp(self) -> Solid:
+        ...
+class SplineCurve2d:
+    def AddPoint(self, arg0: typing.SupportsFloat, arg1: typing.SupportsFloat) -> int:
+        ...
+    @typing.overload
+    def AddSegment(self, p1: typing.SupportsInt, p2: typing.SupportsInt, bcname: str = 'default', maxh: typing.SupportsFloat = 1e+99) -> None:
+        ...
+    @typing.overload
+    def AddSegment(self, p1: typing.SupportsInt, p2: typing.SupportsInt, p3: typing.SupportsInt, bcname: str = 'default', maxh: typing.SupportsFloat = 1e+99) -> None:
+        ...
+    def __init__(self) -> None:
+        ...
+class SplineCurve3d:
+    def AddPoint(self, arg0: typing.SupportsFloat, arg1: typing.SupportsFloat, arg2: typing.SupportsFloat) -> int:
+        ...
+    @typing.overload
+    def AddSegment(self, arg0: typing.SupportsInt, arg1: typing.SupportsInt) -> None:
+        ...
+    @typing.overload
+    def AddSegment(self, arg0: typing.SupportsInt, arg1: typing.SupportsInt, arg2: typing.SupportsInt) -> None:
+        ...
+    def __init__(self) -> None:
+        ...
+class SplineSurface:
+    """
+    A surface for co dim 2 integrals on the splines
+    """
+    def AddPoint(self, x: typing.SupportsFloat, y: typing.SupportsFloat, z: typing.SupportsFloat, hpref: bool = False) -> int:
+        ...
+    @typing.overload
+    def AddSegment(self, pnt1: typing.SupportsInt, pnt2: typing.SupportsInt, bcname: str = 'default', maxh: typing.SupportsFloat = -1.0) -> None:
+        ...
+    @typing.overload
+    def AddSegment(self, pnt1: typing.SupportsInt, pnt2: typing.SupportsInt, pnt3: typing.SupportsInt, bcname: str = 'default', maxh: typing.SupportsFloat = -1.0) -> None:
+        ...
+    def __init__(self, base: SPSolid, cuts: list = []) -> None:
+        ...
+def And(arg0: Solid, arg1: Solid) -> Solid:
+    ...
+def Cone(arg0: netgen.libngpy._meshing.Point3d, arg1: netgen.libngpy._meshing.Point3d, arg2: typing.SupportsFloat, arg3: typing.SupportsFloat) -> Solid:
+    ...
+def Cylinder(arg0: netgen.libngpy._meshing.Point3d, arg1: netgen.libngpy._meshing.Point3d, arg2: typing.SupportsFloat) -> Solid:
+    ...
+def Ellipsoid(arg0: netgen.libngpy._meshing.Point3d, arg1: netgen.libngpy._meshing.Vec3d, arg2: netgen.libngpy._meshing.Vec3d, arg3: netgen.libngpy._meshing.Vec3d) -> Solid:
+    ...
+def EllipticCone(a: netgen.libngpy._meshing.Point3d, vl: netgen.libngpy._meshing.Vec3d, vs: netgen.libngpy._meshing.Vec3d, h: typing.SupportsFloat, r: typing.SupportsFloat) -> Solid:
+    """
+    An elliptic cone, given by the point 'a' at the base of the cone along the main axis,
+    the vectors v and w of the long and short axis of the ellipse, respectively,
+    the height of the cone, h, and ratio of base long axis length to top long axis length, r
+    
+    Note: The elliptic cone has to be truncated by planes similar to a cone or an elliptic cylinder.
+    When r =1, the truncated elliptic cone becomes an elliptic cylinder.
+    When r tends to zero, the truncated elliptic cone tends to a full elliptic cone.
+    However, when r = 0, the top part becomes a point(tip) and meshing fails!
+    """
+def Extrusion(path: SplineCurve3d, profile: SplineCurve2d, d: netgen.libngpy._meshing.Vec3d) -> Solid:
+    """
+    A body of extrusion is defined by its profile
+    (which has to be a closed, clockwiseoriented 2D curve),
+     by a path (a 3D curve) and a vector d. It is constructed
+     as follows: Take a point p on the path and denote the
+     (unit-)tangent of the path in this point by t. If we cut
+     the body by the plane given by p and t as normal vector,
+     the cut is the profile. The profile is oriented by the
+     (local) y-direction `y:=d−(d·t)t` and the (local) x-direction
+     `x:=t \\times y`.
+    The following points have to be noticed:
+     * If the path is not closed, then also the body is NOT closed.
+       In this case e.g. planes or orthobricks have to be used to
+       construct a closed body.
+     * The path has to be smooth, i.e. the tangents at the end- resp.
+       start-point of two consecutive spline or line patches have to
+       have the same directions.
+    """
+def Or(arg0: Solid, arg1: Solid) -> Solid:
+    ...
+def OrthoBrick(arg0: netgen.libngpy._meshing.Point3d, arg1: netgen.libngpy._meshing.Point3d) -> Solid:
+    ...
+def Plane(arg0: netgen.libngpy._meshing.Point3d, arg1: netgen.libngpy._meshing.Vec3d) -> Solid:
+    ...
+def Polyhedron(arg0: list, arg1: list) -> Solid:
+    ...
+def Revolution(arg0: netgen.libngpy._meshing.Point3d, arg1: netgen.libngpy._meshing.Point3d, arg2: SplineCurve2d) -> Solid:
+    ...
+def Save(arg0: netgen.libngpy._meshing.Mesh, arg1: str, arg2: CSGeometry) -> None:
+    ...
+def Sphere(arg0: netgen.libngpy._meshing.Point3d, arg1: typing.SupportsFloat) -> Solid:
+    ...
+def Torus(arg0: netgen.libngpy._meshing.Point3d, arg1: netgen.libngpy._meshing.Vec3d, arg2: typing.SupportsFloat, arg3: typing.SupportsFloat) -> Solid:
+    ...
+def ZRefinement(arg0: netgen.libngpy._meshing.Mesh, arg1: CSGeometry) -> None:
+    ...

netgen/libngpy/_geom2d.pyi

@@ -0,0 +1,323 @@
+"""
+pybind geom2d module
+"""
+from __future__ import annotations
+import netgen.libngpy._meshing
+import typing
+__all__: list[str] = ['CSG2d', 'Circle', 'EdgeInfo', 'PointInfo', 'Rectangle', 'Solid2d', 'Spline', 'SplineGeometry']
+class CSG2d:
+    def Add(self, arg0: Solid2d) -> None:
+        ...
+    def GenerateMesh(self, mp: netgen.libngpy._meshing.MeshingParameters | None = 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.
+        """
+    def GenerateSplineGeometry(self) -> SplineGeometry:
+        ...
+    def __init__(self) -> None:
+        ...
+class EdgeInfo:
+    @typing.overload
+    def __init__(self) -> None:
+        ...
+    @typing.overload
+    def __init__(self, control_point: netgen.libngpy._meshing.Point2d) -> None:
+        ...
+    @typing.overload
+    def __init__(self, maxh: typing.SupportsFloat) -> None:
+        ...
+    @typing.overload
+    def __init__(self, bc: str) -> None:
+        ...
+    @typing.overload
+    def __init__(self, control_point: netgen.libngpy._meshing.Point2d | None = None, maxh: typing.SupportsFloat = 1e+99, bc: str = '') -> None:
+        ...
+class PointInfo:
+    @typing.overload
+    def __init__(self) -> None:
+        ...
+    @typing.overload
+    def __init__(self, maxh: typing.SupportsFloat) -> None:
+        ...
+    @typing.overload
+    def __init__(self, name: str) -> None:
+        ...
+    @typing.overload
+    def __init__(self, maxh: typing.SupportsFloat, name: str) -> None:
+        ...
+class Solid2d:
+    def BC(self, arg0: str) -> Solid2d:
+        ...
+    def Copy(self) -> Solid2d:
+        ...
+    def Layer(self, arg0: typing.SupportsInt) -> Solid2d:
+        ...
+    def Mat(self, arg0: str) -> Solid2d:
+        ...
+    def Maxh(self, arg0: typing.SupportsFloat) -> Solid2d:
+        ...
+    def Move(self, arg0: netgen.libngpy._meshing.Vec2d) -> Solid2d:
+        ...
+    def Rotate(self, angle: typing.SupportsFloat, center: netgen.libngpy._meshing.Point2d = ...) -> Solid2d:
+        ...
+    @typing.overload
+    def Scale(self, arg0: typing.SupportsFloat) -> Solid2d:
+        ...
+    @typing.overload
+    def Scale(self, arg0: netgen.libngpy._meshing.Vec2d) -> Solid2d:
+        ...
+    def __add__(self, arg0: Solid2d) -> Solid2d:
+        ...
+    def __iadd__(self, arg0: Solid2d) -> Solid2d:
+        ...
+    def __imul__(self, arg0: Solid2d) -> Solid2d:
+        ...
+    @typing.overload
+    def __init__(self) -> None:
+        ...
+    @typing.overload
+    def __init__(self, points: Array[netgen.libngpy._meshing.Point2d | ... | ...], mat: str = '', bc: str = '') -> None:
+        ...
+    def __isub__(self, arg0: Solid2d) -> Solid2d:
+        ...
+    def __mul__(self, arg0: Solid2d) -> Solid2d:
+        ...
+    def __sub__(self, arg0: Solid2d) -> Solid2d:
+        ...
+class Spline:
+    """
+    Spline of a SplineGeometry object
+    """
+    def EndPoint(self) -> netgen.libngpy._meshing.Point2d:
+        ...
+    def GetNormal(self, arg0: typing.SupportsFloat) -> netgen.libngpy._meshing.Vec2d:
+        ...
+    def StartPoint(self) -> netgen.libngpy._meshing.Point2d:
+        ...
+    @property
+    def bc(self) -> int:
+        ...
+    @property
+    def leftdom(self) -> int:
+        ...
+    @leftdom.setter
+    def leftdom(self, arg1: typing.SupportsInt) -> None:
+        ...
+    @property
+    def rightdom(self) -> int:
+        ...
+    @rightdom.setter
+    def rightdom(self, arg1: typing.SupportsInt) -> None:
+        ...
+class SplineGeometry(netgen.libngpy._meshing.NetgenGeometry):
+    """
+    a 2d boundary representation geometry model by lines and splines
+    """
+    def AddCurve(self, func: typing.Any, leftdomain: typing.SupportsInt = 1, rightdomain: typing.SupportsInt = 0, bc: typing.Any = ..., maxh: typing.SupportsFloat = 1e+99) -> None:
+        """
+        Curve is given as parametrization on the interval [0,1]
+        """
+    def Append(self, point_indices: list, leftdomain: typing.SupportsInt = 1, rightdomain: typing.SupportsInt = 0, bc: typing.SupportsInt | str | None = None, copy: typing.SupportsInt | None = None, maxh: typing.SupportsFloat = 1e+99, hpref: typing.SupportsFloat = 0, hprefleft: typing.SupportsFloat = 0, hprefright: typing.SupportsFloat = 0) -> int:
+        ...
+    def AppendPoint(self, x: typing.SupportsFloat, y: typing.SupportsFloat, maxh: typing.SupportsFloat = 1e+99, hpref: typing.SupportsFloat = 0, name: str = '') -> int:
+        ...
+    def AppendSegment(self, point_indices: list, leftdomain: typing.SupportsInt = 1, rightdomain: typing.SupportsInt = 0) -> None:
+        ...
+    def Draw(self) -> None:
+        ...
+    def GenerateMesh(self, mp: netgen.libngpy._meshing.MeshingParameters | None = 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.
+        """
+    def GetBCName(self, arg0: typing.SupportsInt) -> str:
+        ...
+    def GetNDomains(self) -> int:
+        ...
+    def GetNPoints(self) -> int:
+        ...
+    def GetNSplines(self) -> int:
+        ...
+    def GetPoint(self, arg0: typing.SupportsInt) -> netgen.libngpy._meshing.Point2d:
+        ...
+    def GetSpline(self, arg0: typing.SupportsInt) -> Spline:
+        ...
+    def Load(self, arg0: os.PathLike | str | bytes) -> None:
+        ...
+    def PlotData(self) -> tuple:
+        ...
+    def PointData(self) -> tuple:
+        ...
+    def Print(self) -> None:
+        ...
+    def SegmentData(self) -> tuple:
+        ...
+    def SetDomainLayer(self, arg0: typing.SupportsInt, arg1: typing.SupportsInt) -> None:
+        ...
+    def SetDomainMaxH(self, arg0: typing.SupportsInt, arg1: typing.SupportsFloat) -> None:
+        ...
+    def SetMaterial(self, arg0: typing.SupportsInt, arg1: str) -> None:
+        ...
+    def _SetDomainTensorMeshing(self, arg0: typing.SupportsInt, arg1: bool) -> None:
+        ...
+    def __getstate__(self) -> tuple:
+        ...
+    @typing.overload
+    def __init__(self) -> None:
+        ...
+    @typing.overload
+    def __init__(self, arg0: str) -> None:
+        ...
+    def __setstate__(self, arg0: tuple) -> None:
+        ...
+    def _visualizationData(self) -> dict:
+        ...
+def Circle(center: netgen.libngpy._meshing.Point2d, radius: typing.SupportsFloat, mat: str = '', bc: str = '') -> Solid2d:
+    ...
+def Rectangle(pmin: netgen.libngpy._meshing.Point2d, pmax: netgen.libngpy._meshing.Point2d, mat: str = '', bc: str = '', bottom: str | None = None, right: str | None = None, top: str | None = None, left: str | None = None) -> Solid2d:
+    ...