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

netgen/config/config.pyi

@@ -0,0 +1,54 @@
+from __future__ import annotations
+__all__: list[str] = ['BUILD_FOR_CONDA', 'BUILD_STUB_FILES', 'CHECK_RANGE', 'CMAKE_INSTALL_PREFIX', 'DEBUG_LOG', 'ENABLE_CPP_CORE_GUIDELINES_CHECK', 'ENABLE_UNIT_TESTS', 'INSTALL_PROFILES', 'INTEL_MIC', 'NETGEN_PYTHON_PACKAGE_NAME', 'NETGEN_PYTHON_RPATH', 'NETGEN_PYTHON_RPATH_BIN', 'NETGEN_VERSION', 'NETGEN_VERSION_GIT', 'NETGEN_VERSION_HASH', 'NETGEN_VERSION_MAJOR', 'NETGEN_VERSION_MINOR', 'NETGEN_VERSION_PATCH', 'NETGEN_VERSION_PYTHON', 'NETGEN_VERSION_TWEAK', 'NG_COMPILE_FLAGS', 'NG_INSTALL_DIR_BIN', 'NG_INSTALL_DIR_CMAKE', 'NG_INSTALL_DIR_INCLUDE', 'NG_INSTALL_DIR_LIB', 'NG_INSTALL_DIR_PYTHON', 'NG_INSTALL_DIR_RES', 'PYTHON_VERSION', 'PYTHON_VERSION_MAJOR', 'PYTHON_VERSION_MINOR', 'TRACE_MEMORY', 'USE_CCACHE', 'USE_CGNS', 'USE_GUI', 'USE_INTERNAL_TCL', 'USE_JPEG', 'USE_MPEG', 'USE_MPI', 'USE_MPI4PY', 'USE_NATIVE_ARCH', 'USE_NUMA', 'USE_OCC', 'USE_PYTHON', 'USE_SPDLOG', 'get_cmake_dir', 'is_python_package', 'ngcore_compile_definitions', 'ngcore_compile_options', 'version']
+def _cmake_to_bool(s):
+    ...
+def get_cmake_dir():
+    ...
+BUILD_FOR_CONDA: bool = True
+BUILD_STUB_FILES: bool = True
+CHECK_RANGE: bool = False
+CMAKE_INSTALL_PREFIX: str = 'C:/gitlabci/tools/builds/3zsqG5ns/0/ngsolve/netgen/_skbuild/win-amd64-3.14/cmake-install'
+DEBUG_LOG: bool = False
+ENABLE_CPP_CORE_GUIDELINES_CHECK: bool = False
+ENABLE_UNIT_TESTS: bool = False
+INSTALL_PROFILES: bool = False
+INTEL_MIC: bool = False
+NETGEN_PYTHON_PACKAGE_NAME: str = 'netgen-mesher'
+NETGEN_PYTHON_RPATH: str = 'netgen'
+NETGEN_PYTHON_RPATH_BIN: str = 'netgen'
+NETGEN_VERSION: str = '6.2.2506-35-ga9438ce2'
+NETGEN_VERSION_GIT: str = 'v6.2.2506-35-ga9438ce2'
+NETGEN_VERSION_HASH: str = 'ga9438ce2'
+NETGEN_VERSION_MAJOR: str = '6'
+NETGEN_VERSION_MINOR: str = '2'
+NETGEN_VERSION_PATCH: str = '2506'
+NETGEN_VERSION_PYTHON: str = '6.2.2506.post35.dev0'
+NETGEN_VERSION_TWEAK: str = '35'
+NG_COMPILE_FLAGS: str = '/arch:AVX2'
+NG_INSTALL_DIR_BIN: str = 'netgen'
+NG_INSTALL_DIR_CMAKE: str = 'netgen/cmake'
+NG_INSTALL_DIR_INCLUDE: str = 'netgen/include'
+NG_INSTALL_DIR_LIB: str = 'netgen/lib'
+NG_INSTALL_DIR_PYTHON: str = '.'
+NG_INSTALL_DIR_RES: str = 'share'
+PYTHON_VERSION: str = '3.14.0'
+PYTHON_VERSION_MAJOR: str = '3'
+PYTHON_VERSION_MINOR: str = '14'
+TRACE_MEMORY: bool = False
+USE_CCACHE: bool = True
+USE_CGNS: bool = False
+USE_GUI: bool = True
+USE_INTERNAL_TCL: bool = True
+USE_JPEG: bool = False
+USE_MPEG: bool = False
+USE_MPI: bool = False
+USE_MPI4PY: bool = False
+USE_NATIVE_ARCH: bool = False
+USE_NUMA: bool = False
+USE_OCC: bool = True
+USE_PYTHON: bool = True
+USE_SPDLOG: bool = False
+is_python_package: bool = True
+ngcore_compile_definitions: str = 'NETGEN_PYTHON;NG_PYTHON;PYBIND11_SIMPLE_GIL_MANAGEMENT;_WIN32_WINNT=0x1000;WNT;WNT_WINDOW;NOMINMAX;MSVC_EXPRESS;_CRT_SECURE_NO_WARNINGS;HAVE_STRUCT_TIMESPEC;WIN32'
+ngcore_compile_options: str = '/arch:AVX2;/bigobj;$<BUILD_INTERFACE:/MP;/W1;/wd4068>'
+version: str = 'v6.2.2506-35-ga9438ce2'

netgen/csg.py

@@ -0,0 +1,25 @@
+from .libngpy._csg import *
+from .libngpy._meshing import Pnt, Vec, Trafo
+from .meshing import meshsize
+
+try:
+    from . import csgvis
+    from .csgvis import MouseMove
+    CSGeometry.VS = csgvis.VS
+    SetBackGroundColor = csgvis.SetBackGroundColor
+    del csgvis
+
+    def VS (obj):
+        return obj.VS()
+except:
+    pass
+
+unit_cube = CSGeometry()
+p1 = Plane(Pnt(0,0,0),Vec(-1,0,0)).bc("back")
+p2 = Plane(Pnt(1,1,1),Vec(1,0,0)).bc("front")
+p3 = Plane(Pnt(0,0,0),Vec(0,-1,0)).bc("left")
+p4 = Plane(Pnt(1,1,1),Vec(0,1,0)).bc("right")
+p5 = Plane(Pnt(0,0,0),Vec(0,0,-1)).bc("bottom")
+p6 = Plane(Pnt(1,1,1),Vec(0,0,1)).bc("top")
+unit_cube.Add (p1*p2*p3*p4*p5*p6, col=(0,0,1))
+

netgen/geom2d.py

@@ -0,0 +1,178 @@
+from .libngpy._geom2d import SplineGeometry, Solid2d, CSG2d, Rectangle, Circle, EdgeInfo, PointInfo
+from .meshing import meshsize
+import math as math
+
+unit_square = SplineGeometry()
+_pnts = [ (0,0), (1,0), (1,1), (0,1) ]
+_lines = [ (0,1,1,"bottom"), (1,2,2,"right"), (2,3,3,"top"), (3,0,4,"left") ]
+_pnums = [unit_square.AppendPoint(*p) for p in _pnts]
+for l1,l2,bc,bcname in _lines:
+    unit_square.Append( ["line", _pnums[l1], _pnums[l2]], bc=bcname)
+
+
+def MakeRectangle (geo, p1, p2, bc=None, bcs=None, **args):
+    p1x, p1y = p1
+    p2x, p2y = p2
+    p1x,p2x = min(p1x,p2x), max(p1x, p2x)
+    p1y,p2y = min(p1y,p2y), max(p1y, p2y)
+    if not bcs: bcs=4*[bc]
+    pts = [geo.AppendPoint(*p) for p in [(p1x,p1y), (p2x, p1y), (p2x, p2y), (p1x, p2y)]]
+    for p1,p2,bc in [(0,1,bcs[0]), (1, 2, bcs[1]), (2, 3, bcs[2]), (3, 0, bcs[3])]:
+        geo.Append( ["line", pts[p1], pts[p2]], bc=bc, **args)
+
+def MakeCircle (geo, c, r, **args):
+    cx,cy = c
+    pts = [geo.AppendPoint(*p) for p in [(cx,cy-r), (cx+r,cy-r), (cx+r,cy), (cx+r,cy+r), \
+                                         (cx,cy+r), (cx-r,cy+r), (cx-r,cy), (cx-r,cy-r)]]
+    for p1,p2,p3 in [(0,1,2), (2,3,4), (4, 5, 6), (6, 7, 0)]:
+        geo.Append( ["spline3", pts[p1], pts[p2], pts[p3]], **args)
+
+    
+
+def CreatePML(geo, pml_size, tol=1e-12):
+    """Create a pml layer around the geometry. This function works only on convex geometries and
+the highest existing domain number must be named by using the function geo.SetMaterial(domnr, name).
+Points in the geometry are assumed to be the same if (pt1 - pt2).Norm() < tol.
+Returned is a dict with information to create the pml layer:
+  normals: A dict from the names of the linear pml domains to the normal vectors pointing inside the pml."""
+
+    def Start(spline):
+        if spline.rightdom == 0:
+            return spline.StartPoint()
+        return spline.EndPoint()
+    def End(spline):
+        if spline.rightdom == 0:
+            return spline.EndPoint()
+        return spline.StartPoint()
+
+    splines = []
+    for i in range(geo.GetNSplines()):
+        splines.append(geo.GetSpline(i))
+    border = []
+    is_closed = False
+    current_endpoint = None
+    while not is_closed:
+        for spline in splines:
+            if spline.leftdom == 0 or spline.rightdom == 0:
+                if current_endpoint is not None:
+                    if (Start(spline)-current_endpoint).Norm() < tol:
+                        border.append(spline)
+                        current_endpoint = End(spline)
+                        if (current_endpoint - startpoint).Norm() < tol:
+                            is_closed = True
+                        break
+                else:
+                    startpoint = Start(spline)
+                    current_endpoint = End(spline)
+                    border.append(spline)
+                    break
+        else:
+            raise Exception("Couldn't find closed spline around domain")
+    endpointindex_map = []
+    for spline in border:
+        pnt = End(spline)
+        for i in range(geo.GetNPoints()):
+            if (pnt - geo.GetPoint(i)).Norm() < tol:
+                endpointindex_map.append(i)
+                break
+        else:
+            raise Exception("Couldn't find endpoint of spline in geometry")
+    start_ndoms = ndoms = geo.GetNDomains() + 1
+    new_spline_domains = []
+    normals = {}
+    duplicate_cnt = 0
+
+    for i, spline in enumerate(border):
+        if i == 0:
+            global_start = Start(spline) + pml_size * spline.GetNormal(0)
+            global_start_pnt = current_start = geo.AppendPoint(global_start[0], global_start[1])
+        next_spline = border[(i+1)%len(border)]
+        new_end =  End(spline) + pml_size * spline.GetNormal(1)
+        spline_name = geo.GetBCName(spline.bc)
+
+        if "pml_" + spline_name in normals \
+        and normals["pml_" + spline_name] != spline.GetNormal(0):
+            duplicate_cnt += 1
+            spline_name = spline_name + "_duplicate_" + str(duplicate_cnt)
+
+        if (new_end - global_start).Norm() < tol:
+            new_spline_domains.append(ndoms)
+            geo.Append(["line", current_start, global_start_pnt], bc="outer_" + spline_name, leftdomain = ndoms)
+            geo.Append(["line", global_start_pnt, endpointindex_map[i]], leftdomain=ndoms, rightdomain=start_ndoms)
+            geo.SetMaterial(ndoms, "pml_" + spline_name)
+            normals["pml_" + spline_name] = spline.GetNormal(0)
+            ndoms += 1
+            break
+        end = geo.AppendPoint(new_end[0], new_end[1])
+        new_spline_domains.append(ndoms)
+        geo.Append(["line", current_start, end], bc="outer_" + spline_name, leftdomain = ndoms)
+        geo.Append(["line", end, endpointindex_map[i]], leftdomain=ndoms, rightdomain=ndoms+1)
+        geo.SetMaterial(ndoms, "pml_" + spline_name)
+        normals["pml_" + spline_name] = spline.GetNormal(0)
+        ndoms += 1
+        new_start = Start(next_spline) + pml_size * next_spline.GetNormal(0)
+        if (new_start - global_start).Norm() < tol:
+            geo.Append(["line", end, global_start_pnt], bc="outer", leftdomain = ndoms)
+            geo.Append(["line", global_start_pnt, endpointindex_map[i]], leftdomain=ndoms, rightdomain=start_ndoms)
+            geo.SetMaterial(ndoms, "pml_corner")
+            ndoms += 1
+            break
+        if (new_end - new_start).Norm() < tol:
+            current_start = end
+        else:
+            current_start = geo.AppendPoint(new_start[0], new_start[1])
+            geo.Append(["line", end, current_start], bc="outer", leftdomain = ndoms)
+            geo.Append(["line", current_start, endpointindex_map[i]], leftdomain=ndoms, rightdomain=ndoms+1)
+            geo.SetMaterial(ndoms, "pml_corner")
+            ndoms += 1
+    for spline, domnr in zip(border, new_spline_domains):
+        if spline.leftdom == 0:
+            spline.leftdom = domnr
+        else:
+            spline.rightdom = domnr
+    return {"normals" : normals}
+
+SplineGeometry.AddCircle = lambda geo, c, r, **args : MakeCircle(geo, c, r, **args)
+SplineGeometry.AddRectangle = lambda geo, p1, p2, **args : MakeRectangle(geo, p1, p2, **args)
+SplineGeometry.AddSegment = lambda *args, **kwargs : SplineGeometry.Append(*args, **kwargs)
+SplineGeometry.AddPoint = lambda *args, **kwargs : SplineGeometry.AppendPoint(*args, **kwargs)
+SplineGeometry.CreatePML = CreatePML
+
+bc = lambda s : EdgeInfo(bc=s)
+maxh = lambda h : EdgeInfo(maxh=h)
+def cp(p_or_px, py_or_none = None):
+    if py_or_none is None:
+        return EdgeInfo(control_point=p)
+    else:
+        return EdgeInfo(control_point=(p_or_px,py_or_none))
+
+
+def Ellipse(center, a, b, bc="ellipse", mat="ellipse"):
+    """Creates ellipse centered at point center with principle axis a and b.
+
+    Parameters
+    ---------
+    center : Vec2
+      center of ellipse
+    a : Vec2
+      first principle axis, needs to be perpendicular to b
+    b : Vec2
+      second principle axis, needs to be perpendicular to a
+    bc : string
+      boundary name
+    mat : string
+      material name
+    """
+    if abs(a[0]*b[0] + a[1]*b[1]) > 1e-12:
+        raise Exception("In Ellipse: principle axis a and b are not perpendicular")
+    
+    ellipse = Circle( center=(0,0), radius=1.0, mat=mat, bc=bc )
+    
+    alpha = math.pi/2-math.atan2(a[0],a[1])
+    r_a = math.sqrt(a[0]**2+a[1]**2)
+    r_b = math.sqrt(b[0]**2+b[1]**2)
+    ellipse.Scale( (r_a,r_b) )
+    ellipse.Rotate( alpha/math.pi*180, center=(0,0) )
+    ellipse.Move( center )
+    
+    return ellipse

netgen/gui.py

@@ -0,0 +1,82 @@
+import netgen
+
+from . import libngguipy
+from . import libngpy
+
+def StartGUI():
+    from tkinter import Tk
+    from netgen import config
+    import sys, os
+
+    try:
+        # the GUI tries to load ngsolve.tcl (which loads ngsolve shared libraries)
+        # BUT might fail to load dependencies (like mkl), these are handled by the
+        # ngsolve __init__.py script, so import ngsolve from python already here
+        import ngsolve
+    except:
+        pass
+
+    global win
+    win = Tk()
+    win.tk.eval('lappend ::auto_path ' + netgen._netgen_lib_dir)
+    win.tk.eval('lappend ::auto_path ' + netgen._netgen_bin_dir)
+    # load with absolute path to avoid issues on MacOS
+    win.tk.eval('load "'+netgen._netgen_lib_dir.replace('\\','/')+'/libnggui[info sharedlibextension]" gui')
+
+    if config.is_python_package and 'darwin' in sys.platform:
+        # libngsolve and other libraries are installed into netgen python dir to keep relative installation paths, but tcl won't find them there automatically
+        netgen_dir = os.path.abspath(os.path.dirname(netgen.__file__))
+        win.tk.eval(f'set netgen_library_dir {netgen_dir}')
+
+    win.tk.eval( netgen.libngpy._meshing._ngscript)
+
+    try:
+        from IPython import get_ipython
+        ipython = get_ipython()
+        ipython.magic('gui tk')
+    except:
+        pass
+
+    def _Redraw(*args, **kwargs):
+        if libngpy._meshing._Redraw(*args, **kwargs):
+            import netgen
+            import tkinter
+            cnt = 0
+            while(win.tk.dooneevent(tkinter._tkinter.DONT_WAIT) and cnt < 100):
+                cnt += 1
+
+    netgen._Redraw = _Redraw
+    _Redraw(blocking=True)
+
+    
+
+def Snapshot(w,h, filename=None):
+    netgen.Redraw(blocking=True)
+    import numpy
+    image = netgen.libngguipy.Snapshot(w, h)
+    image = numpy.array(image, dtype=numpy.uint8).reshape(h, w, 3)
+    image = image[::-1,:,:]
+    if filename:
+        import PIL.Image
+        im = PIL.Image.fromarray(image)
+        im.save(filename)
+    return image
+
+def run_pyfile(filename):
+    with open(filename) as f:
+        exec(f.read(), {})
+
+if __name__ == "__main__":
+    import sys, threading
+    StartGUI()
+    if(len(sys.argv) > 1):
+        if(sys.argv[1].endswith(".py")):
+            t = threading.Thread(target=run_pyfile, args=(sys.argv[1],),
+                                 daemon=True)
+            t.start()
+    win.mainloop()
+else:
+    if not netgen.libngpy._meshing._netgen_executable_started:
+        import os
+        if not "NETGEN_DOCUMENTATION_RST_FORMAT" in os.environ:
+            StartGUI()