Copy disabled (too large)
Download .txt
Showing preview only (10,657K chars total). Download the full file to get everything.
Repository: NGSolve/netgen
Branch: master
Commit: d61126401248
Files: 690
Total size: 10.1 MB
Directory structure:
gitextract_bskl7z7q/
├── .clang-format
├── .gitignore
├── .gitlab-ci.yml
├── .gitmodules
├── AUTHORS
├── CMakeLists.txt
├── CONTRIBUTING.md
├── ChangeLog
├── INSTALL
├── LICENSE
├── NEWS
├── README.md
├── TODO
├── cmake/
│ ├── NetgenConfig.cmake.in
│ ├── SuperBuild.cmake
│ ├── check_submodules.cmake
│ ├── cmake_modules/
│ │ ├── FindFFMPEG.cmake
│ │ └── FindMETIS.cmake
│ ├── cmake_uninstall.cmake.in
│ ├── external_projects/
│ │ ├── catch.cmake
│ │ ├── cgns.cmake
│ │ ├── metis.cmake
│ │ ├── spdlog.cmake
│ │ ├── tcltk.cmake
│ │ └── zlib.cmake
│ ├── generate_version_file.cmake
│ ├── mic.cmake
│ └── netgen_fixup.cmake
├── depcomp
├── doc/
│ ├── CMakeLists.txt
│ ├── element_types.tex
│ └── ng4.tex
├── external_dependencies/
│ └── .gitignore
├── libsrc/
│ ├── CMakeLists.txt
│ ├── core/
│ │ ├── .clang-tidy
│ │ ├── CMakeLists.txt
│ │ ├── _get_glibcxx_use_cxx11_abi.cpp
│ │ ├── _get_gxx_abi.cpp
│ │ ├── archive.cpp
│ │ ├── archive.hpp
│ │ ├── array.hpp
│ │ ├── autodiff.hpp
│ │ ├── autodiffdiff.hpp
│ │ ├── bitarray.cpp
│ │ ├── bitarray.hpp
│ │ ├── concurrentqueue.h
│ │ ├── exception.cpp
│ │ ├── exception.hpp
│ │ ├── flags.cpp
│ │ ├── flags.hpp
│ │ ├── generate_mpi_sources.py
│ │ ├── hashtable.hpp
│ │ ├── localheap.cpp
│ │ ├── localheap.hpp
│ │ ├── logging.cpp
│ │ ├── logging.hpp
│ │ ├── memtracer.hpp
│ │ ├── mpi4py_pycapi.h
│ │ ├── mpi_wrapper.hpp
│ │ ├── ng_mpi.cpp
│ │ ├── ng_mpi.hpp
│ │ ├── ng_mpi_generated_declarations.hpp
│ │ ├── ng_mpi_generated_dummy_init.hpp
│ │ ├── ng_mpi_generated_init.hpp
│ │ ├── ng_mpi_native.hpp
│ │ ├── ng_mpi_wrapper.cpp
│ │ ├── ngcore.hpp
│ │ ├── ngcore_api.hpp
│ │ ├── ngstream.hpp
│ │ ├── paje_trace.cpp
│ │ ├── paje_trace.hpp
│ │ ├── profiler.cpp
│ │ ├── profiler.hpp
│ │ ├── python_ngcore.cpp
│ │ ├── python_ngcore.hpp
│ │ ├── python_ngcore_export.cpp
│ │ ├── ranges.hpp
│ │ ├── register_archive.hpp
│ │ ├── signal.hpp
│ │ ├── simd.hpp
│ │ ├── simd_arm64.hpp
│ │ ├── simd_avx.hpp
│ │ ├── simd_avx512.hpp
│ │ ├── simd_generic.hpp
│ │ ├── simd_math.hpp
│ │ ├── simd_sse.hpp
│ │ ├── statushandler.cpp
│ │ ├── statushandler.hpp
│ │ ├── symboltable.hpp
│ │ ├── table.cpp
│ │ ├── table.hpp
│ │ ├── taskmanager.cpp
│ │ ├── taskmanager.hpp
│ │ ├── type_traits.hpp
│ │ ├── utils.cpp
│ │ ├── utils.hpp
│ │ ├── version.cpp
│ │ ├── version.hpp
│ │ └── xbool.hpp
│ ├── csg/
│ │ ├── CMakeLists.txt
│ │ ├── algprim.cpp
│ │ ├── algprim.hpp
│ │ ├── brick.cpp
│ │ ├── brick.hpp
│ │ ├── bspline2d.cpp
│ │ ├── csg.hpp
│ │ ├── csgeom.cpp
│ │ ├── csgeom.hpp
│ │ ├── csgparser.cpp
│ │ ├── csgparser.hpp
│ │ ├── csgpkg.cpp
│ │ ├── curve2d.cpp
│ │ ├── curve2d.hpp
│ │ ├── edgeflw.cpp
│ │ ├── edgeflw.hpp
│ │ ├── explicitcurve2d.cpp
│ │ ├── explicitcurve2d.hpp
│ │ ├── extrusion.cpp
│ │ ├── extrusion.hpp
│ │ ├── gencyl.cpp
│ │ ├── gencyl.hpp
│ │ ├── genmesh.cpp
│ │ ├── geoml.hpp
│ │ ├── identify.cpp
│ │ ├── identify.hpp
│ │ ├── manifold.cpp
│ │ ├── manifold.hpp
│ │ ├── meshsurf.cpp
│ │ ├── meshsurf.hpp
│ │ ├── polyhedra.cpp
│ │ ├── polyhedra.hpp
│ │ ├── python_csg.cpp
│ │ ├── revolution.cpp
│ │ ├── revolution.hpp
│ │ ├── singularref.cpp
│ │ ├── singularref.hpp
│ │ ├── solid.cpp
│ │ ├── solid.hpp
│ │ ├── specpoin.cpp
│ │ ├── specpoin.hpp
│ │ ├── spline3d.cpp
│ │ ├── spline3d.hpp
│ │ ├── splinesurface.cpp
│ │ ├── splinesurface.hpp
│ │ ├── surface.cpp
│ │ ├── surface.hpp
│ │ ├── triapprox.cpp
│ │ ├── triapprox.hpp
│ │ ├── vscsg.cpp
│ │ ├── vscsg.hpp
│ │ └── zrefine.cpp
│ ├── general/
│ │ ├── CMakeLists.txt
│ │ ├── autodiff.hpp
│ │ ├── autoptr.hpp
│ │ ├── dynamicmem.cpp
│ │ ├── dynamicmem.hpp
│ │ ├── gzstream.cpp
│ │ ├── gzstream.h
│ │ ├── hashtabl.cpp
│ │ ├── hashtabl.hpp
│ │ ├── myadt.hpp
│ │ ├── mystring.cpp
│ │ ├── mystring.hpp
│ │ ├── netgenout.hpp
│ │ ├── ngarray.hpp
│ │ ├── ngbitarray.cpp
│ │ ├── ngbitarray.hpp
│ │ ├── ngpython.hpp
│ │ ├── optmem.cpp
│ │ ├── optmem.hpp
│ │ ├── parthreads.cpp
│ │ ├── parthreads.hpp
│ │ ├── seti.cpp
│ │ ├── seti.hpp
│ │ ├── sort.cpp
│ │ ├── sort.hpp
│ │ ├── spbita2d.cpp
│ │ ├── spbita2d.hpp
│ │ ├── stack.hpp
│ │ ├── table.cpp
│ │ ├── table.hpp
│ │ └── template.hpp
│ ├── geom2d/
│ │ ├── CMakeLists.txt
│ │ ├── csg2d.cpp
│ │ ├── csg2d.hpp
│ │ ├── genmesh2d.cpp
│ │ ├── geom2dpkg.cpp
│ │ ├── geometry2d.cpp
│ │ ├── geometry2d.hpp
│ │ ├── python_geom2d.cpp
│ │ ├── spline2d.hpp
│ │ ├── vsgeom2d.cpp
│ │ └── vsgeom2d.hpp
│ ├── gprim/
│ │ ├── CMakeLists.txt
│ │ ├── adtree.cpp
│ │ ├── adtree.hpp
│ │ ├── geom2d.cpp
│ │ ├── geom2d.hpp
│ │ ├── geom3d.cpp
│ │ ├── geom3d.hpp
│ │ ├── geomfuncs.cpp
│ │ ├── geomfuncs.hpp
│ │ ├── geomobjects.hpp
│ │ ├── geomops.hpp
│ │ ├── geomtest3d.cpp
│ │ ├── geomtest3d.hpp
│ │ ├── gprim.hpp
│ │ ├── spline.cpp
│ │ ├── spline.hpp
│ │ ├── splinegeometry.cpp
│ │ ├── splinegeometry.hpp
│ │ ├── transform3d.cpp
│ │ └── transform3d.hpp
│ ├── include/
│ │ ├── CMakeLists.txt
│ │ ├── acisgeom.hpp
│ │ ├── csg.hpp
│ │ ├── geometry2d.hpp
│ │ ├── gprim.hpp
│ │ ├── incopengl.hpp
│ │ ├── inctcl.hpp
│ │ ├── incvis.hpp
│ │ ├── linalg.hpp
│ │ ├── meshing.hpp
│ │ ├── myadt.hpp
│ │ ├── mydefs.hpp
│ │ ├── mystdlib.h
│ │ ├── nginterface.h
│ │ ├── nginterface_v2.hpp
│ │ ├── nginterface_v2_impl.hpp
│ │ ├── ngsimd.hpp
│ │ ├── occgeom.hpp
│ │ ├── opti.hpp
│ │ ├── parallel.hpp
│ │ ├── stlgeom.hpp
│ │ └── visual.hpp
│ ├── interface/
│ │ ├── CMakeLists.txt
│ │ ├── nginterface.cpp
│ │ ├── nginterface_v2.cpp
│ │ ├── read_fnf_mesh.cpp
│ │ ├── readtetmesh.cpp
│ │ ├── readuser.cpp
│ │ ├── rw_cgns.cpp
│ │ ├── rw_medit.cpp
│ │ ├── rw_medit.hpp
│ │ ├── writeOpenFOAM15x.cpp
│ │ ├── writeabaqus.cpp
│ │ ├── writediffpack.cpp
│ │ ├── writedolfin.cpp
│ │ ├── writeelmer.cpp
│ │ ├── writefeap.cpp
│ │ ├── writefluent.cpp
│ │ ├── writegmsh.cpp
│ │ ├── writegmsh2.cpp
│ │ ├── writejcm.cpp
│ │ ├── writepermas.cpp
│ │ ├── writetecplot.cpp
│ │ ├── writetet.cpp
│ │ ├── writetochnog.cpp
│ │ ├── writeuser.cpp
│ │ ├── writeuser.hpp
│ │ └── wuchemnitz.cpp
│ ├── linalg/
│ │ ├── CMakeLists.txt
│ │ ├── bfgs.cpp
│ │ ├── densemat.cpp
│ │ ├── densemat.hpp
│ │ ├── linalg.hpp
│ │ ├── linopt.cpp
│ │ ├── linsearch.cpp
│ │ ├── opti.hpp
│ │ ├── polynomial.cpp
│ │ ├── polynomial.hpp
│ │ └── vector.hpp
│ ├── meshing/
│ │ ├── CMakeLists.txt
│ │ ├── adfront2.cpp
│ │ ├── adfront2.hpp
│ │ ├── adfront3.cpp
│ │ ├── adfront3.hpp
│ │ ├── basegeom.cpp
│ │ ├── basegeom.hpp
│ │ ├── bcfunctions.cpp
│ │ ├── bcfunctions.hpp
│ │ ├── bisect.cpp
│ │ ├── bisect.hpp
│ │ ├── boundarylayer.cpp
│ │ ├── boundarylayer.hpp
│ │ ├── boundarylayer2d.cpp
│ │ ├── boundarylayer_interpolate.cpp
│ │ ├── boundarylayer_limiter.hpp
│ │ ├── classifyhpel.hpp
│ │ ├── clusters.cpp
│ │ ├── clusters.hpp
│ │ ├── curvedelems.cpp
│ │ ├── curvedelems.hpp
│ │ ├── debugging.cpp
│ │ ├── debugging.hpp
│ │ ├── delaunay.cpp
│ │ ├── delaunay2d.cpp
│ │ ├── delaunay2d.hpp
│ │ ├── fieldlines.cpp
│ │ ├── fieldlines.hpp
│ │ ├── findip.hpp
│ │ ├── findip2.hpp
│ │ ├── geomsearch.cpp
│ │ ├── geomsearch.hpp
│ │ ├── global.cpp
│ │ ├── global.hpp
│ │ ├── hpref_hex.hpp
│ │ ├── hpref_prism.hpp
│ │ ├── hpref_pyramid.hpp
│ │ ├── hpref_quad.hpp
│ │ ├── hpref_segm.hpp
│ │ ├── hpref_tet.hpp
│ │ ├── hpref_trig.hpp
│ │ ├── hprefinement.cpp
│ │ ├── hprefinement.hpp
│ │ ├── improve2.cpp
│ │ ├── improve2.hpp
│ │ ├── improve2gen.cpp
│ │ ├── improve3.cpp
│ │ ├── improve3.hpp
│ │ ├── localh.cpp
│ │ ├── localh.hpp
│ │ ├── meshclass.cpp
│ │ ├── meshclass.hpp
│ │ ├── meshfunc.cpp
│ │ ├── meshfunc.hpp
│ │ ├── meshfunc2d.cpp
│ │ ├── meshing.hpp
│ │ ├── meshing2.cpp
│ │ ├── meshing2.hpp
│ │ ├── meshing3.cpp
│ │ ├── meshing3.hpp
│ │ ├── meshtool.cpp
│ │ ├── meshtool.hpp
│ │ ├── meshtype.cpp
│ │ ├── meshtype.hpp
│ │ ├── msghandler.cpp
│ │ ├── msghandler.hpp
│ │ ├── netrule2.cpp
│ │ ├── netrule3.cpp
│ │ ├── parallelmesh.cpp
│ │ ├── paralleltop.cpp
│ │ ├── paralleltop.hpp
│ │ ├── parser2.cpp
│ │ ├── parser3.cpp
│ │ ├── python_mesh.cpp
│ │ ├── python_mesh.hpp
│ │ ├── refine.cpp
│ │ ├── ruler2.cpp
│ │ ├── ruler2.hpp
│ │ ├── ruler3.cpp
│ │ ├── ruler3.hpp
│ │ ├── secondorder.cpp
│ │ ├── smoothing2.5.cpp
│ │ ├── smoothing2.cpp
│ │ ├── smoothing3.cpp
│ │ ├── soldata.hpp
│ │ ├── specials.cpp
│ │ ├── specials.hpp
│ │ ├── surfacegeom.cpp
│ │ ├── surfacegeom.hpp
│ │ ├── topology.cpp
│ │ ├── topology.hpp
│ │ ├── validate.cpp
│ │ ├── validate.hpp
│ │ ├── visual_interface.cpp
│ │ └── visual_interface.hpp
│ ├── occ/
│ │ ├── CMakeLists.txt
│ │ ├── Partition_Inter2d.cxx
│ │ ├── Partition_Inter2d.hxx
│ │ ├── Partition_Inter2d.ixx
│ │ ├── Partition_Inter2d.jxx
│ │ ├── Partition_Inter3d.cxx
│ │ ├── Partition_Inter3d.hxx
│ │ ├── Partition_Inter3d.ixx
│ │ ├── Partition_Inter3d.jxx
│ │ ├── Partition_Loop.cxx
│ │ ├── Partition_Loop.hxx
│ │ ├── Partition_Loop.ixx
│ │ ├── Partition_Loop.jxx
│ │ ├── Partition_Loop2d.cxx
│ │ ├── Partition_Loop2d.hxx
│ │ ├── Partition_Loop2d.ixx
│ │ ├── Partition_Loop2d.jxx
│ │ ├── Partition_Loop3d.cxx
│ │ ├── Partition_Loop3d.hxx
│ │ ├── Partition_Loop3d.ixx
│ │ ├── Partition_Loop3d.jxx
│ │ ├── Partition_Spliter.cxx
│ │ ├── Partition_Spliter.hxx
│ │ ├── Partition_Spliter.ixx
│ │ ├── Partition_Spliter.jxx
│ │ ├── cross_section.cpp
│ │ ├── occ_edge.cpp
│ │ ├── occ_edge.hpp
│ │ ├── occ_face.cpp
│ │ ├── occ_face.hpp
│ │ ├── occ_solid.hpp
│ │ ├── occ_utils.cpp
│ │ ├── occ_utils.hpp
│ │ ├── occ_vertex.cpp
│ │ ├── occ_vertex.hpp
│ │ ├── occconstruction.cpp
│ │ ├── occgenmesh.cpp
│ │ ├── occgeom.cpp
│ │ ├── occgeom.hpp
│ │ ├── occmeshsurf.cpp
│ │ ├── occmeshsurf.hpp
│ │ ├── occpkg.cpp
│ │ ├── python_occ.cpp
│ │ ├── python_occ_basic.cpp
│ │ ├── python_occ_shapes.cpp
│ │ ├── utilities.h
│ │ ├── vsocc.cpp
│ │ └── vsocc.hpp
│ ├── stlgeom/
│ │ ├── CMakeLists.txt
│ │ ├── meshstlsurface.cpp
│ │ ├── meshstlsurface.hpp
│ │ ├── python_stl.cpp
│ │ ├── stlgeom.cpp
│ │ ├── stlgeom.hpp
│ │ ├── stlgeomchart.cpp
│ │ ├── stlgeommesh.cpp
│ │ ├── stlline.cpp
│ │ ├── stlline.hpp
│ │ ├── stlpkg.cpp
│ │ ├── stltool.cpp
│ │ ├── stltool.hpp
│ │ ├── stltopology.cpp
│ │ ├── stltopology.hpp
│ │ ├── vsstl.cpp
│ │ └── vsstl.hpp
│ └── visualization/
│ ├── CMakeLists.txt
│ ├── importsolution.cpp
│ ├── meshdoc.cpp
│ ├── meshdoc.hpp
│ ├── mvdraw.cpp
│ ├── mvdraw.hpp
│ ├── vispar.hpp
│ ├── visual.hpp
│ ├── visual_api.hpp
│ ├── visualpkg.cpp
│ ├── vsfieldlines.cpp
│ ├── vsmesh.cpp
│ ├── vssolution.cpp
│ └── vssolution.hpp
├── mkinstalldirs
├── netgen.icns
├── ng/
│ ├── CMakeLists.txt
│ ├── Togl2.1/
│ │ ├── CMakeLists.txt
│ │ ├── LICENSE
│ │ ├── Makefile.in
│ │ ├── README.stubs
│ │ ├── Togl.py
│ │ ├── Xmu/
│ │ │ ├── CmapAlloc.c
│ │ │ ├── CrCmap.c
│ │ │ ├── DelCmap.c
│ │ │ ├── LookupCmap.c
│ │ │ ├── README.togl
│ │ │ ├── StdCmap.c
│ │ │ └── StdCmap.h
│ │ ├── aclocal.m4
│ │ ├── ben.rgb
│ │ ├── configure
│ │ ├── configure.in
│ │ ├── doc/
│ │ │ ├── README.txt
│ │ │ ├── capi.html
│ │ │ ├── download.html
│ │ │ ├── faq.html
│ │ │ ├── header.js
│ │ │ ├── index.html
│ │ │ ├── stereo.html
│ │ │ ├── tclapi.html
│ │ │ ├── upgrading.html
│ │ │ └── using.html
│ │ ├── double.c
│ │ ├── double.tcl
│ │ ├── gears.c
│ │ ├── gears.tcl
│ │ ├── gl/
│ │ │ ├── glext.h
│ │ │ ├── glxext.h
│ │ │ └── wglext.h
│ │ ├── image.c
│ │ ├── image.h
│ │ ├── index.c
│ │ ├── index.tcl
│ │ ├── multisample.tcl
│ │ ├── overlay.c
│ │ ├── overlay.tcl
│ │ ├── pbuffer.c
│ │ ├── pbuffer.tcl
│ │ ├── pkgIndex.tcl.in
│ │ ├── stereo.c
│ │ ├── stereo.tcl
│ │ ├── tclconfig/
│ │ │ ├── install-sh
│ │ │ └── tcl.m4
│ │ ├── texture.c
│ │ ├── texture.tcl
│ │ ├── togl.c
│ │ ├── togl.decls
│ │ ├── togl.h
│ │ ├── toglAGL.c
│ │ ├── toglDecls.h
│ │ ├── toglFont.c
│ │ ├── toglGLX.c
│ │ ├── toglNSOpenGL.c
│ │ ├── toglProcAddr.c
│ │ ├── toglStubInit.c
│ │ ├── toglStubLib.c
│ │ ├── toglWGL.c
│ │ ├── togl_ws.h.in
│ │ ├── toglpy.h
│ │ └── tree2.rgba
│ ├── acisgeom.tcl
│ ├── csgeom.tcl
│ ├── demoview.cpp
│ ├── demoview.hpp
│ ├── dialog.tcl
│ ├── drawing.tcl
│ ├── drawing_togl17.tcl
│ ├── encoding.hpp
│ ├── fonts.hpp
│ ├── gui.cpp
│ ├── menustat.tcl
│ ├── netgen.ocf
│ ├── netgenpy.cpp
│ ├── ng.tcl
│ ├── ng_acis.hpp
│ ├── ngappinit.cpp
│ ├── ngguipy.cpp
│ ├── nghelp.tcl
│ ├── ngicon.tcl
│ ├── ngpkg.cpp
│ ├── ngshell.tcl
│ ├── ngtcl.cpp
│ ├── ngtesting.tcl
│ ├── ngvisual.tcl
│ ├── occgeom.tcl
│ ├── onetcl.cpp
│ ├── onetcl.py
│ ├── parallelfunc.cpp
│ ├── parallelfunc.hpp
│ ├── parameters.tcl
│ ├── sockets.tcl
│ ├── stlgeom.tcl
│ └── variables.tcl
├── nglib/
│ ├── CMakeLists.txt
│ ├── cube.surf
│ ├── hinge.stl
│ ├── netgen.py
│ ├── ng_occ.cpp
│ ├── ng_stl.cpp
│ ├── ng_vol.cpp
│ ├── nglib.cpp
│ ├── nglib.h
│ ├── nglib_occ.cpp
│ ├── nglib_occ.h
│ └── parallelfunc.cpp
├── py_tutorials/
│ ├── CMakeLists.txt
│ ├── csg2d.py
│ ├── csg_first_example.py
│ ├── cube.geo
│ ├── exportNeutral.py
│ ├── merge.py
│ ├── mesh.py
│ ├── opengl.py
│ ├── opengl_thread.py
│ ├── opengl_window.py
│ ├── python_geometry.py
│ └── shaft.geo
├── python/
│ ├── .gitignore
│ ├── CMakeLists.txt
│ ├── NgOCC.py
│ ├── __init__.py
│ ├── __main__.py
│ ├── config/
│ │ ├── __init__.py
│ │ ├── __main__.py
│ │ └── config_template.py
│ ├── csg.py
│ ├── gengeom.py
│ ├── gengeom_curve.py
│ ├── geom2d.py
│ ├── gui.py
│ ├── init_geom2d.py
│ ├── meshing.py
│ ├── occ.py
│ ├── pyngcore/
│ │ └── __init__.py
│ ├── read_gmsh.py
│ ├── read_meshio.py
│ ├── stl.py
│ ├── version_template.py
│ └── webgui.py
├── rules/
│ ├── CMakeLists.txt
│ ├── hexrules.rls
│ ├── makerlsfile.cpp
│ ├── prismrules2.rls
│ ├── prisms.rls
│ ├── pyramidrules.rls
│ ├── pyramidrules2.rls
│ ├── quadrules.rls
│ ├── tetrules.rls
│ └── triarules.rls
├── setup.py
├── tests/
│ ├── CMakeLists.txt
│ ├── build_debug.sh
│ ├── build_guidelines.sh
│ ├── build_mpi.sh
│ ├── build_ngsolve.sh
│ ├── build_nospdlog.sh
│ ├── build_pip.ps1
│ ├── build_pip.sh
│ ├── build_pip_mac.sh
│ ├── catch/
│ │ ├── CMakeLists.txt
│ │ ├── archive.cpp
│ │ ├── array.cpp
│ │ ├── main.cpp
│ │ ├── ranges.cpp
│ │ ├── symboltable.cpp
│ │ ├── utils.cpp
│ │ └── version.cpp
│ ├── dockerfile
│ ├── dockerfile_mpi
│ ├── pytest/
│ │ ├── CMakeLists.txt
│ │ ├── compare_results.py
│ │ ├── conftest.py
│ │ ├── geofiles/
│ │ │ └── plane.stl
│ │ ├── meshes.py
│ │ ├── test_array.py
│ │ ├── test_bitarray.py
│ │ ├── test_boundarylayer.py
│ │ ├── test_csg.py
│ │ ├── test_csg2d.py
│ │ ├── test_geom2d.py
│ │ ├── test_meshclass.py
│ │ ├── test_mpi4py.py
│ │ ├── test_nonnative_master
│ │ ├── test_occ.py
│ │ ├── test_occ_identifications.py
│ │ ├── test_pickling.py
│ │ ├── test_savemesh.py
│ │ ├── test_splinegeo_tensordomainmeshing.py
│ │ └── test_tutorials.py
│ └── utils.py
├── tutorials/
│ ├── CMakeLists.txt
│ ├── boundarycondition.geo
│ ├── boxcyl.geo
│ ├── circle_on_cube.geo
│ ├── cone.geo
│ ├── cube.geo
│ ├── cubeandring.geo
│ ├── cubeandspheres.geo
│ ├── cubemcyl.geo
│ ├── cubemsphere.geo
│ ├── cylinder.geo
│ ├── cylsphere.geo
│ ├── ellipsoid.geo
│ ├── ellipticcone.geo
│ ├── ellipticcyl.geo
│ ├── extrusion.geo
│ ├── fichera.geo
│ ├── frame.step
│ ├── hinge.stl
│ ├── lense.in2d
│ ├── lshape3d.geo
│ ├── manyholes.geo
│ ├── manyholes2.geo
│ ├── matrix.geo
│ ├── ortho.geo
│ ├── part1.stl
│ ├── period.geo
│ ├── revolution.geo
│ ├── screw.step
│ ├── sculpture.geo
│ ├── shaft.geo
│ ├── shell.geo
│ ├── sphere.geo
│ ├── sphereincube.geo
│ ├── square.in2d
│ ├── squarecircle.in2d
│ ├── squarehole.in2d
│ ├── test.dem
│ ├── torus.geo
│ ├── trafo.geo
│ ├── twobricks.geo
│ ├── twocubes.geo
│ └── twocyl.geo
└── windows/
├── .gitignore
├── CMakeLists.txt
├── netgen.rc.template
└── resource.h
================================================
FILE CONTENTS
================================================
================================================
FILE: .clang-format
================================================
Language: Cpp
BasedOnStyle: LLVM
AlignAfterOpenBracket: Align
AlignConsecutiveAssignments: false
AlignConsecutiveDeclarations: false
AlignEscapedNewlines: Left
AlignOperands: true
AlignTrailingComments: true
AllowAllParametersOfDeclarationOnNextLine: false
AllowShortBlocksOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: true
AllowShortFunctionsOnASingleLine: InlineOnly
AllowShortIfStatementsOnASingleLine: false
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakTemplateDeclarations: Yes
BinPackArguments: false
BinPackParameters: false
BreakBeforeBinaryOperators: NonAssignment
BreakBeforeBraces: Custom
BraceWrapping:
AfterClass: true
AfterControlStatement: true
AfterEnum: true
AfterFunction: true
AfterNamespace: true
AfterStruct: true
AfterUnion: true
BeforeCatch: true
BeforeElse: true
IndentBraces: true
BreakBeforeTernaryOperators: true
BreakConstructorInitializersBeforeComma: false
BreakInheritanceList: AfterColon
ColumnLimit: 0
ConstructorInitializerAllOnOneLineOrOnePerLine: true
ConstructorInitializerIndentWidth: 2
ContinuationIndentWidth: 2
Cpp11BracedListStyle: true
EmptyLineBeforeAccessModifier: Never
IndentCaseLabels: false
IndentPPDirectives: None
IndentWidth: 2
KeepEmptyLinesAtTheStartOfBlocks: false
MaxEmptyLinesToKeep: 1
NamespaceIndentation: None
PointerAlignment: Left
ReflowComments: true
SortIncludes: false
SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false
SpaceBeforeParens: Custom
SpaceBeforeParensOptions:
AfterControlStatements: true
AfterFunctionDefinitionName: true
AfterFunctionDeclarationName: true
SpacesInAngles: false
SpacesInContainerLiterals: false
SpacesInCStyleCastParentheses: false
SpacesInSquareBrackets: false
Standard: Latest
TabWidth: 2
UseTab: Never
================================================
FILE: .gitignore
================================================
*.whl
dist
build
*.vol.gz
*.vol
*.ini
__pycache__
*.json
*.zip
.cache
*.patch
================================================
FILE: .gitlab-ci.yml
================================================
stages:
- build
- test
- test_ngsolve
- deploy
- cleanup
push_github:
stage: build
tags:
- linux
- docker
- bash
script:
- git remote add github git@github.com:NGSolve/netgen.git || true
- git remote update
- git checkout --track origin/master
- git pull origin master
- git push github master --tags
only:
- master
############################################
# Windows
############################################
.template_windows: &win
tags:
- windows
- pip
before_script:
- |
$ErrorActionPreference = "Stop"
# Import MSVC environment from vcvars64.bat into the current PowerShell process
$vcvars = '"C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvars64.bat"'
cmd /c "$vcvars && set" |
ForEach-Object {
if ($_ -match '^(.*?)=(.*)$') {
[System.Environment]::SetEnvironmentVariable($matches[1], $matches[2])
Set-Item -Path "env:$($matches[1])" -Value $matches[2] -ErrorAction SilentlyContinue
}
}
$env:CI_DIR = "C:\ci\$env:CI_PIPELINE_ID"
$env:CCACHE_BASEDIR = $env:CI_DIR
$env:NETGEN_BUILD_DIR = Join-Path $env:CI_DIR "build"
$env:INSTALL_DIR = Join-Path $env:CI_DIR "install"
$env:SRC_DIR = Join-Path $env:CI_DIR "src"
$env:NETGENDIR = Join-Path $env:INSTALL_DIR "bin"
$env:PYTHONPATH = Join-Path $env:INSTALL_DIR "lib\site-packages"
Write-Output $env:PATH
$env:PATH = @(
(Join-Path $env:INSTALL_DIR "bin")
"C:\python314"
"C:\python314\bin"
"C:\python314\Scripts"
"C:\tools"
$env:PATH
) -join ";"
Write-Output $env:PATH
$env:CCACHE_HARDLINK = "1"
$env:CCACHE_NOHASHDIR = "1"
& "C:\tools\ccache.exe" -s
& "C:\tools\ccache.exe" -M "20G"
python.exe --version
cmake --version
build_win:
<<: *win
stage: build
script:
- |
New-Item -ItemType Directory -Force -Path $env:SRC_DIR | Out-Null
Get-ChildItem -Force | Copy-Item -Destination $env:SRC_DIR -Recurse -Force
python.exe -m pip install -U netgen-occt netgen-occt-devel ninja cmake
Set-Location $env:SRC_DIR
git submodule update --init --recursive
if (Test-Path $env:NETGEN_BUILD_DIR) {
Remove-Item $env:NETGEN_BUILD_DIR -Recurse -Force
}
New-Item -ItemType Directory -Force -Path $env:NETGEN_BUILD_DIR | Out-Null
Set-Location $env:NETGEN_BUILD_DIR
cmake $env:SRC_DIR `
-G Ninja `
-DCMAKE_PREFIX=C:/python314 `
-DPython3_ROOT_DIR=C:/python314 `
-DCMAKE_INSTALL_PREFIX="$($env:INSTALL_DIR)" `
-DCHECK_RANGE=ON `
-DUSE_CGNS=OFF `
-DUSE_OCC=ON `
-DUSE_CCACHE=ON `
-DENABLE_UNIT_TESTS=OFF `
-DCMAKE_BUILD_TYPE=Release
cmake --build . --target install --config Release
test_win:
<<: *win
stage: test
script:
- |
pip install pytest-check
Set-Location (Join-Path $env:NETGEN_BUILD_DIR "netgen")
ctest -C Release -V --output-on-failure
Set-Location ..
needs: ["build_win"]
generate_results:
<<: *win
stage: test
script:
- |
pip install pytest-check
Set-Location "tests\pytest"
python test_tutorials.py "new_results.json"
needs: ["build_win"]
when: manual
artifacts:
paths:
- tests/pytest/new_results.json
when: always
expire_in: 1 week
cleanup_win:
<<: *win
stage: cleanup
script:
- |
Set-Location $env:CI_PROJECT_DIR
if (Test-Path $env:CI_DIR) {
Remove-Item $env:CI_DIR -Recurse -Force
}
when: always
allow_failure: true
needs: ["test_win"]
############################################
# Ubuntu/Linux
############################################
.template_ubuntu: &ubuntu
tags:
- linux
- bash
before_script:
- pwd
- ls
- docker info
- export PYTHONPATH=/opt/netgen/`python3 -c "import os.path, sysconfig;print(os.path.relpath(sysconfig.get_path('platlib'), sysconfig.get_path('data')))"`
variables:
UBUNTU_VERSION: "22.04"
build_ubuntu_debug:
<<: *ubuntu
stage: build
script:
- docker build -t netgen_${CI_PIPELINE_ID}:${UBUNTU_VERSION} -f tests/dockerfile .
- rm -f netgen_${CI_PIPELINE_ID}_$UBUNTU_VERSION.id
- >-
docker run
--cidfile netgen_${CI_PIPELINE_ID}_${UBUNTU_VERSION}.id
-e CCACHE_DIR=/ccache
-e PYTHONPATH=$PYTHONPATH
-v /mnt/ccache:/ccache
netgen_${CI_PIPELINE_ID}:${UBUNTU_VERSION}
bash /root/src/netgen/tests/build_debug.sh
- docker commit `cat netgen_${CI_PIPELINE_ID}_${UBUNTU_VERSION}.id` netgen_${CI_PIPELINE_ID}_installed:${UBUNTU_VERSION}
- rm netgen_${CI_PIPELINE_ID}_${UBUNTU_VERSION}.id
build_ubuntu_mpi:
<<: *ubuntu
stage: build
script:
- docker build -t netgen_mpi_${CI_PIPELINE_ID}:${UBUNTU_VERSION} -f tests/dockerfile_mpi .
- rm -f netgen_mpi_${CI_PIPELINE_ID}_$UBUNTU_VERSION.id_mpi
- >-
docker run>-
--cidfile netgen_mpi_${CI_PIPELINE_ID}_${UBUNTU_VERSION}.id>-
-e CCACHE_DIR=/ccache
-e PYTHONPATH=$PYTHONPATH
-e RUN_SLOW_TESTS=${RUN_SLOW_TESTS}
-v /mnt/ccache:/ccache
netgen_mpi_${CI_PIPELINE_ID}:${UBUNTU_VERSION}
bash /root/src/netgen/tests/build_mpi.sh
- docker commit `cat netgen_mpi_${CI_PIPELINE_ID}_${UBUNTU_VERSION}.id` netgen_mpi_${CI_PIPELINE_ID}_installed:${UBUNTU_VERSION}
- rm netgen_mpi_${CI_PIPELINE_ID}_${UBUNTU_VERSION}.id
test_ubuntu_debug:
<<: *ubuntu
stage: test
script:
- >-
docker run
-e PYTHONPATH=$PYTHONPATH
netgen_${CI_PIPELINE_ID}_installed:${UBUNTU_VERSION}
bash -c 'cd /root/build/netgen && make test_netgen ARGS="-V --output-on-failure"'
needs: ["build_ubuntu_debug"]
test_ubuntu_mpi:
<<: *ubuntu
stage: test
script:
- >-
docker run
-e RUN_SLOW_TESTS=${RUN_SLOW_TESTS}
-e PYTHONPATH=$PYTHONPATH
netgen_mpi_${CI_PIPELINE_ID}_installed:${UBUNTU_VERSION}
bash -c 'cd /root/build/netgen && make test_netgen ARGS="-V --output-on-failure"'
needs: ["build_ubuntu_mpi"]
test_build_ngsolve:
<<: *ubuntu
allow_failure: true
stage: test_ngsolve
script:
- >-
docker run
-e NETGENDIR=/opt/netgen/bin
-e PYTHONPATH=$PYTHONPATH
-e MKLROOT=/opt/intel/mkl
-v /opt/intel:/opt/intel
-e CCACHE_DIR=/ccache
-v /mnt/ccache:/ccache
netgen_${CI_PIPELINE_ID}_installed:${UBUNTU_VERSION}
bash -c 'cd /root/src/netgen/tests/ && ./build_ngsolve.sh'
cleanup_ubuntu:
stage: cleanup
tags:
- linux
- bash
script:
# remove intermediate and old docker images and containers
- docker rm -f `docker ps --no-trunc -aq`
- docker images --no-trunc -aqf "dangling=true" | xargs docker rmi -f || true
- docker rmi -f netgen_${CI_PIPELINE_ID}:${UBUNTU_VERSION} || true
- docker rmi -f netgen_${CI_PIPELINE_ID}_installed:${UBUNTU_VERSION} || true
- docker rmi -f netgen_mpi_${CI_PIPELINE_ID}:${UBUNTU_VERSION} || true
- docker rmi -f netgen_mpi_${CI_PIPELINE_ID}_installed:${UBUNTU_VERSION} || true
when: always
allow_failure: true
############################################
# MacOSX
############################################
.template_mac: &mac
tags:
- macosx
- m1
before_script:
- export PATH=/Library/Frameworks/Python.framework/Versions/3.14/bin:$PATH
- export ROOT_DIR=/tmp/$CI_PIPELINE_ID
- export SRC_DIR=$ROOT_DIR/src
- export BUILD_DIR=$ROOT_DIR/build
- export CMAKE_INSTALL_PREFIX=/tmp/$CI_PIPELINE_ID/install/Netgen.app
- export PYTHONPATH=$CMAKE_INSTALL_PREFIX/Contents/Resources/`python3 -c "import os.path, sysconfig;print(os.path.relpath(sysconfig.get_path('platlib'), sysconfig.get_path('data')))"`:.
- export PATH=$CMAKE_INSTALL_PREFIX/Contents/MacOS:$PATH
build_mac:
<<: *mac
stage: build
script:
- python3 -m pip install -U netgen-occt netgen-occt-devel cmake pytest-check
- git submodule update --init --recursive
- rm -rf $BUILD_DIR
- mkdir -p $BUILD_DIR
- rm -rf $SRC_DIR
- mkdir -p $SRC_DIR
- cp -a . $SRC_DIR/
- cd $BUILD_DIR
- >-
cmake $SRC_DIR
-DCMAKE_INSTALL_PREFIX=$CMAKE_INSTALL_PREFIX
-DCMAKE_BUILD_TYPE=Release
-DCHECK_RANGE=ON
-DUSE_NATIVE_ARCH=ON
-DUSE_CCACHE=ON
-DENABLE_UNIT_TESTS=ON
-DCMAKE_OSX_DEPLOYMENT_TARGET=10.15
-DCMAKE_OSX_SYSROOT=/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk
-DUSE_CGNS=OFF
-DPython3_ROOT_DIR=/Library/Frameworks/Python.framework/Versions/3.14
-DUSE_OCC=ON
- make -j5 install
test_mac:
<<: *mac
stage: test
script:
- cd $BUILD_DIR/netgen
- ctest . -V --output-on-failure
needs: ["build_mac"]
cleanup_mac:
<<: *mac
stage: cleanup
script:
- rm -rf $ROOT_DIR
when: always
allow_failure: true
needs: ["test_mac"]
pip_linux:
image: quay.io/pypa/manylinux_2_28_x86_64
stage: build
tags:
- pip
- linux
- docker
script:
- ./tests/build_pip.sh
when: manual
pip_windows:
stage: build
tags:
- pip
- windows
script:
- .\tests\build_pip.ps1 C:\Python314
- .\tests\build_pip.ps1 C:\Python313
- .\tests\build_pip.ps1 C:\Python312
- .\tests\build_pip.ps1 C:\Python311
- .\tests\build_pip.ps1 C:\Python310
when: manual
pip_macos:
stage: build
tags:
- pip
- macosx
- m1
script:
- ./tests/build_pip_mac.sh 3.14
- ./tests/build_pip_mac.sh 3.13
- ./tests/build_pip_mac.sh 3.12
- ./tests/build_pip_mac.sh 3.11
- ./tests/build_pip_mac.sh 3.10
when: manual
================================================
FILE: .gitmodules
================================================
[submodule "external_dependencies/pybind11"]
path = external_dependencies/pybind11
url = https://github.com/ngsolve/pybind11.git
================================================
FILE: AUTHORS
================================================
Joachim Schoeberl <joachim.schoeberl@tuwien.ac.at>
================================================
FILE: CMakeLists.txt
================================================
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE "RelWithDebInfo" CACHE STRING INTERNAL)
endif(NOT CMAKE_BUILD_TYPE)
set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreadedDLL")
cmake_minimum_required(VERSION 3.16)
cmake_policy(VERSION 3.16)
if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.24.0")
cmake_policy(SET CMP0135 NEW)
endif()
include (CMakeDependentOption)
option( USE_NATIVE_ARCH "build for native cpu architecture" ON)
option( USE_GUI "build with GUI" ON )
option( USE_PYTHON "build with python interface" ON )
cmake_dependent_option( PREFER_SYSTEM_PYBIND11 "Use system wide PyBind11" OFF "USE_PYTHON" OFF)
option( USE_MPI "enable mpi parallelization" OFF )
option( USE_MPI_WRAPPER "enable mpi wrapper (run-time dispatch of MPI library calls)" OFF )
option( USE_OCC "build with OpenCascade geometry kernel interface" ON)
option( USE_STLGEOM "build with STL geometry support" ON)
option( USE_CSG "build with CSG kernel" ON)
option( USE_INTERFACE "build nginterface" ON)
option( USE_GEOM2D "build 2d geometry kernels" ON)
option( USE_JPEG "enable snapshots using library libjpeg" OFF )
option( USE_MPEG "enable video recording with FFmpeg, uses libavcodec" OFF )
option( USE_CGNS "enable CGNS file read/write support" OFF )
option( USE_NUMA "compile with NUMA-aware code")
option( INTEL_MIC "cross compile for intel xeon phi")
option( INSTALL_PROFILES "install environment variable settings to /etc/profile.d" OFF )
option( USE_CCACHE "use ccache")
option( USE_INTERNAL_TCL "Compile tcl files into the code and don't install them" ON)
option( ENABLE_UNIT_TESTS "Enable Catch unit tests")
option( ENABLE_CPP_CORE_GUIDELINES_CHECK "Enable cpp core guideline checks on ngcore" OFF)
option( DEBUG_LOG "Enable more debug output (may increase computation time) - only works with USE_SPDLOG=ON" OFF)
option( CHECK_RANGE "Check array range access, automatically enabled if built in debug mode" OFF)
option( BUILD_STUB_FILES "Build stub files for better autocompletion" ON)
option( BUILD_FOR_CONDA "Link python libraries only to executables" OFF)
option( USE_SUPERBUILD "build dependencies automatically" ON)
option( TRACE_MEMORY "Enable memory tracing" OFF)
set(NG_COMPILE_FLAGS "" CACHE STRING "Additional compile flags")
set(NGLIB_LIBRARY_TYPE SHARED CACHE STRING "nglib library type")
set(NGCORE_LIBRARY_TYPE SHARED CACHE STRING "ngcore library type")
set(NGGUI_LIBRARY_TYPE SHARED CACHE STRING "nggui library type")
set(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}" "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_modules")
if(APPLE)
set(INSTALL_DIR_DEFAULT /Applications/Netgen.app)
else(APPLE)
if(WIN32)
set(INSTALL_DIR_DEFAULT "C:/netgen")
else(WIN32)
set(INSTALL_DIR_DEFAULT /opt/netgen)
endif(WIN32)
endif(APPLE)
if(INSTALL_DIR)
message(WARNING "INSTALL_DIR is deprecated, use CMAKE_INSTALL_PREFIX instead")
set(INSTALL_DIR_DEFAULT ${INSTALL_DIR})
endif(INSTALL_DIR)
if(UNIX AND USE_SUPERBUILD)
message("Checking for write permissions in install directory...")
execute_process(COMMAND mkdir -p ${CMAKE_INSTALL_PREFIX})
execute_process(COMMAND test -w ${CMAKE_INSTALL_PREFIX} RESULT_VARIABLE res)
if(res)
message(WARNING "No write access at install directory, please set correct permissions")
endif()
endif(UNIX AND USE_SUPERBUILD)
if (USE_SUPERBUILD)
project (SUPERBUILD)
else()
project(Netgen)
endif()
if (CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
set(CMAKE_INSTALL_PREFIX "${INSTALL_DIR_DEFAULT}" CACHE PATH "Install directory" FORCE)
endif()
set(NG_INSTALL_SUFFIX netgen CACHE STRING "Suffix appended to install directories (project name)")
if(USE_PYTHON)
if(${CMAKE_VERSION} VERSION_GREATER_EQUAL 3.18)
find_package(Python3 REQUIRED COMPONENTS Development.Module)
if(NOT EMSCRIPTEN)
find_package(Python3 COMPONENTS Interpreter Development.Embed)
endif()
else()
find_package(Python3 REQUIRED COMPONENTS Interpreter Development)
endif()
if(NOT CMAKE_CROSSCOMPILING)
find_package(Python3 REQUIRED COMPONENTS Interpreter)
execute_process(COMMAND ${Python3_EXECUTABLE} -c "import os.path, sysconfig;print(os.path.relpath(sysconfig.get_path('platlib'), sysconfig.get_path('data')))" OUTPUT_VARIABLE PYTHON_PACKAGES_INSTALL_DIR OUTPUT_STRIP_TRAILING_WHITESPACE)
file(TO_CMAKE_PATH ${PYTHON_PACKAGES_INSTALL_DIR} PYTHON_PACKAGES_INSTALL_DIR)
endif(NOT CMAKE_CROSSCOMPILING)
endif(USE_PYTHON)
if(APPLE AND NOT EMSCRIPTEN)
set(NG_INSTALL_DIR_BIN_DEFAULT Contents/MacOS)
set(NG_INSTALL_DIR_LIB_DEFAULT Contents/MacOS)
set(NG_INSTALL_DIR_CMAKE_DEFAULT Contents/Resources/CMake)
set(NG_INSTALL_DIR_PYTHON_DEFAULT Contents/Resources/${PYTHON_PACKAGES_INSTALL_DIR})
set(NG_INSTALL_DIR_RES_DEFAULT Contents/Resources/share)
set(NG_INSTALL_DIR_INCLUDE_DEFAULT Contents/Resources/include)
set(NG_RPATH_TOKEN "@loader_path")
else(APPLE AND NOT EMSCRIPTEN)
set(NG_INSTALL_DIR_BIN_DEFAULT bin)
set(NG_INSTALL_DIR_LIB_DEFAULT lib)
if(WIN32)
set(NG_INSTALL_DIR_CMAKE_DEFAULT cmake)
else(WIN32)
set(NG_INSTALL_DIR_CMAKE_DEFAULT lib/cmake/${NG_INSTALL_SUFFIX})
endif(WIN32)
set(NG_INSTALL_DIR_PYTHON_DEFAULT ${PYTHON_PACKAGES_INSTALL_DIR})
set(NG_INSTALL_DIR_RES_DEFAULT share)
set(NG_INSTALL_DIR_INCLUDE_DEFAULT include)
set(NG_RPATH_TOKEN "\$ORIGIN")
endif(APPLE AND NOT EMSCRIPTEN)
set(NG_INSTALL_DIR_PYTHON ${NG_INSTALL_DIR_PYTHON_DEFAULT} CACHE STRING "Install directory for Python files")
set(NG_INSTALL_DIR_BIN ${NG_INSTALL_DIR_BIN_DEFAULT} CACHE STRING "Install directory for executables")
set(NG_INSTALL_DIR_LIB ${NG_INSTALL_DIR_LIB_DEFAULT} CACHE STRING "Install directory for libraries")
set(NG_INSTALL_DIR_INCLUDE ${NG_INSTALL_DIR_INCLUDE_DEFAULT} CACHE STRING "Install directory for header files")
set(NG_INSTALL_DIR_CMAKE ${NG_INSTALL_DIR_CMAKE_DEFAULT} CACHE STRING "Install directory for CMake files")
set(NG_INSTALL_DIR_RES ${NG_INSTALL_DIR_RES_DEFAULT} CACHE STRING "Install directory for resources")
get_filename_component(NETGEN_CMAKE_DIR_ABSOLUTE ${NG_INSTALL_DIR_CMAKE} ABSOLUTE BASE_DIR ${CMAKE_INSTALL_PREFIX})
get_filename_component(NETGEN_BINARY_DIR_ABSOLUTE ${NG_INSTALL_DIR_BIN} ABSOLUTE BASE_DIR ${CMAKE_INSTALL_PREFIX})
get_filename_component(NETGEN_LIBRARY_DIR_ABSOLUTE ${NG_INSTALL_DIR_LIB} ABSOLUTE BASE_DIR ${CMAKE_INSTALL_PREFIX})
get_filename_component(NETGEN_INCLUDE_DIR_ABSOLUTE ${NG_INSTALL_DIR_INCLUDE} ABSOLUTE BASE_DIR ${CMAKE_INSTALL_PREFIX})
get_filename_component(NETGEN_RESOURCE_DIR_ABSOLUTE ${NG_INSTALL_DIR_RES} ABSOLUTE BASE_DIR ${CMAKE_INSTALL_PREFIX})
file(RELATIVE_PATH NETGEN_DIR ${NETGEN_CMAKE_DIR_ABSOLUTE} ${CMAKE_INSTALL_PREFIX})
file(RELATIVE_PATH NETGEN_BINARY_DIR ${NETGEN_CMAKE_DIR_ABSOLUTE} ${NETGEN_BINARY_DIR_ABSOLUTE})
file(RELATIVE_PATH NETGEN_LIBRARY_DIR ${NETGEN_CMAKE_DIR_ABSOLUTE} ${NETGEN_LIBRARY_DIR_ABSOLUTE})
file(RELATIVE_PATH NETGEN_INCLUDE_DIR ${NETGEN_CMAKE_DIR_ABSOLUTE} ${NETGEN_INCLUDE_DIR_ABSOLUTE})
file(RELATIVE_PATH NETGEN_RESOURCE_DIR ${NETGEN_CMAKE_DIR_ABSOLUTE} ${NETGEN_RESOURCE_DIR_ABSOLUTE})
file(RELATIVE_PATH NETGEN_RPATH ${NETGEN_BINARY_DIR_ABSOLUTE} ${NETGEN_LIBRARY_DIR_ABSOLUTE})
if (USE_SUPERBUILD)
# execute the superbuild (this script will be invoked again without the
# USE_SUPERBUILD option this time)
include (cmake/SuperBuild.cmake)
return() # stop processing this file further
endif()
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
include (${CMAKE_CURRENT_LIST_DIR}/cmake/generate_version_file.cmake)
set(CPACK_PACKAGE_VERSION "${NETGEN_VERSION}")
#######################################################################
if(USE_CCACHE)
find_program(CCACHE_FOUND NAMES ccache ccache.bat)
if(CCACHE_FOUND)
set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${CCACHE_FOUND})
message(STATUS "Using ccache ${CCACHE_FOUND}")
endif(CCACHE_FOUND)
endif(USE_CCACHE)
#######################################################################
if(INTEL_MIC)
set(MKL_ARCH "mic")
include(cmake/mic.cmake)
else(INTEL_MIC)
set(MKL_ARCH "intel64")
endif(INTEL_MIC)
#######################################################################
# Append install paths of software in non-standard paths (e.g. openmpi, metis, intel mkl, ...)
# cmake -DUSE_MPI=ON -DCMAKE_PREFIX_PATH="/opt/openmpi165;/opt/metis51" ../
set(ADDITIONAL_PATHS "" CACHE PATH "List of paths to additional libraries in non-standard locations, separated by ';'")
if (ADDITIONAL_PATHS)
set(CMAKE_PREFIX_PATH ${ADDITIONAL_PATHS})
endif (ADDITIONAL_PATHS)
#######################################################################
# build options
include_directories ("${PROJECT_SOURCE_DIR}/include")
include_directories ("${PROJECT_SOURCE_DIR}/libsrc")
include_directories ("${PROJECT_SOURCE_DIR}/libsrc/include")
include_directories ("${PROJECT_BINARY_DIR}")
set(CMAKE_INCLUDE_CURRENT_DIR ON)
if(USE_PYTHON)
get_filename_component(NETGEN_PYTHON_DIR_ABSOLUTE ${NG_INSTALL_DIR_PYTHON} ABSOLUTE BASE_DIR ${CMAKE_INSTALL_PREFIX})
file(RELATIVE_PATH NETGEN_PYTHON_DIR ${NETGEN_CMAKE_DIR_ABSOLUTE} ${NETGEN_PYTHON_DIR_ABSOLUTE})
file(RELATIVE_PATH NETGEN_PYTHON_RPATH_BIN ${NETGEN_PYTHON_DIR_ABSOLUTE} ${NETGEN_BINARY_DIR_ABSOLUTE})
file(RELATIVE_PATH NETGEN_PYTHON_RPATH ${NETGEN_PYTHON_DIR_ABSOLUTE} ${NETGEN_LIBRARY_DIR_ABSOLUTE})
if(WIN32)
set(NETGEN_PYTHON_RPATH ${NETGEN_PYTHON_RPATH_BIN})
endif(WIN32)
endif(USE_PYTHON)
set(NG_INSTALL_DIR EXPORT netgen-targets RUNTIME DESTINATION ${NG_INSTALL_DIR_BIN} COMPONENT netgen LIBRARY DESTINATION ${NG_INSTALL_DIR_LIB} COMPONENT netgen_devel ARCHIVE DESTINATION ${NG_INSTALL_DIR_LIB} COMPONENT netgen_devel)
install(EXPORT netgen-targets DESTINATION ${NG_INSTALL_DIR_CMAKE} COMPONENT netgen_devel)
set(CMAKE_MACOSX_RPATH TRUE)
set(CMAKE_INSTALL_RPATH "${NG_RPATH_TOKEN};${NG_RPATH_TOKEN}/${NETGEN_RPATH}")
if(BUILD_FOR_CONDA)
file(RELATIVE_PATH py_rpath "/bin" "/${NG_INSTALL_DIR_LIB}")
set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_RPATH};${py_rpath}")
endif(BUILD_FOR_CONDA)
include (CheckIncludeFiles)
check_include_files (dlfcn.h HAVE_DLFCN_H)
if(HAVE_DLFCN_H)
add_definitions(-DHAVE_DLFCN_H)
endif()
include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR})
#######################################################################
# platform specific definitions and flags
macro(get_WIN32_WINNT version)
if (WIN32 AND CMAKE_SYSTEM_VERSION)
if("${CMAKE_SYSTEM_VERSION}" MATCHES "^([0-9]+)\\.([0-9]+)")
math(EXPR ver "${CMAKE_MATCH_1}*100 + ${CMAKE_MATCH_2}")
endif()
set(${version} "0x${ver}")
endif()
endmacro()
macro(get_dll_from_lib dll_path lib_path)
get_filename_component(parent_lib_path ${lib} DIRECTORY)
get_filename_component(lib_name ${lib} name)
endmacro()
set(CMAKE_CXX_VISIBILITY_PRESET hidden)
set(CMAKE_CXX_STANDARD 17)
if(WIN32)
set(CMAKE_MFC_FLAG 0)
endif(WIN32)
if(APPLE)
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -undefined dynamic_lookup")
endif(APPLE)
#######################################################################
add_library(nglib ${NGLIB_LIBRARY_TYPE})
if(USE_GUI)
add_library(nggui ${NGGUI_LIBRARY_TYPE})
if(WIN32)
set_target_properties( nggui PROPERTIES OUTPUT_NAME "libnggui")
endif(WIN32)
endif(USE_GUI)
#######################################################################
if(NOT ZLIB_INCLUDE_DIRS)
find_package(ZLIB REQUIRED)
endif(NOT ZLIB_INCLUDE_DIRS)
target_include_directories(nglib PRIVATE ${ZLIB_INCLUDE_DIRS})
if(USE_GUI)
target_include_directories(nggui PRIVATE ${ZLIB_INCLUDE_DIRS})
endif(USE_GUI)
#######################################################################
if(WIN32)
add_library(netgen_gui INTERFACE IMPORTED)
else()
add_library(netgen_gui INTERFACE)
endif()
if (USE_GUI)
find_package(TCL 8.5 REQUIRED)
find_package(TclStub 8.5 REQUIRED)
find_package(Threads REQUIRED)
if(APPLE)
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -framework AppKit")
target_link_libraries(netgen_gui INTERFACE "-framework AppKit")
else(APPLE)
find_package(X11 REQUIRED)
target_link_libraries( netgen_gui INTERFACE ${X11_Xmu_LIB} ${X11_X11_LIB})
endif(APPLE)
find_package(OpenGL REQUIRED)
target_compile_definitions(netgen_gui INTERFACE -DTCL -DOPENGL -DUSE_TOGL_2 -DUSE_TCL_STUBS -DUSE_TK_STUBS)
target_include_directories(netgen_gui INTERFACE ${TCL_INCLUDE_PATH} ${TK_INCLUDE_PATH})
target_link_libraries(netgen_gui INTERFACE ${TCL_STUB_LIBRARY} ${TK_STUB_LIBRARY})
if(NOT EXISTS ${TK_INCLUDE_PATH}/tkWin.h AND EXISTS ${TK_INCLUDE_PATH}/../win/tkWin.h)
target_include_directories(netgen_gui INTERFACE ${TK_INCLUDE_PATH}/../win)
endif()
if(NOT EXISTS ${TK_INCLUDE_PATH}/x11/Xlib.h AND EXISTS ${TK_INCLUDE_PATH}/../xlib/X11/Xlib.h)
target_include_directories(netgen_gui INTERFACE ${TK_INCLUDE_PATH}/../xlib)
endif()
target_link_libraries(nggui PUBLIC nglib togl PRIVATE "$<BUILD_INTERFACE:netgen_python>" )
if(WIN32)
target_compile_definitions(netgen_gui INTERFACE -DTOGL_WGL)
endif()
if(APPLE)
target_compile_definitions(netgen_gui INTERFACE -DTOGL_NSOPENGL)
endif()
if(UNIX AND NOT APPLE)
target_compile_definitions(netgen_gui INTERFACE -DTOGL_X11)
endif()
endif (USE_GUI)
#######################################################################
if(WIN32)
add_library(netgen_python INTERFACE IMPORTED)
else()
add_library(netgen_python INTERFACE)
endif()
if (USE_PYTHON)
if (PREFER_SYSTEM_PYBIND11)
set(NG_INSTALL_PYBIND OFF)
find_package(pybind11 CONFIG REQUIRED)
else()
add_subdirectory(external_dependencies/pybind11)
endif()
target_compile_definitions(netgen_python INTERFACE NG_PYTHON NETGEN_PYTHON)
target_include_directories(netgen_python INTERFACE ${pybind11_INCLUDE_DIR} ${Python3_INCLUDE_DIRS})
target_include_directories(nglib PRIVATE ${pybind11_INCLUDE_DIR} ${Python3_INCLUDE_DIRS})
if(Python3_LIBRARIES AND (WIN32 OR NOT BUILD_FOR_CONDA))
target_link_libraries(netgen_python INTERFACE ${Python3_LIBRARIES})
endif()
if(NG_INSTALL_PYBIND)
install(DIRECTORY ${pybind11_INCLUDE_DIR}/pybind11 DESTINATION ${NG_INSTALL_DIR_INCLUDE} COMPONENT netgen_devel)
install(FILES ${pybind11_INCLUDE_DIR}/../LICENSE DESTINATION ${NG_INSTALL_DIR_INCLUDE}/pybind11 COMPONENT netgen_devel)
endif(NG_INSTALL_PYBIND)
endif (USE_PYTHON)
#######################################################################
add_library(netgen_metis INTERFACE)
if (USE_MPI)
set(MPI_DETERMINE_LIBRARY_VERSION TRUE)
find_package(MPI)
find_package(METIS REQUIRED)
target_include_directories(netgen_metis INTERFACE ${METIS_INCLUDE_DIR})
target_link_libraries(netgen_metis INTERFACE ${METIS_LIBRARY} )
target_compile_definitions(netgen_metis INTERFACE METIS )
endif (USE_MPI)
#######################################################################
add_library(occ_libs INTERFACE IMPORTED)
if (USE_OCC)
find_package(OpenCascade NAMES OpenCASCADE opencascade REQUIRED CMAKE_FIND_ROOT_PATH_BOTH)
add_definitions(-DOCCGEOMETRY)
set(OCC_LIBRARIES
TKBO
TKBRep
TKBool
TKCAF
TKCDF
TKFillet
TKG2d
TKG3d
TKGeomAlgo
TKGeomBase
TKHLR
TKLCAF
TKMath
TKMesh
TKOffset
TKPrim
TKService
TKShHealing
TKTopAlgo
TKV3d
TKVCAF
TKXCAF
TKXSBase
TKernel
)
if(${OpenCASCADE_MAJOR_VERSION}.${OpenCASCADE_MINOR_VERSION} VERSION_GREATER_EQUAL 7.8)
list(APPEND OCC_LIBRARIES TKDEIGES TKDESTEP TKDESTL)
else()
list(APPEND OCC_LIBRARIES
TKIGES
TKSTEP
TKSTL
TKXDEIGES
TKXDESTEP
TKSTEP209
TKSTEPAttr
TKSTEPBase
)
endif()
if(UNIX AND NOT APPLE)
list(PREPEND OCC_LIBRARIES -Wl,--start-group)
list(APPEND OCC_LIBRARIES -Wl,--end-group)
endif()
target_link_libraries(occ_libs INTERFACE ${OCC_LIBRARIES})
get_target_property(occ_include_dir TKernel INTERFACE_INCLUDE_DIRECTORIES)
if(NOT occ_include_dir)
set(occ_include_dir ${OpenCASCADE_INCLUDE_DIR})
endif()
target_include_directories(occ_libs INTERFACE ${occ_include_dir})
message(STATUS "OpenCasCade include dirs: ${occ_include_dir}")
if(NOT OpenCASCADE_BUILD_SHARED_LIBS)
if(OpenCASCADE_WITH_FREETYPE)
find_library( FREETYPE NAMES freetype HINTS ${OpenCASCADE_LIBRARY_DIR})
list(APPEND OCC_LIBRARIES ${FREETYPE})
target_link_libraries(occ_libs INTERFACE ${FREETYPE})
if(UNIX AND NOT APPLE)
find_package(Fontconfig REQUIRED)
target_link_libraries(occ_libs INTERFACE ${Fontconfig_LIBRARIES})
endif()
endif(OpenCASCADE_WITH_FREETYPE)
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads REQUIRED)
target_link_libraries(occ_libs INTERFACE Threads::Threads)
endif()
if(WIN32 AND USE_GUI)
target_link_libraries(nggui PRIVATE Ws2_32.lib)
endif(WIN32 AND USE_GUI)
if(USE_GUI)
target_link_libraries(nggui PRIVATE occ_libs)
endif(USE_GUI)
endif (USE_OCC)
#######################################################################
if (USE_JPEG)
find_package(JPEG REQUIRED)
add_definitions(-DJPEGLIB)
include_directories(${JPEG_INCLUDE_DIR})
endif (USE_JPEG)
#######################################################################
if (USE_MPEG)
find_package(FFMPEG REQUIRED)
add_definitions(-DFFMPEG -D__STDC_CONSTANT_MACROS)
include_directories(${FFMPEG_INCLUDE_DIR})
endif (USE_MPEG)
#######################################################################
add_custom_target(ng_generate_version_file
${CMAKE_COMMAND}
-DBDIR=${CMAKE_CURRENT_BINARY_DIR}
-P ${CMAKE_CURRENT_LIST_DIR}/cmake/generate_version_file.cmake
)
#######################################################################
if(INSTALL_PROFILES)
file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/netgen.sh "#!/bin/sh\n")
file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/netgen.sh "export PATH=${CMAKE_INSTALL_PREFIX}/bin:$PATH\n")
file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/netgen.sh "export NETGENDIR=${CMAKE_INSTALL_PREFIX}/bin\n")
file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/netgen.sh "export PYTHONPATH=${CMAKE_INSTALL_PREFIX}/${PYTHON_PACKAGES_INSTALL_DIR}:.\n")
file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/netgen.sh "export LD_LIBRARY_PATH=${CMAKE_INSTALL_PREFIX}/lib:.\n")
install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/netgen.sh DESTINATION /etc/profile.d COMPONENT netgen)
string(ASCII 27 Esc)
file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/postinst "#!/bin/sh\n")
file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/postinst "echo \"${Esc}[0;31mPlease log out and in again or do 'source /etc/profile.d/netgen.sh' to load the correct environment variables!${Esc}[m\"")
set( CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA "${CMAKE_CURRENT_BINARY_DIR}/postinst")
endif(INSTALL_PROFILES)
#######################################################################
file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/fixup.cmake "\
include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/netgen_fixup.cmake)
set(APP ${CMAKE_INSTALL_PREFIX})
message(\${APP})
set(BU_CHMOD_BUNDLE_ITEMS ON)
file(GLOB libs ${CMAKE_INSTALL_PREFIX}/${NG_INSTALL_DIR_LIB}/*.dylib ${CMAKE_INSTALL_PREFIX}/${NG_INSTALL_DIR_LIB}/*.so)
message(\"\${libs}\")
netgen_fixup_bundle( \${APP}/Contents/MacOS/netgen \"\${libs}\" ${CMAKE_INSTALL_PREFIX}/${NG_INSTALL_DIR_LIB} )
execute_process(COMMAND ln -s /Applications ${CMAKE_INSTALL_PREFIX}/../Applications)
set (bundle_filename \$ENV{NETGEN_BUNDLE_NAME})
if(NOT bundle_filename)
set(bundle_filename netgen)
endif(NOT bundle_filename)
execute_process(COMMAND hdiutil create -volname Netgen -srcfolder ${CMAKE_INSTALL_PREFIX} -ov -format UDZO \${bundle_filename}-${PACKAGE_VERSION}.dmg)
")
add_custom_target(bundle COMMAND ${CMAKE_COMMAND} "-P" "${CMAKE_CURRENT_BINARY_DIR}/fixup.cmake")
#######################################################################
# CTest
enable_testing()
include(CTest)
if(ENABLE_UNIT_TESTS)
include(${CMAKE_CURRENT_LIST_DIR}/cmake/external_projects/catch.cmake)
endif(ENABLE_UNIT_TESTS)
#######################################################################
if(USE_SPDLOG)
include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/external_projects/spdlog.cmake)
include_directories(${SPDLOG_INCLUDE_DIR})
endif(USE_SPDLOG)
if(ENABLE_CPP_CORE_GUIDELINES_CHECK)
find_program(
CLANG_TIDY_EXE
NAMES "clang-tidy"
DOC "Path to clang-tidy executable"
)
if(NOT CLANG_TIDY_EXE)
message(WARNING "clang-tidy not found.")
else()
message(STATUS "clang-tidy found: ${CLANG_TIDY_EXE}")
set(DO_CLANG_TIDY "${CLANG_TIDY_EXE}" "-header-filter=libsrc/core/")
endif()
endif(ENABLE_CPP_CORE_GUIDELINES_CHECK)
add_library(netgen_cgns INTERFACE)
if(USE_CGNS)
find_library( CGNS_LIBRARY NAMES cgns cgnsdll )
find_path( CGNS_INCLUDE_DIR cgnslib.h )
target_compile_definitions(netgen_cgns INTERFACE NG_CGNS)
target_include_directories(netgen_cgns INTERFACE ${CGNS_INCLUDE_DIR})
target_link_libraries(netgen_cgns INTERFACE ${CGNS_LIBRARY})
if(NOT WIN32 AND NOT APPLE) # hdf5 is statically linked into cgns in Windows amd MacOS binaries
find_library(HDF5_LIBRARY NAMES hdf5 hdf5_serial)
target_link_libraries(netgen_cgns INTERFACE ${HDF5_LIBRARY})
endif(NOT WIN32 AND NOT APPLE)
endif(USE_CGNS)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/netgen_version.hpp ${CMAKE_CURRENT_BINARY_DIR}/netgen_config.hpp DESTINATION ${NG_INSTALL_DIR_INCLUDE}/include COMPONENT netgen_devel)
# include instead of add_subdirectory to recognize the generated source files properly
include(rules/CMakeLists.txt)
add_subdirectory(windows)
add_subdirectory(libsrc)
add_subdirectory(ng)
add_subdirectory(tutorials)
add_subdirectory(py_tutorials)
add_subdirectory(doc)
add_subdirectory(nglib)
add_subdirectory(tests)
#######################################################################
if(USE_NATIVE_ARCH)
if(WIN32)
include(CheckCXXSourceRuns)
check_cxx_source_runs("
#include <immintrin.h>
int main()
{
__m256d a{1.,2.,3.,4.};
__m256d b{2.,0.,3.,5.};
__m256d c = _mm256_mul_pd(a,b);
return 0;
} " NG_HAVE_AVX)
check_cxx_source_runs("
#include <immintrin.h>
int main()
{
__m256i a{1,2,3,4};
__m256i b{2,0,3,5};
__m256i c = _mm256_cmpgt_epi64 (a,b);
return 0;
} " NG_HAVE_AVX2)
check_cxx_source_runs("
#include <immintrin.h>
int main()
{
__m512d a{1.,2.,3.,4.};
__m512d b{5.,6.,7.,8.};
__m512d c = _mm512_mul_pd(a,b);
return 0;
} " NG_HAVE_AVX512)
if(NG_HAVE_AVX512)
target_compile_options(ngcore PUBLIC "/arch:AVX512")
message(STATUS "Build for AVX512 CPU")
elseif(NG_HAVE_AVX2)
target_compile_options(ngcore PUBLIC "/arch:AVX2")
message(STATUS "Build for AVX2 CPU")
elseif(NG_HAVE_AVX)
target_compile_options(ngcore PUBLIC "/arch:AVX")
message(STATUS "Build for AVX CPU")
else()
message(STATUS "Build for generic CPU")
endif()
elseif(APPLE AND CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64")
# no flag necessary/available on Apple M1
else()
target_compile_options(ngcore PUBLIC "-march=native")
endif(WIN32)
if(APPLE)
# work-around for bug in Xcode 11.3: https://forums.developer.apple.com/thread/121887
target_compile_options(ngcore PUBLIC "-fno-stack-check")
endif(APPLE)
endif(USE_NATIVE_ARCH)
if (USE_PYTHON)
add_subdirectory(python)
endif (USE_PYTHON)
#######################################################################
# Debian packager
if(UNIX)
set(CPACK_SOURCE_GENERATOR "TGZ")
set(CPACK_SOURCE_IGNORE_FILES "/cmake/;/build/;/.gz/;~$;${CPACK_SOURCE_IGNORE_FILES}")
set(CPACK_PACKAGE_VERSION ${PACKAGE_VERSION} )
set(CPACK_PACKAGE_NAME netgen)
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "automatic 3d tetrahedral mesh generator")
set(CPACK_PACKAGE_DESCRIPTION "NETGEN is an automatic 3d tetrahedral mesh generator. It accepts input from constructive solid geometry (CSG) or boundary representation (BRep) from STL file format. The connection to a geometry kernel allows the handling of IGES and STEP files. NETGEN contains modules for mesh optimization and hierarchical mesh refinement. Netgen is open source based on the LGPL license. It is available for Unix/Linux and Windows.")
set(CPACK_PACKAGING_INSTALL_PREFIX "/opt/netgen")
execute_process(COMMAND grep CODENAME /etc/lsb-release OUTPUT_VARIABLE temp OUTPUT_STRIP_TRAILING_WHITESPACE)
execute_process(COMMAND dpkg --print-architecture OUTPUT_VARIABLE CPACK_DEBIAN_PACKAGE_ARCHITECTURE OUTPUT_STRIP_TRAILING_WHITESPACE)
if(temp)
set(CPACK_GENERATOR "DEB")
string(SUBSTRING ${temp} 17 -1 UBUNTU_VERSION)
message("ubuntu version: ${UBUNTU_VERSION}")
set(CPACK_DEBIAN_PACKAGE_DEPENDS "python3, libtk8.5, libtcl8.5, tix, libxmu6")
execute_process(COMMAND dpkg --print-architecture OUTPUT_VARIABLE CPACK_DEBIAN_PACKAGE_ARCHITECTURE OUTPUT_STRIP_TRAILING_WHITESPACE)
set(CPACK_DEBIAN_PACKAGE_MAINTAINER "Matthias Hochsteger <matthias.hochsteger@tuwien.ac.at>")
if(USE_MPI)
set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libmetis5, openmpi-bin")
set(CPACK_PACKAGE_NAME "${CPACK_PACKAGE_NAME}_mpi")
endif(USE_MPI)
if(USE_OCC)
set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, liboce-ocaf-dev")
endif(USE_OCC)
set(CPACK_DEBIAN_PACKAGE_SECTION Science)
set(CPACK_DEBIAN_PACKAGE_NAME ${CPACK_PACKAGE_NAME})
set(CPACK_PACKAGE_FILE_NAME "netgen-${PACKAGE_VERSION}_${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}")
endif(temp)
endif(UNIX)
if(USE_PYTHON AND NOT SKBUILD)
# install egg file to let python/pip know that Netgen ist installed
file( WRITE "netgen_mesher-py3.egg-info"
"Metadata-Version: 2.1
Name: netgen-mesher
Version: ${NETGEN_VERSION_MAJOR}.${NETGEN_VERSION_MINOR}.${NETGEN_VERSION_PATCH}.post${NETGEN_VERSION_TWEAK}
")
install(FILES netgen_mesher-py3.egg-info DESTINATION ${NG_INSTALL_DIR_PYTHON} COMPONENT netgen)
endif()
if(APPLE AND NOT SKBUILD)
# create some auxiliary files
set(mac_startup ${CMAKE_CURRENT_BINARY_DIR}/startup.sh)
file(WRITE ${mac_startup} "\
#!/bin/sh
Netgen_BUNDLE=\"`echo \"$0\" | sed -e 's/\\/Contents\\/MacOS\\/startup.sh//'`\"
Netgen_MACOS=\"$Netgen_BUNDLE/Contents/MacOS\"
export NETGENDIR=$Netgen_MACOS
export DYLD_LIBRARY_PATH=$Netgen_MACOS:$DYLD_LIBRARY_PATH
# export TIX_LIBRARY=$Netgen_MACOS/library
# export TCLLIBPATH=$Netgen_MACOS:$TCLLIBPATH
export PYTHONPATH=$Netgen_BUNDLE/Contents/Resources/${PYTHON_PACKAGES_INSTALL_DIR}:$PYTHONPATH
cd $Netgen_MACOS
$Netgen_MACOS/netgen
")
install(PROGRAMS ${mac_startup} DESTINATION ${NG_INSTALL_DIR_BIN})
set(mac_ngsuite ${CMAKE_CURRENT_BINARY_DIR}/ngsuite.sh)
file(WRITE ${mac_ngsuite} "\
#!/bin/sh
Netgen_BUNDLE=\"`echo \"$0\" | sed -e 's/\\/Contents\\/MacOS\\/Netgen1//'`\"
Netgen_MACOS=\"$Netgen_BUNDLE/Contents/MacOS\"
open -a /Applications/Utilities/Terminal.app $Netgen_MACOS/startup.sh || open -a /System/Applications/Utilities/Terminal.app $Netgen_MACOS/startup.sh
")
install(PROGRAMS ${mac_ngsuite} DESTINATION ${NG_INSTALL_DIR_BIN} RENAME Netgen1)
set(mac_plist ${CMAKE_CURRENT_BINARY_DIR}/Info.plist)
file(WRITE ${mac_plist} "<?xml version=\"1.0\" encoding=\"UTF-8\"?>
<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">
<plist version=\"1.0\">
<dict>
<key>CFBundleDevelopmentRegion</key>
<string>English</string>
<key>CFBundleExecutable</key>
<string>Netgen1</string>
<key>CFBundleIconFile</key>
<string>Netgen.icns</string>
<key>NSHighResolutionCapable</key>
<string>True</string>
</dict>
</plist>
")
install(FILES ${mac_plist} DESTINATION ${NG_INSTALL_DIR_BIN}/../)
install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/netgen.icns DESTINATION ${NG_INSTALL_DIR_RES}/../ RENAME Netgen.icns)
endif(APPLE AND NOT SKBUILD)
if(NOT APPLE)
include(CPack)
endif()
#######################################################################
# uninstall target
configure_file(
"${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in"
"${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
IMMEDIATE @ONLY)
add_custom_target(uninstall
COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
#######################################################################
# Generate package config file
set(NETGEN_MSVC_RUNTIME_LIBRARY ${CMAKE_MSVC_RUNTIME_LIBRARY})
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/NetgenConfig.cmake.in
${CMAKE_CURRENT_BINARY_DIR}/NetgenConfig.cmake @ONLY ESCAPE_QUOTES)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/NetgenConfig.cmake DESTINATION ${NG_INSTALL_DIR_CMAKE} COMPONENT netgen_devel)
#######################################################################
# Configure message
# TODO: other message in case of failure
string(TOUPPER "CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE}" name)
set(flags "${${name}} ${CMAKE_CXX_FLAGS}")
message("
------------------------------------------------------------------------
${PROJECT_NAME} ${PACKAGE_VERSION}: Automatic configuration OK.
Build type: ${CMAKE_BUILD_TYPE}
Flags: ${flags}
Enabled functionality:
OCC: ............... ${USE_OCC}
JPEGlib: ........... ${USE_JPEG}
FFMPEG: ............ ${USE_MPEG}
GUI: ............... ${USE_GUI}
MPI: ............... ${USE_MPI}
PYTHON: ............ ${USE_PYTHON}
Building: ")
if(WIN32)
message("
Open ${CMAKE_BINARY_DIR}/Netgen.sln and build solution to compile ${PROJECT_NAME}.
Build \"INSTALL\" to install ${PROJECT_NAME}.
")
else(WIN32)
message("
Type 'make' to compile ${PROJECT_NAME}.
Type 'make install' to install ${PROJECT_NAME}.
")
endif(WIN32)
message("
Install directory:
${CMAKE_INSTALL_PREFIX}
Please set the following environment variables:
NETGENDIR=${CMAKE_INSTALL_PREFIX}/bin")
if(USE_PYTHON)
message(" PYTHONPATH=.:${CMAKE_INSTALL_PREFIX}/${PYTHON_PACKAGES_INSTALL_DIR}")
endif(USE_PYTHON)
message("
------------------------------------------------------------------------
")
if (ADDITIONAL_PATHS)
message(WARNING "The use of ADDITIONAL_PATHS is deprecated, use CMAKE_PREFIX_PATH instead")
endif (ADDITIONAL_PATHS)
================================================
FILE: CONTRIBUTING.md
================================================
# How to Contribute
## Reporting issues
If you have a problem using Netgen/NGSolve consider asking a question in our [forum](https://ngsolve.org/forum).
If you found a bug create an issue in the [Github Issue Tracker](https://github.com/NGSolve/netgen/issues). Please be as specific as possible, issues with a reproducible minimal failing example will get more attention than unspecific one liners :)
## Contributing patches
We love and want to encourage community engagement and will review and accept patches and contributions to this project. There are just a few steps to follow:
On your first contribution, to clear any legal questions, we ask you to sign our [Contributor License Agreement](CLA.pdf). Generally you have to sign this only once for Netgen or NGSolve. Please send the signed agreement to <joachim.schoeberl@tuwien.ac.at>.
Place a pull request on GitHub. From there we will pull it into our internal testing environment and, if approved, merge it into the main codebase.
If you have any questions feel free to ask on the [forum](https://ngsolve.org/forum).
================================================
FILE: ChangeLog
================================================
================================================
FILE: INSTALL
================================================
Basic Installation
==================
These are generic installation instructions.
The `configure' shell script attempts to guess correct values for
various system-dependent variables used during compilation. It uses
those values to create a `Makefile' in each directory of the package.
It may also create one or more `.h' files containing system-dependent
definitions. Finally, it creates a shell script `config.status' that
you can run in the future to recreate the current configuration, a file
`config.cache' that saves the results of its tests to speed up
reconfiguring, and a file `config.log' containing compiler output
(useful mainly for debugging `configure').
If you need to do unusual things to compile the package, please try
to figure out how `configure' could check whether to do them, and mail
diffs or instructions to the address given in the `README' so they can
be considered for the next release. If at some point `config.cache'
contains results you don't want to keep, you may remove or edit it.
The file `configure.in' is used to create `configure' by a program
called `autoconf'. You only need `configure.in' if you want to change
it or regenerate `configure' using a newer version of `autoconf'.
The simplest way to compile this package is:
1. `cd' to the directory containing the package's source code and type
`./configure' to configure the package for your system. If you're
using `csh' on an old version of System V, you might need to type
`sh ./configure' instead to prevent `csh' from trying to execute
`configure' itself.
Running `configure' takes a while. While running, it prints some
messages telling which features it is checking for.
2. Type `make' to compile the package.
3. Type `make install' to install the programs and any data files and
documentation.
4. You can remove the program binaries and object files from the
source code directory by typing `make clean'.
Compilers and Options
=====================
Some systems require unusual options for compilation or linking that
the `configure' script does not know about. You can give `configure'
initial values for variables by setting them in the environment. Using
a Bourne-compatible shell, you can do that on the command line like
this:
CC=c89 CFLAGS=-O2 LIBS=-lposix ./configure
Or on systems that have the `env' program, you can do it like this:
env CPPFLAGS=-I/usr/local/include LDFLAGS=-s ./configure
Compiling For Multiple Architectures
====================================
You can compile the package for more than one kind of computer at the
same time, by placing the object files for each architecture in their
own directory. To do this, you must use a version of `make' that
supports the `VPATH' variable, such as GNU `make'. `cd' to the
directory where you want the object files and executables to go and run
the `configure' script. `configure' automatically checks for the
source code in the directory that `configure' is in and in `..'.
If you have to use a `make' that does not supports the `VPATH'
variable, you have to compile the package for one architecture at a time
in the source code directory. After you have installed the package for
one architecture, use `make distclean' before reconfiguring for another
architecture.
Installation Names
==================
By default, `make install' will install the package's files in
`/usr/local/bin', `/usr/local/man', etc. You can specify an
installation prefix other than `/usr/local' by giving `configure' the
option `--prefix=PATH'.
You can specify separate installation prefixes for
architecture-specific files and architecture-independent files. If you
give `configure' the option `--exec-prefix=PATH', the package will use
PATH as the prefix for installing programs and libraries.
Documentation and other data files will still use the regular prefix.
If the package supports it, you can cause programs to be installed
with an extra prefix or suffix on their names by giving `configure' the
option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
Optional Features
=================
Some packages pay attention to `--enable-FEATURE' options to
`configure', where FEATURE indicates an optional part of the package.
They may also pay attention to `--with-PACKAGE' options, where PACKAGE
is something like `gnu-as' or `x' (for the X Window System). The
`README' should mention any `--enable-' and `--with-' options that the
package recognizes.
For packages that use the X Window System, `configure' can usually
find the X include and library files automatically, but if it doesn't,
you can use the `configure' options `--x-includes=DIR' and
`--x-libraries=DIR' to specify their locations.
Specifying the System Type
==========================
There may be some features `configure' can not figure out
automatically, but needs to determine by the type of host the package
will run on. Usually `configure' can figure that out, but if it prints
a message saying it can not guess the host type, give it the
`--host=TYPE' option. TYPE can either be a short name for the system
type, such as `sun4', or a canonical name with three fields:
CPU-COMPANY-SYSTEM
See the file `config.sub' for the possible values of each field. If
`config.sub' isn't included in this package, then this package doesn't
need to know the host type.
If you are building compiler tools for cross-compiling, you can also
use the `--target=TYPE' option to select the type of system they will
produce code for and the `--build=TYPE' option to select the type of
system on which you are compiling the package.
Sharing Defaults
================
If you want to set default values for `configure' scripts to share,
you can create a site shell script called `config.site' that gives
default values for variables like `CC', `cache_file', and `prefix'.
`configure' looks for `PREFIX/share/config.site' if it exists, then
`PREFIX/etc/config.site' if it exists. Or, you can set the
`CONFIG_SITE' environment variable to the location of the site script.
A warning: not all `configure' scripts look for a site script.
Operation Controls
==================
`configure' recognizes the following options to control how it
operates.
`--cache-file=FILE'
Use and save the results of the tests in FILE instead of
`./config.cache'. Set FILE to `/dev/null' to disable caching, for
debugging `configure'.
`--help'
Print a summary of the options to `configure', and exit.
`--quiet'
`--silent'
`-q'
Do not print messages saying which checks are being made.
`--srcdir=DIR'
Look for the package's source code in directory DIR. Usually
`configure' can determine that directory automatically.
`--version'
Print the version of Autoconf used to generate the `configure'
script, and exit.
`configure' also accepts some other, not widely useful, options.
================================================
FILE: LICENSE
================================================
GNU LESSER GENERAL PUBLIC LICENSE
Version 2.1, February 1999
Copyright (C) 1991, 1999 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the Lesser GPL. It also counts
as the successor of the GNU Library Public License, version 2, hence
the version number 2.1.]
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it. You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.
When we speak of free software, we are referring to freedom of use,
not price. Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.
To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights. These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.
To protect each distributor, we want to make it very clear that
there is no warranty for the free library. Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.
Finally, software patents pose a constant threat to the existence of
any free program. We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder. Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.
Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License. This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License. We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.
When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library. The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom. The Lesser General
Public License permits more lax criteria for linking other code with
the library.
We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License. It also provides other free software developers Less
of an advantage over competing non-free programs. These disadvantages
are the reason we use the ordinary General Public License for many
libraries. However, the Lesser license provides advantages in certain
special circumstances.
For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it becomes
a de-facto standard. To achieve this, non-free programs must be
allowed to use the library. A more frequent case is that a free
library does the same job as widely used non-free libraries. In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.
In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software. For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.
Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.
GNU LESSER GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (1) uses at run time a
copy of the library already present on the user's computer system,
rather than copying library functions into the executable, and (2)
will operate properly with a modified version of the library, if
the user installs one, as long as the modified version is
interface-compatible with the version that the work was made with.
c) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
d) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
e) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
NO WARRANTY
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Libraries
If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change. You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).
To apply these terms, attach the following notices to the library. It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.
<one line to give the library's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Also add information on how to contact you by electronic and paper mail.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
<signature of Ty Coon>, 1 April 1990
Ty Coon, President of Vice
That's all there is to it!
================================================
FILE: NEWS
================================================
================================================
FILE: README.md
================================================
Netgen mesh generator
NETGEN is an automatic 3d tetrahedral mesh generator. It accepts input from constructive solid geometry (CSG) or boundary representation (BRep) from STL file format. The connection to a geometry kernel allows the handling of IGES and STEP files. NETGEN contains modules for mesh optimization and hierarchical mesh refinement. Netgen 6.x supports scripting via a Python interface. Netgen is open source based on the LGPL license. It is available for Unix/Linux, Windows, and OSX.
Find the Open Source Community on https://ngsolve.org
Support & Services: https://cerbsim.com
================================================
FILE: TODO
================================================
================================================
FILE: cmake/NetgenConfig.cmake.in
================================================
set(CMAKE_MSVC_RUNTIME_LIBRARY "@CMAKE_MSVC_RUNTIME_LIBRARY@")
set(NETGEN_VERSION "@NETGEN_VERSION@")
set(NETGEN_VERSION_MAJOR "@NETGEN_VERSION_MAJOR@")
set(NETGEN_VERSION_MINOR "@NETGEN_VERSION_MINOR@")
set(NETGEN_VERSION_PATCH "@NETGEN_VERSION_PATCH@")
set(NETGEN_VERSION_TWEAK "@NETGEN_VERSION_TWEAK@")
get_filename_component(NETGEN_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
get_filename_component(NETGEN_DIR "${NETGEN_CMAKE_DIR}/@NETGEN_DIR@" ABSOLUTE)
set(NETGEN_COMPILE_DEFINITIONS "@NETGEN_COMPILE_DEFINITIONS@")
get_filename_component(NETGEN_INCLUDE_DIR "${NETGEN_CMAKE_DIR}/@NETGEN_INCLUDE_DIR@" ABSOLUTE)
get_filename_component(NETGEN_BINARY_DIR "${NETGEN_CMAKE_DIR}/@NETGEN_BINARY_DIR@" ABSOLUTE)
get_filename_component(NETGEN_LIBRARY_DIR "${NETGEN_CMAKE_DIR}/@NETGEN_LIBRARY_DIR@" ABSOLUTE)
get_filename_component(NETGEN_PYTHON_DIR "${NETGEN_CMAKE_DIR}/@NETGEN_PYTHON_DIR@" ABSOLUTE)
get_filename_component(NETGEN_RESOURCE_DIR "${NETGEN_CMAKE_DIR}/@NETGEN_RESOURCE_DIR@" ABSOLUTE)
set(NETGEN_SOURCE_DIR "@PROJECT_SOURCE_DIR@")
set(NETGEN_BUILD_FOR_CONDA "@BUILD_FOR_CONDA@")
set(NETGEN_CHECK_RANGE "@CHECK_RANGE@")
set(NETGEN_INCLUDE_DIRS "${NETGEN_INCLUDE_DIR}/include;${NETGEN_INCLUDE_DIR}")
set(NETGEN_CMAKE_THREAD_LIBS_INIT "@CMAKE_THREAD_LIBS_INIT@")
set(NETGEN_FFMPEG_LIBRARIES "@FFMPEG_LIBRARIES@")
set(NETGEN_JPEG_INCLUDE_DIR "@JPEG_INCLUDE_DIR@")
set(NETGEN_JPEG_LIBRARIES "@JPEG_LIBRARIES@")
set(NETGEN_LIBTOGL "@LIBTOGL@")
set(NETGEN_METIS_INCLUDE_DIR "@METIS_INCLUDE_DIR@")
set(NETGEN_METIS_LIBRARY "@METIS_LIBRARY@")
set(NETGEN_MKL_LIBRARIES "@MKL_LIBRARIES@")
set(NETGEN_MPI_CXX_INCLUDE_PATH "@MPI_CXX_INCLUDE_PATH@")
set(NETGEN_MPI_CXX_LIBRARIES "@MPI_CXX_LIBRARIES@")
set(NETGEN_NUMA_LIBRARY "@NUMA_LIBRARY@")
set(NETGEN_OCC_DIR "@OpenCasCade_DIR@")
set(NETGEN_OCC_INCLUDE_DIR "@OpenCASCADE_INCLUDE_DIR@")
set(NETGEN_OCC_LIBRARIES_BIN "@OpenCASCADE_BINARY_DIR@")
set(NETGEN_OCC_LIBRARIES "@OCC_LIBRARIES@")
set(NETGEN_OCC_LIBRARY_DIR "@OpenCASCADE_LIBRARY_DIR@")
set(NETGEN_OPENGL_LIBRARIES "@OPENGL_LIBRARIES@")
set(NETGEN_PYTHON_EXECUTABLE "@Python3_EXECUTABLE@")
set(NETGEN_PYTHON_INCLUDE_DIRS "@Python3_INCLUDE_DIRS@")
set(NETGEN_PYTHON_LIBRARIES "@Python3_LIBRARIES@")
set(NETGEN_TCL_INCLUDE_PATH "@TCL_INCLUDE_PATH@")
set(NETGEN_TCL_LIBRARY "@TCL_STUB_LIBRARY@")
set(NETGEN_TK_DND_LIBRARY "@TK_DND_LIBRARY@")
set(NETGEN_TK_INCLUDE_PATH "@TK_INCLUDE_PATH@")
set(NETGEN_TK_LIBRARY "@TK_STUB_LIBRARY@")
set(NETGEN_X11_X11_LIB "@X11_X11_LIB@")
set(NETGEN_X11_Xmu_LIB "@X11_Xmu_LIB@")
set(NETGEN_ZLIB_INCLUDE_DIRS "@ZLIB_INCLUDE_DIRS@")
set(NETGEN_ZLIB_LIBRARIES "@ZLIB_LIBRARIES@")
set(NETGEN_USE_GUI @USE_GUI@)
set(NETGEN_USE_PYTHON @USE_PYTHON@)
set(NETGEN_USE_MPI @USE_MPI@)
set(NETGEN_USE_OCC @USE_OCC@)
set(NETGEN_USE_JPEG @USE_JPEG@)
set(NETGEN_USE_MPEG @USE_MPEG@)
set(NETGEN_USE_CGNS @USE_CGNS@)
set(NETGEN_INTEL_MIC @INTEL_MIC@)
set(NETGEN_INSTALL_PROFILES @INSTALL_PROFILES@)
set(NETGEN_USE_CCACHE @USE_CCACHE@)
set(NETGEN_USE_NATIVE_ARCH @USE_NATIVE_ARCH@)
set(NETGEN_USE_NUMA @USE_NUMA@)
set(NETGEN_PYTHON_RPATH "@NETGEN_PYTHON_RPATH@")
set(NETGEN_RPATH_TOKEN "@NG_RPATH_TOKEN@")
set(NETGEN_INSTALL_DIR_PYTHON @NG_INSTALL_DIR_PYTHON@)
set(NETGEN_INSTALL_DIR_BIN @NG_INSTALL_DIR_BIN@)
set(NETGEN_INSTALL_DIR_LIB @NG_INSTALL_DIR_LIB@)
set(NETGEN_INSTALL_DIR_INCLUDE @NG_INSTALL_DIR_INCLUDE@)
set(NETGEN_INSTALL_DIR_CMAKE @NG_INSTALL_DIR_CMAKE@)
set(NETGEN_INSTALL_DIR_RES @NG_INSTALL_DIR_RES@)
if (NETGEN_USE_PYTHON)
# Make sure we are finding the same Python version Netgen was built with
set(Python3_FIND_VERSION_MAJOR @Python3_VERSION_MAJOR@)
set(Python3_FIND_VERSION_MINOR @Python3_VERSION_MINOR@)
endif()
include(${CMAKE_CURRENT_LIST_DIR}/netgen-targets.cmake)
message(STATUS "Found Netgen: ${CMAKE_CURRENT_LIST_DIR}")
================================================
FILE: cmake/SuperBuild.cmake
================================================
include (ExternalProject)
option( BUILD_ZLIB "Build and link static version of zlib (useful for pip binaries)" OFF )
option( BUILD_OCC "Build and link static version of occ (useful for pip binaries)" OFF )
set_property (DIRECTORY PROPERTY EP_PREFIX dependencies)
set (NETGEN_DEPENDENCIES)
set (LAPACK_DEPENDENCIES)
set (NETGEN_CMAKE_ARGS "" CACHE INTERNAL "")
set (SUBPROJECT_CMAKE_ARGS "" CACHE INTERNAL "")
set (SUBPROJECT_ARGS
LIST_SEPARATOR |
PREFIX ${CMAKE_CURRENT_BINARY_DIR}/dependencies
)
if (EMSCRIPTEN)
set (SUBPROJECT_ARGS
${SUBPROJECT_ARGS}
CMAKE_COMMAND emcmake ${CMAKE_COMMAND})
endif()
# only show output on failure in ci-builds
if(DEFINED ENV{CI})
set (SUBPROJECT_ARGS
${SUBPROJECT_ARGS}
LOG_DOWNLOAD ON
LOG_BUILD ON
LOG_INSTALL ON
LOG_CONFIGURE ON
)
if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.14.0")
set (SUBPROJECT_ARGS
${SUBPROJECT_ARGS}
LOG_OUTPUT_ON_FAILURE ON
LOG_MERGED_STDOUTERR ON
)
endif()
endif()
set (NETGEN_CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} )
macro(set_vars VAR_OUT)
foreach(varname ${ARGN})
if(NOT "${${varname}}" STREQUAL "")
string(REPLACE ";" "|" varvalue "${${varname}}" )
set(${VAR_OUT} "${${VAR_OUT}};-D${varname}=${varvalue}" CACHE INTERNAL "")
endif()
endforeach()
endmacro()
#######################################################################
set_vars(SUBPROJECT_CMAKE_ARGS CMAKE_OSX_DEPLOYMENT_TARGET)
set_vars(SUBPROJECT_CMAKE_ARGS CMAKE_OSX_SYSROOT)
set_vars(SUBPROJECT_CMAKE_ARGS CMAKE_C_COMPILER)
set_vars(SUBPROJECT_CMAKE_ARGS CMAKE_CXX_COMPILER)
set_vars(SUBPROJECT_CMAKE_ARGS CMAKE_BUILD_TYPE)
set(SUBPROJECT_CMAKE_ARGS "${SUBPROJECT_CMAKE_ARGS};-DCMAKE_POSITION_INDEPENDENT_CODE=ON;-DCMAKE_POLICY_VERSION_MINIMUM=3.5" CACHE INTERNAL "")
if(USE_CCACHE)
find_program(CCACHE_FOUND NAMES ccache ccache.bat)
if(CCACHE_FOUND)
set(SUBPROJECT_CMAKE_ARGS "${SUBPROJECT_CMAKE_ARGS};-DCMAKE_CXX_COMPILER_LAUNCHER=${CCACHE_FOUND}" CACHE INTERNAL "")
endif()
endif()
#######################################################################
set (DEPS_DOWNLOAD_URL "https://github.com/NGSolve/ngsolve_dependencies/releases/download/v1.0.0" CACHE STRING INTERNAL)
set (OCC_DOWNLOAD_URL_WIN "${DEPS_DOWNLOAD_URL}/occ75_win64.zip" CACHE STRING INTERNAL)
set (TCLTK_DOWNLOAD_URL_WIN "${DEPS_DOWNLOAD_URL}/tcltk_win64.zip" CACHE STRING INTERNAL)
set (ZLIB_DOWNLOAD_URL_WIN "${DEPS_DOWNLOAD_URL}/zlib_win64.zip" CACHE STRING INTERNAL)
set (CGNS_DOWNLOAD_URL_WIN "${DEPS_DOWNLOAD_URL}/cgns_win64.zip" CACHE STRING INTERNAL)
set (CGNS_DOWNLOAD_URL_MAC "${DEPS_DOWNLOAD_URL}/cgns_mac.zip" CACHE STRING INTERNAL)
if(UNIX)
message("Checking for write permissions in install directory...")
execute_process(COMMAND mkdir -p ${CMAKE_INSTALL_PREFIX})
execute_process(COMMAND test -w ${CMAKE_INSTALL_PREFIX} RESULT_VARIABLE res)
if(res)
message(WARNING "No write access at install directory, please set correct permissions")
endif()
endif(UNIX)
if(USE_OCC)
if(BUILD_OCC)
set(OCC_DIR ${CMAKE_CURRENT_BINARY_DIR}/dependencies/occ)
ExternalProject_Add(project_occ
# URL https://github.com/Open-Cascade-SAS/OCCT/archive/refs/tags/V7_6_3.zip
# URL_MD5 2426e373903faabbd4f96a01a934b66d
# URL https://github.com/Open-Cascade-SAS/OCCT/archive/refs/tags/V7_7_2.zip
# URL_MD5 533eb4f18af0f77ae321b158caeaee79
URL https://github.com/Open-Cascade-SAS/OCCT/archive/refs/tags/V7_8_1.zip
URL_MD5 bf62952a03696dab9e4272aa8efacb1a
DOWNLOAD_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external_dependencies
${SUBPROJECT_ARGS}
CMAKE_ARGS
-DCMAKE_INSTALL_PREFIX=${OCC_DIR}
-DCMAKE_PREFIX_PATH=${OCC_DIR}
-DBUILD_LIBRARY_TYPE:STRING=Static
-DBUILD_MODULE_FoundationClasses:BOOL=ON
-DBUILD_MODULE_ModelingData:BOOL=ON
-DBUILD_MODULE_ModelingAlgorithms:BOOL=ON
-DBUILD_MODULE_DataExchange:BOOL=ON
-DBUILD_MODULE_Visualization:BOOL=OFF
-DBUILD_MODULE_ApplicationFramework:BOOL=OFF
-DBUILD_MODULE_Draw:BOOL=OFF
-DBUILD_MODULE_DETools:BOOL=OFF
-DUSE_FREETYPE:BOOL=OFF
-DUSE_OPENGL:BOOL=OFF
-DUSE_XLIB:BOOL=OFF
-DBUILD_DOC_Overview:BOOL=OFF
${SUBPROJECT_CMAKE_ARGS}
UPDATE_COMMAND ""
)
list(APPEND NETGEN_DEPENDENCIES project_occ)
set(OpenCascade_ROOT ${OCC_DIR})
else(BUILD_OCC)
find_package(OpenCascade NAMES OpenCasCade OpenCASCADE opencascade)
if(NOT OpenCascade_FOUND)
message(FATAL_ERROR "Opencascade not found, either\n\
- install pip packages netgen-occt-devel netgen-occt\n\
- set OpenCascade_DIR to a directory containting opencascadeConfig.cmake\n\
- build OpenCascade automatically by passing -DBUILD_OCC=ON\n\
- disable OpenCascade by passing -DUSE_OCC=OFF\n\
")
endif()
endif(BUILD_OCC)
endif(USE_OCC)
if(BUILD_ZLIB)
set(ZLIB_ROOT ${CMAKE_CURRENT_BINARY_DIR}/dependencies/zlib)
ExternalProject_Add(project_zlib
${SUBPROJECT_ARGS}
URL https://github.com/madler/zlib/archive/refs/tags/v1.2.11.zip
URL_MD5 9d6a627693163bbbf3f26403a3a0b0b1
DOWNLOAD_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external_dependencies
CMAKE_ARGS
-DCMAKE_INSTALL_PREFIX=${ZLIB_ROOT}
${SUBPROJECT_CMAKE_ARGS}
UPDATE_COMMAND "" # Disable update
BUILD_IN_SOURCE 1
)
list(APPEND NETGEN_DEPENDENCIES project_zlib)
if(WIN32)
# force linking the static library
set(ZLIB_INCLUDE_DIRS ${ZLIB_ROOT}/include)
set(ZLIB_LIBRARIES ${ZLIB_ROOT}/lib/zlibstatic.lib)
set(ZLIB_LIBRARY_RELEASE ${ZLIB_ROOT}/lib/zlibstatic.lib)
else(WIN32)
set(ZLIB_INCLUDE_DIRS ${ZLIB_ROOT}/include)
set(ZLIB_LIBRARIES ${ZLIB_ROOT}/lib/libz.a)
set(ZLIB_LIBRARY_RELEASE ${ZLIB_ROOT}/lib/libz.a)
endif(WIN32)
else()
include(cmake/external_projects/zlib.cmake)
endif()
#######################################################################
if (USE_PYTHON)
find_path(PYBIND_INCLUDE_DIR pybind11/pybind11.h PATHS ${CMAKE_CURRENT_SOURCE_DIR}/external_dependencies/pybind11/include NO_DEFAULT_PATH)
set(NG_INSTALL_PYBIND ON)
if( NOT PYBIND_INCLUDE_DIR )
# if the pybind submodule is missing, try to initialize and update all submodules
execute_process(COMMAND git submodule update --init --recursive WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
find_path(PYBIND_INCLUDE_DIR pybind11/pybind11.h PATHS ${CMAKE_CURRENT_SOURCE_DIR}/external_dependencies/pybind11/include NO_DEFAULT_PATH)
endif( NOT PYBIND_INCLUDE_DIR )
if( PYBIND_INCLUDE_DIR )
message("-- Found Pybind11: ${PYBIND_INCLUDE_DIR}")
else( PYBIND_INCLUDE_DIR )
message(FATAL_ERROR "Could NOT find pybind11!")
endif( PYBIND_INCLUDE_DIR )
if(${CMAKE_VERSION} VERSION_GREATER_EQUAL 3.18)
find_package(Python3 COMPONENTS Interpreter Development.Module)
if(NOT EMSCRIPTEN)
find_package(Python3 COMPONENTS Interpreter Development.Embed)
endif()
else()
find_package(Python3 REQUIRED COMPONENTS Interpreter Development)
endif()
set_vars(NETGEN_CMAKE_ARGS
Python3_INCLUDE_DIRS
Python3_LIBRARIES
Python3_EXECUTABLE
Python3_VERSION
PYBIND_INCLUDE_DIR
NG_INSTALL_PYBIND
)
endif (USE_PYTHON)
#######################################################################
if(USE_GUI)
include(cmake/external_projects/tcltk.cmake)
endif(USE_GUI)
if(USE_CGNS)
include(cmake/external_projects/cgns.cmake)
endif(USE_CGNS)
#######################################################################
if(USE_MPI)
if (METIS_DIR)
message(STATUS "Using external METIS at: ${METIS_DIR}")
else (METIS_DIR)
message(STATUS "Looking for system METIS")
find_package(METIS QUIET)
if(NOT METIS_FOUND)
message(WARNING "Could not find METIS, it will be built from source (this might conflict with NGSolve MUMPS)!")
include(cmake/external_projects/metis.cmake)
endif(NOT METIS_FOUND)
endif(METIS_DIR)
endif(USE_MPI)
#######################################################################
# propagate cmake variables to Netgen subproject
set_vars( NETGEN_CMAKE_ARGS
CMAKE_MODULE_LINKER_FLAGS
CMAKE_MODULE_LINKER_FLAGS_RELEASE
CMAKE_SHARED_LINKER_FLAGS
CMAKE_SHARED_LINKER_FLAGS_RELEASE
CMAKE_CXX_FLAGS
CMAKE_CXX_FLAGS_RELEASE
CMAKE_STRIP
USE_GUI
USE_PYTHON
USE_MPI
USE_MPI_WRAPPER
USE_VT
USE_VTUNE
USE_NUMA
USE_CCACHE
USE_NATIVE_ARCH
USE_OCC
USE_MPEG
USE_JPEG
USE_CGNS
USE_INTERNAL_TCL
INSTALL_PROFILES
INTEL_MIC
CMAKE_INSTALL_PREFIX
ENABLE_UNIT_TESTS
ENABLE_CPP_CORE_GUIDELINES_CHECK
USE_SPDLOG
DEBUG_LOG
CHECK_RANGE
TRACE_MEMORY
BUILD_STUB_FILES
BUILD_FOR_CONDA
NG_COMPILE_FLAGS
OpenCascade_ROOT
ZLIB_INCLUDE_DIRS
ZLIB_LIBRARIES
ZLIB_LIBRARY_RELEASE
ZLIB_ROOT
NGLIB_LIBRARY_TYPE
NGCORE_LIBRARY_TYPE
NGGUI_LIBRARY_TYPE
NG_INSTALL_DIR_PYTHON
NG_INSTALL_DIR_BIN
NG_INSTALL_DIR_LIB
NG_INSTALL_DIR_INCLUDE
NG_INSTALL_DIR_CMAKE
NG_INSTALL_DIR_RES
NG_INSTALL_SUFFIX
)
# propagate all variables set on the command line using cmake -DFOO=BAR
# to Netgen subproject
get_cmake_property(CACHE_VARS CACHE_VARIABLES)
foreach(CACHE_VAR ${CACHE_VARS})
get_property(CACHE_VAR_HELPSTRING CACHE ${CACHE_VAR} PROPERTY HELPSTRING)
if(CACHE_VAR_HELPSTRING STREQUAL "No help, variable specified on the command line." AND NOT CACHE_VAR STREQUAL "CMAKE_OSX_ARCHITECTURES")
get_property(CACHE_VAR_TYPE CACHE ${CACHE_VAR} PROPERTY TYPE)
string(REPLACE ";" "|" varvalue "${${CACHE_VAR}}" )
set(NETGEN_CMAKE_ARGS ${NETGEN_CMAKE_ARGS};-D${CACHE_VAR}:${CACHE_VAR_TYPE}=${varvalue} CACHE INTERNAL "")
endif()
endforeach()
if(${CMAKE_GENERATOR} STREQUAL "Unix Makefiles")
set(NETGEN_BUILD_COMMAND $(MAKE) --silent )
else()
set(NETGEN_BUILD_COMMAND ${CMAKE_COMMAND} --build ${CMAKE_CURRENT_BINARY_DIR}/netgen --config ${CMAKE_BUILD_TYPE})
endif()
string(REPLACE ";" "|" NETGEN_CMAKE_PREFIX_PATH_ALT_SEP "${NETGEN_CMAKE_PREFIX_PATH}")
ExternalProject_Add (netgen
${SUBPROJECT_ARGS}
DEPENDS ${NETGEN_DEPENDENCIES}
SOURCE_DIR ${PROJECT_SOURCE_DIR}
CMAKE_ARGS
-DUSE_SUPERBUILD=OFF
${NETGEN_CMAKE_ARGS}
${SUBPROJECT_CMAKE_ARGS}
-DCMAKE_PREFIX_PATH=${NETGEN_CMAKE_PREFIX_PATH_ALT_SEP}
INSTALL_COMMAND ""
BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/netgen
BUILD_COMMAND ${NETGEN_BUILD_COMMAND}
STEP_TARGETS build
)
# Check if the git submodules (i.e. pybind11) are up to date
# in case, something is wrong, emit a warning but continue
ExternalProject_Add_Step(netgen check_submodules
COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/check_submodules.cmake
DEPENDERS install # Steps on which this step depends
)
# Due to 'ALWAYS 1', this step is always run which also forces a build of
# the Netgen subproject
ExternalProject_Add_Step(netgen check_submodules1
COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/check_submodules.cmake
DEPENDEES configure # Steps on which this step depends
DEPENDERS build # Steps that depend on this step
ALWAYS 1 # No stamp file, step always runs
)
install(CODE "execute_process(COMMAND \"${CMAKE_COMMAND}\" --build . --target install --config ${CMAKE_BUILD_TYPE} WORKING_DIRECTORY \"${CMAKE_CURRENT_BINARY_DIR}/netgen\")")
add_custom_target(test_netgen
${CMAKE_COMMAND} --build ${CMAKE_CURRENT_BINARY_DIR}/netgen
--target test
--config ${CMAKE_BUILD_TYPE}
)
================================================
FILE: cmake/check_submodules.cmake
================================================
execute_process(COMMAND git submodule status --recursive WORKING_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/../" OUTPUT_VARIABLE git_status_output)
string(REPLACE "\n" ";" git_status_output "${git_status_output}")
foreach( a ${git_status_output})
if(NOT ${a} MATCHES " [a-f,0-9]* external_dependencies[.]*")
message(WARNING
"*****************************************************************
WARNING: The git submodules are out of sync! Please run
git submodule update --init --recursive
in your source directory
*****************************************************************")
endif()
endforeach()
================================================
FILE: cmake/cmake_modules/FindFFMPEG.cmake
================================================
# - Try to find ffmpeg libraries (libavcodec, libavformat, libavutil and swscale)
# Once done this will define
#
# FFMPEG_FOUND - system has ffmpeg or libav
# FFMPEG_INCLUDE_DIR - the ffmpeg include directory
# FFMPEG_LIBRARIES - Link these to use ffmpeg
# FFMPEG_LIBAVCODEC
# FFMPEG_LIBAVFORMAT
# FFMPEG_LIBAVUTIL
# FFMPEG_SWSCALE
#
# Copyright (c) 2008 Andreas Schneider <mail@cynapses.org>
# Modified for other libraries by Lasse Kärkkäinen <tronic>
# Modified for Hedgewars by Stepik777
# Modified for Netgen by Christoph Lehrenfeld (2015) (current version)
#
# Redistribution and use is allowed according to the terms of the New
# BSD license.
#
if (FFMPEG_LIBRARIES AND FFMPEG_INCLUDE_DIR)
# in cache already
set(FFMPEG_FOUND TRUE)
else (FFMPEG_LIBRARIES AND FFMPEG_INCLUDE_DIR)
# use pkg-config to get the directories and then use these values
# in the FIND_PATH() and FIND_LIBRARY() calls
find_package(PkgConfig)
if (PKG_CONFIG_FOUND)
pkg_check_modules(_FFMPEG_AVCODEC libavcodec)
pkg_check_modules(_FFMPEG_AVFORMAT libavformat)
pkg_check_modules(_FFMPEG_AVUTIL libavutil)
pkg_check_modules(SWSCALE libswscale)
endif (PKG_CONFIG_FOUND)
find_path(FFMPEG_AVCODEC_INCLUDE_DIR
NAMES libavcodec/avcodec.h
PATHS ${_FFMPEG_AVCODEC_INCLUDE_DIRS} /usr/include /usr/local/include /opt/local/include /sw/include
PATH_SUFFIXES ffmpeg libav
)
find_library(FFMPEG_LIBAVCODEC
NAMES avcodec
PATHS ${_FFMPEG_AVCODEC_LIBRARY_DIRS} /usr/lib /usr/local/lib /opt/local/lib /sw/lib
)
find_library(FFMPEG_LIBAVFORMAT
NAMES avformat
PATHS ${_FFMPEG_AVFORMAT_LIBRARY_DIRS} /usr/lib /usr/local/lib /opt/local/lib /sw/lib
)
find_library(FFMPEG_LIBAVUTIL
NAMES avutil
PATHS ${_FFMPEG_AVUTIL_LIBRARY_DIRS} /usr/lib /usr/local/lib /opt/local/lib /sw/lib
)
find_library(FFMPEG_SWSCALE
NAMES swscale
PATHS ${SWSCALE_LIBRARY_DIRS} /usr/lib /usr/local/lib /opt/local/lib /sw/lib
)
if (FFMPEG_LIBAVCODEC AND FFMPEG_LIBAVFORMAT)
set(FFMPEG_FOUND TRUE)
endif()
if (FFMPEG_FOUND)
set(FFMPEG_INCLUDE_DIR ${FFMPEG_AVCODEC_INCLUDE_DIR})
set(FFMPEG_LIBRARIES
${FFMPEG_LIBAVCODEC}
${FFMPEG_LIBAVFORMAT}
${FFMPEG_LIBAVUTIL}
${FFMPEG_SWSCALE}
)
endif (FFMPEG_FOUND)
if (FFMPEG_FOUND)
if (NOT FFMPEG_FIND_QUIETLY)
message(STATUS "Found FFMPEG or Libav: ${FFMPEG_LIBRARIES}, ${FFMPEG_INCLUDE_DIR}")
endif (NOT FFMPEG_FIND_QUIETLY)
else (FFMPEG_FOUND)
if (FFMPEG_FIND_REQUIRED)
message(FATAL_ERROR "Could not find libavcodec or libavformat or libavutil")
endif (FFMPEG_FIND_REQUIRED)
endif (FFMPEG_FOUND)
endif (FFMPEG_LIBRARIES AND FFMPEG_INCLUDE_DIR)
================================================
FILE: cmake/cmake_modules/FindMETIS.cmake
================================================
# -*- mode: cmake -*-
#
# METIS Find Module for MSTK
# Shamelessly stolen from Amanzi open source code https://software.lanl.gov/ascem/trac
#
# Usage:
# Control the search through METIS_DIR or setting environment variable
# METIS_ROOT to the METIS installation prefix.
#
# This module does not search default paths!
#
# Following variables are set:
# METIS_FOUND (BOOL) Flag indicating if METIS was found
# METIS_INCLUDE_DIR (PATH) Path to the METIS include file
# METIS_INCLUDE_DIRS (LIST) List of all required include files
# METIS_LIBRARY_DIR (PATH) Path to the METIS library
# METIS_LIBRARY (FILE) METIS library
# METIS_LIBRARIES (LIST) List of all required METIS libraries
#
# #############################################################################
# Standard CMake modules see CMAKE_ROOT/Modules
include(FindPackageHandleStandardArgs)
# Amanzi CMake functions see <root>/tools/cmake for source
# include(PrintVariable)
if ( METIS_LIBRARIES AND METIS_INCLUDE_DIRS )
# Do nothing. Variables are set. No need to search again
else(METIS_LIBRARIES AND METIS_INCLUDE_DIRS)
# Cache variables
if(METIS_DIR)
set(METIS_DIR "${METIS_DIR}" CACHE PATH "Path to search for METIS include and library files")
endif()
if(METIS_INCLUDE_DIR)
set(METIS_INCLUDE_DIR "${METIS_INCLUDE_DIR}" CACHE PATH "Path to search for METIS include files")
endif()
if(METIS_LIBRARY_DIR)
set(METIS_LIBRARY_DIR "${METIS_LIBRARY_DIR}" CACHE PATH "Path to search for METIS library files")
endif()
# Search for include files
# Search order preference:
# (1) METIS_INCLUDE_DIR - check existence of path AND if the include files exist
# (2) METIS_DIR/<include>
# (3) Default CMake paths See cmake --html-help=out.html file for more information.
#
set(metis_inc_names "metis.h")
if (METIS_INCLUDE_DIR)
if (EXISTS "${METIS_INCLUDE_DIR}")
find_path(metis_test_include_path
NAMES ${metis_inc_names}
HINTS ${METIS_INCLUDE_DIR}
NO_DEFAULT_PATH)
set(METIS_INCLUDE_DIR "${metis_test_include_path}")
endif()
else()
# Metis sometimes puts the include files in a subdir called Lib
set(metis_inc_suffixes "include" "Lib")
if(METIS_DIR)
if (EXISTS "${METIS_DIR}" )
find_path(METIS_INCLUDE_DIR
NAMES ${metis_inc_names}
HINTS ${METIS_DIR}
PATH_SUFFIXES ${metis_inc_suffixes}
NO_DEFAULT_PATH)
endif()
else()
find_path(METIS_INCLUDE_DIR
NAMES ${metis_inc_names}
PATH_SUFFIXES ${metis_inc_suffixes})
endif()
endif()
# Search for libraries
# Search order preference:
# (1) METIS_LIBRARY_DIR - check existence of path AND if the library file exists
# (2) METIS_DIR/<lib,Lib>
# (3) Default CMake paths See cmake --html-help=out.html file for more information.
#
set(metis_lib_names "metis5" "metis")
if (METIS_LIBRARY_DIR)
if (EXISTS "${METIS_LIBRARY_DIR}")
find_library(METIS_LIBRARY
NAMES ${metis_lib_names}
HINTS ${METIS_LIBRARY_DIR}
NO_DEFAULT_PATH)
endif()
else()
list(APPEND metis_lib_suffixes "lib" "Lib")
if(METIS_DIR)
if (EXISTS "${METIS_DIR}" )
find_library(METIS_LIBRARY
NAMES ${metis_lib_names}
HINTS ${METIS_DIR}
PATH_SUFFIXES ${metis_lib_suffixes}
NO_DEFAULT_PATH)
endif()
else()
find_library(METIS_LIBRARY
NAMES ${metis_lib_names}
PATH_SUFFIXES ${metis_lib_suffixes})
endif()
endif()
# Define prerequisite packages
set(METIS_INCLUDE_DIRS ${METIS_INCLUDE_DIR})
set(METIS_LIBRARIES ${METIS_LIBRARY})
endif(METIS_LIBRARIES AND METIS_INCLUDE_DIRS )
# Send useful message if everything is found
find_package_handle_standard_args(METIS DEFAULT_MSG
METIS_LIBRARIES
METIS_INCLUDE_DIRS)
# find_package_handle_standard_args should set METIS_FOUND but it does not!
if ( METIS_LIBRARIES AND METIS_INCLUDE_DIRS)
set(METIS_FOUND TRUE)
else()
set(METIS_FOUND FALSE)
endif()
# Define the version
mark_as_advanced(
METIS_INCLUDE_DIR
METIS_INCLUDE_DIRS
METIS_LIBRARY
METIS_LIBRARIES
METIS_LIBRARY_DIR
)
================================================
FILE: cmake/cmake_uninstall.cmake.in
================================================
if(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
message(FATAL_ERROR "Cannot find install manifest: @CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
endif(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
file(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files)
string(REGEX REPLACE "\n" ";" files "${files}")
foreach(file ${files})
message(STATUS "Uninstalling $ENV{DESTDIR}${file}")
if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
exec_program(
"@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
OUTPUT_VARIABLE rm_out
RETURN_VALUE rm_retval
)
if(NOT "${rm_retval}" STREQUAL 0)
message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}")
endif(NOT "${rm_retval}" STREQUAL 0)
else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
message(STATUS "File $ENV{DESTDIR}${file} does not exist.")
endif(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
endforeach(file)
================================================
FILE: cmake/external_projects/catch.cmake
================================================
include (ExternalProject)
find_program(GIT_EXECUTABLE git)
ExternalProject_Add(
project_catch
PREFIX ${CMAKE_BINARY_DIR}/catch
GIT_REPOSITORY https://github.com/catchorg/Catch2.git
GIT_TAG v2.13.7
TIMEOUT 10
UPDATE_COMMAND "" # ${GIT_EXECUTABLE} pull
CONFIGURE_COMMAND ""
BUILD_COMMAND ""
INSTALL_COMMAND ""
LOG_DOWNLOAD ON
)
# Expose required variable (CATCH_INCLUDE_DIR) to parent scope
ExternalProject_Get_Property(project_catch source_dir)
set(CATCH_INCLUDE_DIR ${source_dir}/single_include CACHE INTERNAL "Path to include folder for Catch")
================================================
FILE: cmake/external_projects/cgns.cmake
================================================
if(WIN32)
ExternalProject_Add(project_win_cgns
URL ${CGNS_DOWNLOAD_URL_WIN}
UPDATE_COMMAND "" # Disable update
BUILD_IN_SOURCE 1
CONFIGURE_COMMAND ""
BUILD_COMMAND ""
INSTALL_COMMAND ${CMAKE_COMMAND} -E copy_directory . ${CMAKE_INSTALL_PREFIX}
LOG_DOWNLOAD 1
)
list(APPEND NETGEN_DEPENDENCIES project_win_cgns)
endif(WIN32)
if(APPLE)
ExternalProject_Add(project_mac_cgns
URL ${CGNS_DOWNLOAD_URL_MAC}
UPDATE_COMMAND "" # Disable update
BUILD_IN_SOURCE 1
CONFIGURE_COMMAND ""
BUILD_COMMAND ""
INSTALL_COMMAND ${CMAKE_COMMAND} -E copy_directory . ${CMAKE_INSTALL_PREFIX}
LOG_DOWNLOAD 1
)
list(APPEND NETGEN_DEPENDENCIES project_mac_cgns)
list(APPEND NETGEN_CMAKE_ARGS "-DCGNS_INCLUDE_DIR=${CMAKE_INSTALL_PREFIX}/Contents/Resources/include")
list(APPEND NETGEN_CMAKE_ARGS "-DCGNS_LIBRARY=${CMAKE_INSTALL_PREFIX}/Contents/MacOS/libcgns.dylib")
endif(APPLE)
================================================
FILE: cmake/external_projects/metis.cmake
================================================
set(METIS_SRC_DIR ${CMAKE_CURRENT_BINARY_DIR}/dependencies/src/project_metis)
set(METIS_DIR ${CMAKE_CURRENT_BINARY_DIR}/dependencies/metis)
ExternalProject_Add(project_metis
PREFIX ${CMAKE_CURRENT_BINARY_DIR}/dependencies
URL https://bitbucket.org/petsc/pkg-metis/get/v5.1.0-p12.tar.gz
URL_MD5 6cd66f75f88dfa2cf043de011f85d8bc
DOWNLOAD_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external_dependencies
CMAKE_ARGS
-DCMAKE_POLICY_VERSION_MINIMUM=3.5
-DGKLIB_PATH=${METIS_SRC_DIR}/GKlib
-DCMAKE_INSTALL_PREFIX=${METIS_DIR}
-DCMAKE_POSITION_INDEPENDENT_CODE=ON
-DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
UPDATE_COMMAND "" # Disable update
BUILD_IN_SOURCE 1
)
set_vars( NETGEN_CMAKE_ARGS METIS_DIR )
list(APPEND NETGEN_DEPENDENCIES project_metis)
================================================
FILE: cmake/external_projects/spdlog.cmake
================================================
include(ExternalProject)
find_program(GIT_EXECUTABLE git)
ExternalProject_Add(
project_spdlog
PREFIX ${CMAKE_BINARY_DIR}/spdlog
GIT_REPOSITORY https://github.com/gabime/spdlog.git
GIT_TAG v1.2.1
TIMEOUT 01
UPDATE_COMMAND ""
CONFIGURE_COMMAND ""
BUILD_COMMAND ""
INSTALL_COMMAND ""
LOG_DOWNLOAD ON
)
ExternalProject_Get_Property(project_spdlog source_dir)
set(SPDLOG_INCLUDE_DIR ${source_dir}/include)
================================================
FILE: cmake/external_projects/tcltk.cmake
================================================
if(UNIX AND NOT APPLE)
set (LINUX TRUE)
endif()
if(LINUX)
find_package(TclStub 8.5 REQUIRED)
else(LINUX)
if(SKBUILD)
# we are building a pip package - download the tcl/tk sources matching the tkinter version (for private headers not shipped with python)
execute_process(COMMAND ${Python3_EXECUTABLE} -c
"import tkinter;print(tkinter.Tcl().eval('info patchlevel').replace('.','-'))"
OUTPUT_VARIABLE PYTHON_TCL_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE)
set(TCL_DIR ${CMAKE_CURRENT_BINARY_DIR}/dependencies/src/project_tcl)
set(TK_DIR ${CMAKE_CURRENT_BINARY_DIR}/dependencies/src/project_tk)
ExternalProject_Add(project_tcl
URL "https://github.com/tcltk/tcl/archive/refs/tags/core-${PYTHON_TCL_VERSION}.zip"
UPDATE_COMMAND ""
CONFIGURE_COMMAND ""
BUILD_COMMAND ""
INSTALL_COMMAND ""
${SUBPROJECT_ARGS}
DOWNLOAD_DIR download_tcl
)
ExternalProject_Add(project_tk
URL "https://github.com/tcltk/tk/archive/refs/tags/core-${PYTHON_TCL_VERSION}.zip"
UPDATE_COMMAND ""
CONFIGURE_COMMAND ""
INSTALL_COMMAND ""
BUILD_COMMAND ${CMAKE_COMMAND} -E copy_directory macosx generic
${SUBPROJECT_ARGS}
DOWNLOAD_DIR download_tk
BUILD_IN_SOURCE 1
)
set(TCL_INCLUDE_PATH ${TCL_DIR}/generic)
set(TK_INCLUDE_PATH ${TK_DIR}/generic)
list(APPEND NETGEN_DEPENDENCIES project_tcl project_tk)
if(APPLE OR WIN32)
execute_process(COMMAND ${Python3_EXECUTABLE} -c "import sys; print(sys.prefix)" OUTPUT_VARIABLE PYTHON_PREFIX OUTPUT_STRIP_TRAILING_WHITESPACE)
file(TO_CMAKE_PATH ${PYTHON_PREFIX} PYTHON_PREFIX)
set(tcl_find_args
REQUIRED
NO_DEFAULT_PATH
NO_PACKAGE_ROOT_PATH
NO_CMAKE_PATH
NO_CMAKE_ENVIRONMENT_PATH
NO_SYSTEM_ENVIRONMENT_PATH
NO_CMAKE_SYSTEM_PATH
NO_CMAKE_FIND_ROOT_PATH
HINTS
${PYTHON_PREFIX}/lib
${PYTHON_PREFIX}/tcl
${PYTHON_PREFIX}/Frameworks
${PYTHON_PREFIX}/Frameworks/Tcl.framework
${PYTHON_PREFIX}/Frameworks/Tk.framework
)
find_library(TCL_STUB_LIBRARY NAMES tclstub85 tclstub8.5 tclstub86 tclstub8.6 ${tcl_find_args})
find_library(TK_STUB_LIBRARY NAMES tkstub85 tkstub8.5 tkstub86 tkstub8.6 ${tcl_find_args})
find_library(TCL_LIBRARY NAMES tcl85 tcl8.5 tcl86 tcl8.6 tcl86t Tcl ${tcl_find_args})
find_library(TK_LIBRARY NAMES tk85 tk8.5 tk86 tk8.6 tk86t Tk ${tcl_find_args})
else()
# use system tcl/tk on linux
find_package(TclStub REQUIRED)
endif()
else(SKBUILD)
if(APPLE)
set(tcl_prefix ${CMAKE_INSTALL_PREFIX})
# URL "http://sourceforge.net/projects/tcl/files/Tcl/8.6.9/tcl8.6.9-src.tar.gz"
# URL_MD5 aa0a121d95a0e7b73a036f26028538d4
ExternalProject_Add(project_tcl
URL "https://github.com/NGSolve/tcl/archive/7769161.zip"
URL_MD5 1131f188dd26944df557913c475d43b4
DOWNLOAD_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external_dependencies
UPDATE_COMMAND ""
CONFIGURE_COMMAND ../project_tcl/macosx/configure --enable-threads --enable-framework --prefix=${tcl_prefix} --libdir=${tcl_prefix}/Contents/Frameworks --bindir=${tcl_prefix}/Contents/Frameworks/Tcl.framework/bin
BUILD_COMMAND make -j4 binaries libraries
INSTALL_COMMAND make install-binaries install-headers install-libraries install-private-headers
${SUBPROJECT_ARGS}
)
# URL "http://sourceforge.net/projects/tcl/files/Tcl/8.6.9/tk8.6.9.1-src.tar.gz"
# URL_MD5 9efe3976468352dc894dae0c4e785a8e
ExternalProject_Add(project_tk
DEPENDS project_tcl
URL "https://github.com/NGSolve/tk/archive/e7c2bc7.zip"
URL_MD5 94044140d4826069c22f1c60cedb6e59
DOWNLOAD_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external_dependencies
UPDATE_COMMAND ""
CONFIGURE_COMMAND ../project_tk/macosx/configure --enable-aqua=yes --enable-threads --enable-framework --prefix=${tcl_prefix} --libdir=${tcl_prefix}/Contents/Frameworks --bindir=${tcl_prefix}/Contents/Frameworks/Tcl.framework/bin --with-tcl=${tcl_prefix}/Contents/Frameworks/Tcl.framework
BUILD_COMMAND make -j4 binaries libraries
INSTALL_COMMAND make install-binaries install-headers install-libraries install-private-headers
${SUBPROJECT_ARGS}
)
ExternalProject_Add(project_tkdnd
URL "https://src.fedoraproject.org/repo/pkgs/tkdnd/tkdnd2.8-src.tar.gz/a6d47a996ea957416469b12965d4db91/tkdnd2.8-src.tar.gz"
URL_MD5 a6d47a996ea957416469b12965d4db91
DEPENDS project_tcl project_tk
DOWNLOAD_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external_dependencies
PATCH_COMMAND patch < ${CMAKE_CURRENT_LIST_DIR}/tkdnd_macosx.patch
UPDATE_COMMAND "" # Disable update
BUILD_IN_SOURCE 1
CMAKE_ARGS
-DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}/Contents/MacOS
-DTCL_INCLUDE_PATH=${CMAKE_INSTALL_PREFIX}/Contents/Frameworks/Tcl.framework/Headers
-DTK_INCLUDE_PATH=${CMAKE_INSTALL_PREFIX}/Contents/Frameworks/Tk.framework/Headers
-DCMAKE_POLICY_VERSION_MINIMUM=3.5
${SUBPROJECT_ARGS}
)
list(APPEND NETGEN_DEPENDENCIES project_tcl project_tk project_tkdnd)
list(APPEND CMAKE_PREFIX_PATH ${CMAKE_INSTALL_PREFIX}/Contents/Frameworks)
set(TCL_INCLUDE_PATH ${CMAKE_INSTALL_PREFIX}/Contents/Frameworks/Tcl.framework/Headers)
set(TCL_LIBRARY ${CMAKE_INSTALL_PREFIX}/Contents/Frameworks/Tcl.framework)
set(TK_LIBRARY ${CMAKE_INSTALL_PREFIX}/Contents/Frameworks/Tk.framework)
set(TK_INCLUDE_PATH ${CMAKE_INSTALL_PREFIX}/Contents/Frameworks/Tk.framework/Headers)
set(TCL_STUB_LIBRARY ${CMAKE_INSTALL_PREFIX}/Contents/Frameworks/Tcl.framework/libtclstub8.6.a)
set(TK_STUB_LIBRARY ${CMAKE_INSTALL_PREFIX}/Contents/Frameworks/Tk.framework/libtkstub8.6.a)
# # use system tcl/tk
# if((${PYTHON_VERSION_STRING} VERSION_EQUAL "3.7") OR (${PYTHON_VERSION_STRING} VERSION_GREATER "3.7"))
# # fetch tcl/tk sources to match the one used in Python 3.7
# ExternalProject_Add(project_tcl
# URL "https://prdownloads.sourceforge.net/tcl/tcl8.6.8-src.tar.gz"
# URL_MD5 81656d3367af032e0ae6157eff134f89
# DOWNLOAD_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external_dependencies
# UPDATE_COMMAND "" # Disable update
# CONFIGURE_COMMAND ""
# BUILD_COMMAND ""
# INSTALL_COMMAND ""
# )
# ExternalProject_Add(project_tk
# URL "https://prdownloads.sourceforge.net/tcl/tk8.6.8-src.tar.gz"
# URL_MD5 5e0faecba458ee1386078fb228d008ba
# DOWNLOAD_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external_dependencies
# UPDATE_COMMAND "" # Disable update
# CONFIGURE_COMMAND ""
# BUILD_COMMAND ""
# INSTALL_COMMAND ""
# )
#
# get_filename_component(PYTHON_LIB_DIR ${PYTHON_LIBRARY} DIRECTORY)
# find_library(TCL_LIBRARY libtcl8.6.dylib PATHS ${PYTHON_LIB_DIR} NO_DEFAULT_PATH)
# find_library(TK_LIBRARY libtk8.6.dylib PATHS ${PYTHON_LIB_DIR} NO_DEFAULT_PATH)
#
# set(TCL_DIR ${CMAKE_CURRENT_BINARY_DIR}/dependencies/src/project_tcl)
# set(TK_DIR ${CMAKE_CURRENT_BINARY_DIR}/dependencies/src/project_tk)
# set(TCL_INCLUDE_PATH "${TCL_DIR}/generic;${TCL_DIR}/macosx")
# set(TK_INCLUDE_PATH "${TK_DIR}/generic;${TK_DIR}/macosx;${TK_DIR}/xlib")
# string(REPLACE ";" "$<SEMICOLON>" TCL_INC "${TCL_INCLUDE_PATH}")
# string(REPLACE ";" "$<SEMICOLON>" TK_INC "${TK_INCLUDE_PATH}")
#
# ExternalProject_Add(project_tkdnd
# URL "http://sourceforge.net/projects/tkdnd/files/TkDND/TkDND%202.8/tkdnd2.8-src.tar.gz"
# URL_MD5 a6d47a996ea957416469b12965d4db91
# DEPENDS project_tcl project_tk
# DOWNLOAD_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external_dependencies
# PATCH_COMMAND patch < ${CMAKE_CURRENT_LIST_DIR}/tkdnd_macosx.patch
# UPDATE_COMMAND "" # Disable update
# BUILD_IN_SOURCE 1
# CMAKE_ARGS
# -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}/Contents/MacOS
# -DTCL_INCLUDE_PATH=${TCL_INC}
# -DTK_INCLUDE_PATH=${TK_INC}
# -DTK_LIBRARY=${TK_LIBRARY}
# -DTCL_LIBRARY=${TCL_LIBRARY}
# LOG_DOWNLOAD 1
# LOG_CONFIGURE 1
# LOG_BUILD 1
# LOG_INSTALL 1
# )
#
# list(APPEND NETGEN_DEPENDENCIES project_tkdnd)
# else()
# find_package(TCL 8.5 REQUIRED)
# endif()
elseif(WIN32)
ExternalProject_Add(project_win_tcltk
URL ${TCLTK_DOWNLOAD_URL_WIN}
UPDATE_COMMAND "" # Disable update
BUILD_IN_SOURCE 1
CONFIGURE_COMMAND ""
BUILD_COMMAND ""
INSTALL_COMMAND ${CMAKE_COMMAND} -E copy_directory lib ${CMAKE_INSTALL_PREFIX}/${NG_INSTALL_DIR_LIB}
COMMAND ${CMAKE_COMMAND} -E copy_directory bin ${CMAKE_INSTALL_PREFIX}/${NG_INSTALL_DIR_BIN}
COMMAND ${CMAKE_COMMAND} -E copy_directory include ${CMAKE_INSTALL_PREFIX}/${NG_INSTALL_DIR_INCLUDE}
${SUBPROJECT_ARGS}
)
set (TK_INCLUDE_PATH ${CMAKE_INSTALL_PREFIX}/include)
set (TCL_INCLUDE_PATH ${CMAKE_INSTALL_PREFIX}/include)
set (TCL_LIBRARY ${CMAKE_INSTALL_PREFIX}/lib/tcl86t.lib)
set (TK_LIBRARY ${CMAKE_INSTALL_PREFIX}/lib/tk86t.lib)
set (TCL_STUB_LIBRARY ${CMAKE_INSTALL_PREFIX}/lib/tclstub86.lib)
set (TK_STUB_LIBRARY ${CMAKE_INSTALL_PREFIX}/lib/tkstub86.lib)
list(APPEND NETGEN_DEPENDENCIES project_win_tcltk)
else(WIN32)
find_package(TCL 8.5 REQUIRED)
# ExternalProject_Add(project_tkdnd
# GIT_REPOSITORY https://github.com/petasis/tkdnd.git
# GIT_TAG d7cfd96087b248255da5349086ef70cc4bbfb619
# PREFIX ${CMAKE_CURRENT_BINARY_DIR}/tkdnd
# CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}/lib
# UPDATE_COMMAND ""
# LOG_DOWNLOAD 1
# LOG_BUILD 1
# LOG_INSTALL 1
# )
# list(APPEND NETGEN_DEPENDENCIES project_tkdnd)
endif(APPLE)
endif(SKBUILD)
endif(LINUX)
# Propagate settings to Netgen subproject
set_vars(NETGEN_CMAKE_ARGS TCL_INCLUDE_PATH TCL_STUB_LIBRARY TCL_LIBRARY TK_STUB_LIBRARY TK_LIBRARY TK_INCLUDE_PATH TCL_TCLSH TK_WISH)
================================================
FILE: cmake/external_projects/zlib.cmake
================================================
if(WIN32)
ExternalProject_Add(project_win_zlib
URL ${ZLIB_DOWNLOAD_URL_WIN}
UPDATE_COMMAND "" # Disable update
BUILD_IN_SOURCE 1
CONFIGURE_COMMAND ""
BUILD_COMMAND ""
INSTALL_COMMAND ${CMAKE_COMMAND} -E copy_directory lib ${CMAKE_INSTALL_PREFIX}/${NG_INSTALL_DIR_LIB}
COMMAND ${CMAKE_COMMAND} -E copy_directory bin ${CMAKE_INSTALL_PREFIX}/${NG_INSTALL_DIR_BIN}
COMMAND ${CMAKE_COMMAND} -E copy_directory include ${CMAKE_INSTALL_PREFIX}/${NG_INSTALL_DIR_INCLUDE}
LOG_DOWNLOAD 1
)
list(APPEND NETGEN_DEPENDENCIES project_win_zlib)
endif(WIN32)
================================================
FILE: cmake/generate_version_file.cmake
================================================
if(NOT BDIR)
set(BDIR ${CMAKE_CURRENT_BINARY_DIR})
endif()
if(NETGEN_VERSION_GIT)
set(git_version_string ${NETGEN_VERSION_GIT})
else()
find_package(Git REQUIRED)
execute_process(COMMAND git describe --tags --match "v[0-9]*" --long --dirty
WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
OUTPUT_VARIABLE git_version_string
RESULT_VARIABLE status
ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE
)
endif()
if(status AND NOT status EQUAL 0)
if(EXISTS ${CMAKE_CURRENT_LIST_DIR}/../version.txt)
# for source package files (generated for ubuntu builds on launchpad) read the version from version.txt
if(EXISTS ${CMAKE_CURRENT_LIST_DIR}/../version.txt)
file(READ ${CMAKE_CURRENT_LIST_DIR}/../version.txt git_version_string )
else()
get_filename_component(git_version_string ${CMAKE_CURRENT_LIST_DIR}/.. NAME)
string(REGEX REPLACE "^netgen(.*)" "\\1" git_version_string "${git_version_string}")
endif()
else()
MESSAGE(WARNING "Could not determine git-version from source code - assuming 6.2.0-0")
set(git_version_string "v6.2.0-0")
endif()
endif()
string(STRIP ${git_version_string} git_version_string)
string(REGEX REPLACE "^v([0-9]+)\\..*" "\\1" NETGEN_VERSION_MAJOR "${git_version_string}")
string(REGEX REPLACE "^v[0-9]+\\.([0-9]+).*" "\\1" NETGEN_VERSION_MINOR "${git_version_string}")
string(REGEX REPLACE "^v[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" NETGEN_VERSION_PATCH "${git_version_string}")
string(REGEX REPLACE "^v[0-9]+\\.[0-9]+\\.[0-9]+\\-([0-9]+).*" "\\1" NETGEN_VERSION_TWEAK "${git_version_string}")
string(REGEX REPLACE "^v[0-9]+\\.[0-9]+\\.[0-9]+\\-[0-9]+\\-([0-9a-z]+).*" "\\1" NETGEN_VERSION_HASH "${git_version_string}")
set(NETGEN_VERSION_SHORT ${NETGEN_VERSION_MAJOR}.${NETGEN_VERSION_MINOR}.${NETGEN_VERSION_PATCH})
set(NETGEN_VERSION_LONG ${NETGEN_VERSION_SHORT}-${NETGEN_VERSION_TWEAK}-${NETGEN_VERSION_HASH})
if(NETGEN_VERSION_TWEAK)
# no release version - nightly build
set(NETGEN_VERSION ${NETGEN_VERSION_LONG})
else()
# TWEAK is 0 -> current version has a tag assigned
set(NETGEN_VERSION ${NETGEN_VERSION_SHORT})
endif()
set(NETGEN_VERSION_LONG ${NETGEN_VERSION_SHORT}-${NETGEN_VERSION_TWEAK}-${NETGEN_VERSION_HASH})
if(NOT NETGEN_VERSION_GIT)
set(NETGEN_VERSION_GIT ${NETGEN_VERSION_LONG})
endif()
if(NOT NETGEN_VERSION_PYTHON)
set(NETGEN_VERSION_PYTHON ${NETGEN_VERSION_TWEAK})
endif()
set(version_file ${BDIR}/netgen_version.hpp)
set(new_version_file_string "\
#ifndef NETGEN_VERSION_HPP_INCLUDED
#define NETGEN_VERSION_HPP_INCLUDED
#define NETGEN_VERSION \"${NETGEN_VERSION}\"
#define NETGEN_VERSION_MAJOR ${NETGEN_VERSION_MAJOR}
#define NETGEN_VERSION_MINOR ${NETGEN_VERSION_MINOR}
#define NETGEN_VERSION_PATCH ${NETGEN_VERSION_PATCH}
#define NETGEN_VERSION_TWEAK ${NETGEN_VERSION_TWEAK}
#define NETGEN_VERSION_HASH \"${NETGEN_VERSION_HASH}\"
#endif // NETGEN_VERSION_HPP_INCLUDED
")
if(EXISTS ${version_file})
file(READ ${version_file} old_version_file_string )
if(${old_version_file_string} STREQUAL ${new_version_file_string})
else()
file(WRITE ${BDIR}/netgen_version.hpp ${new_version_file_string})
endif()
else()
file(WRITE ${BDIR}/netgen_version.hpp ${new_version_file_string})
endif()
file(GENERATE OUTPUT netgen_config.hpp CONTENT
"\
#ifndef NETGEN_CONFIG_HPP_INCLUDED___
#define NETGEN_CONFIG_HPP_INCLUDED___
#define NETGEN_USE_NATIVE_ARCH $<BOOL:${USE_NATIVE_ARCH}>
#define NETGEN_USE_GUI $<BOOL:${USE_GUI}>
#define NETGEN_USE_PYTHON $<BOOL:${USE_PYTHON}>
#define NETGEN_USE_MPI $<BOOL:${USE_MPI}}>
#define NETGEN_USE_MPI4PY $<BOOL:${USE_MPI4PY}>
#define NETGEN_USE_OCC $<BOOL:${USE_OCC}}>
#define NETGEN_USE_JPEG $<BOOL:${USE_JPEG}}>
#define NETGEN_USE_MPEG $<BOOL:${USE_MPEG}}>
#define NETGEN_USE_CGNS $<BOOL:${USE_CGNS}}>
#define NETGEN_USE_NUMA $<BOOL:${USE_NUMA}}>
#define NETGEN_INTEL_MIC $<BOOL:${USE_INTEL_MIC}}>
#define NETGEN_INSTALL_PROFILES $<BOOL:${INSTALL_PROFILES}>
#define NETGEN_USE_CCACHE $<BOOL:${USE_CCACHE}}>
#define NETGEN_USE_INTERNAL_TCL $<BOOL:${USE_INTERNAL_TCL}>
#define NETGEN_ENABLE_UNIT_TESTS $<BOOL:${ENABLE_UNIT_TESTS}>
#define NETGEN_ENABLE_CPP_CORE_GUIDELINES_CHECK $<BOOL:${ENABLE_CPP_CORE_GUIDELINES_CHECK}>
#define NETGEN_USE_SPDLOG $<BOOL:${USE_SPDLOG}>
#define NETGEN_DEBUG_LOG $<BOOL:${DEBUG_LOG}>
#define NETGEN_USE_CHECK_RANGE $<BOOL:${CHECK_RANGE}>
#define NETGEN_BUILD_STUB_FILES $<BOOL:${BUILD_STUB_FILES}>
#define NETGEN_BUILD_FOR_CONDA $<BOOL:${BUILD_FOR_CONDA}>
#define NETGEN_SHARED_LIBRARY_SUFFIX \"${CMAKE_SHARED_LIBRARY_SUFFIX}\"
#endif // NETGEN_CONFIG_HPP_INCLUDED___
")
================================================
FILE: cmake/mic.cmake
================================================
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR k1om)
set(CMAKE_SYSTEM_VERSION 1)
# specify the cross compiler
set(CMAKE_C_COMPILER icc)
set(CMAKE_CXX_COMPILER icpc)
set(MPI_C_COMPILER mpiicc)
set(_CMAKE_TOOLCHAIN_PREFIX x86_64-k1om-linux-)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mmic")
set(CMAKE_CXX_LINK_FLAGS "${CMAKE_CXX_LINK_FLAGS} -limf -lsvml -lirng -lintlc")
# where is the target environment
set(CMAKE_FIND_ROOT_PATH /usr/linux-k1om-4.7)
================================================
FILE: cmake/netgen_fixup.cmake
================================================
include(BundleUtilities)
function(netgen_fixup_bundle app libs dirs)
message(STATUS "fixup_bundle")
message(STATUS " app='${app}'")
message(STATUS " libs='${libs}'")
message(STATUS " dirs='${dirs}'")
get_bundle_and_executable("${app}" bundle executable valid)
if(valid)
get_filename_component(exepath "${executable}" PATH)
message(STATUS "fixup_bundle: preparing...")
get_bundle_keys("${app}" "${libs}" "${dirs}" keys)
message(STATUS "fixup_bundle: copying...")
list(LENGTH keys n)
math(EXPR n ${n}*2)
set(i 0)
foreach(key ${keys})
math(EXPR i ${i}+1)
if(${${key}_COPYFLAG})
set(item "${${key}_ITEM}")
if(item MATCHES "[^/]+\\.framework/")
copy_resolved_framework_into_bundle("${${key}_RESOLVED_ITEM}"
"${${key}_RESOLVED_EMBEDDED_ITEM}")
else()
copy_resolved_item_into_bundle("${${key}_RESOLVED_ITEM}"
"${${key}_RESOLVED_EMBEDDED_ITEM}")
endif()
endif()
endforeach()
message(STATUS "fixup_bundle: fixing...")
foreach(key ${keys})
math(EXPR i ${i}+1)
message(STATUS "${i}/${n}: fixing up '${${key}_RESOLVED_EMBEDDED_ITEM}'")
fixup_bundle_item("${${key}_RESOLVED_EMBEDDED_ITEM}" "${exepath}" "${dirs}")
endforeach()
message(STATUS "fixup_bundle: cleaning up...")
clear_bundle_keys(keys)
else()
message(SEND_ERROR "error: fixup_bundle: not a valid bundle")
endif()
message(STATUS "fixup_bundle: done")
endfunction()
================================================
FILE: depcomp
================================================
#! /bin/sh
# depcomp - compile a program generating dependencies as side-effects
# Copyright 1999, 2000 Free Software Foundation, Inc.
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
# 02111-1307, USA.
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.
# Originally written by Alexandre Oliva <oliva@dcc.unicamp.br>.
if test -z "$depmode" || test -z "$source" || test -z "$object"; then
echo "depcomp: Variables source, object and depmode must be set" 1>&2
exit 1
fi
# `libtool' can also be set to `yes' or `no'.
depfile=${depfile-`echo "$object" | sed 's,\([^/]*\)$,.deps/\1,;s/\.\([^.]*\)$/.P\1/'`}
tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`}
rm -f "$tmpdepfile"
# Some modes work just like other modes, but use different flags. We
# parameterize here, but still list the modes in the big case below,
# to make depend.m4 easier to write. Note that we *cannot* use a case
# here, because this file can only contain one case statement.
if test "$depmode" = hp; then
# HP compiler uses -M and no extra arg.
gccflag=-M
depmode=gcc
fi
if test "$depmode" = dashXmstdout; then
# This is just like dashmstdout with a different argument.
dashmflag=-xM
depmode=dashmstdout
fi
case "$depmode" in
gcc3)
## gcc 3 implements dependency tracking that does exactly what
## we want. Yay! Note: for some reason libtool 1.4 doesn't like
## it if -MD -MP comes after the -MF stuff. Hmm.
"$@" -MT "$object" -MD -MP -MF "$tmpdepfile"
stat=$?
if test $stat -eq 0; then :
else
rm -f "$tmpdepfile"
exit $stat
fi
mv "$tmpdepfile" "$depfile"
;;
gcc)
## There are various ways to get dependency output from gcc. Here's
## why we pick this rather obscure method:
## - Don't want to use -MD because we'd like the dependencies to end
## up in a subdir. Having to rename by hand is ugly.
## (We might end up doing this anyway to support other compilers.)
## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like
## -MM, not -M (despite what the docs say).
## - Using -M directly means running the compiler twice (even worse
## than renaming).
if test -z "$gccflag"; then
gccflag=-MD,
fi
"$@" -Wp,"$gccflag$tmpdepfile"
stat=$?
if test $stat -eq 0; then :
else
rm -f "$tmpdepfile"
exit $stat
fi
rm -f "$depfile"
echo "$object : \\" > "$depfile"
alpha=ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
## The second -e expression handles DOS-style file names with drive letters.
sed -e 's/^[^:]*: / /' \
-e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile"
## This next piece of magic avoids the `deleted header file' problem.
## The problem is that when a header file which appears in a .P file
## is deleted, the dependency causes make to die (because there is
## typically no way to rebuild the header). We avoid this by adding
## dummy dependencies for each header file. Too bad gcc doesn't do
## this for us directly.
tr ' ' '
' < "$tmpdepfile" |
## Some versions of gcc put a space before the `:'. On the theory
## that the space means something, we add a space to the output as
## well.
## Some versions of the HPUX 10.20 sed can't process this invocation
## correctly. Breaking it into two sed invocations is a workaround.
sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
rm -f "$tmpdepfile"
;;
hp)
# This case exists only to let depend.m4 do its work. It works by
# looking at the text of this script. This case will never be run,
# since it is checked for above.
exit 1
;;
sgi)
if test "$libtool" = yes; then
"$@" "-Wp,-MDupdate,$tmpdepfile"
else
"$@" -MDupdate "$tmpdepfile"
fi
stat=$?
if test $stat -eq 0; then :
else
rm -f "$tmpdepfile"
exit $stat
fi
rm -f "$depfile"
if test -f "$tmpdepfile"; then # yes, the sourcefile depend on other files
echo "$object : \\" > "$depfile"
# Clip off the initial element (the dependent). Don't try to be
# clever and replace this with sed code, as IRIX sed won't handle
# lines with more than a fixed number of characters (4096 in
# IRIX 6.2 sed, 8192 in IRIX 6.5). We also remove comment lines;
# the IRIX cc adds comments like `#:fec' to the end of the
# dependency line.
tr ' ' '
' < "$tmpdepfile" \
| sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' | \
tr '
' ' ' >> $depfile
echo >> $depfile
# The second pass generates a dummy entry for each header file.
tr ' ' '
' < "$tmpdepfile" \
| sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \
>> $depfile
else
# The sourcefile does not contain any dependencies, so just
# store a dummy comment line, to avoid errors with the Makefile
# "include basename.Plo" scheme.
echo "#dummy" > "$depfile"
fi
rm -f "$tmpdepfile"
;;
aix)
# The C for AIX Compiler uses -M and outputs the dependencies
# in a .u file. This file always lives in the current directory.
# Also, the AIX compiler puts `$object:' at the start of each line;
# $object doesn't have directory information.
stripped=`echo "$object" | sed -e 's,^.*/,,' -e 's/\(.*\)\..*$/\1/'`
tmpdepfile="$stripped.u"
outname="$stripped.o"
if test "$libtool" = yes; then
"$@" -Wc,-M
else
"$@" -M
fi
stat=$?
if test $stat -eq 0; then :
else
rm -f "$tmpdepfile"
exit $stat
fi
if test -f "$tmpdepfile"; then
# Each line is of the form `foo.o: dependent.h'.
# Do two passes, one to just change these to
# `$object: dependent.h' and one to simply `dependent.h:'.
sed -e "s,^$outname:,$object :," < "$tmpdepfile" > "$depfile"
sed -e "s,^$outname: \(.*\)$,\1:," < "$tmpdepfile" >> "$depfile"
else
# The sourcefile does not contain any dependencies, so just
# store a dummy comment line, to avoid errors with the Makefile
# "include basename.Plo" scheme.
echo "#dummy" > "$depfile"
fi
rm -f "$tmpdepfile"
;;
icc)
# Must come before tru64.
# Intel's C compiler understands `-MD -MF file'. However
# icc -MD -MF foo.d -c -o sub/foo.o sub/foo.c
# will fill foo.d with something like
# foo.o: sub/foo.c
# foo.o: sub/foo.h
# which is wrong. We want:
# sub/foo.o: sub/foo.c
# sub/foo.o: sub/foo.h
# sub/foo.c:
# sub/foo.h:
"$@" -MD -MF "$tmpdepfile"
stat=$?
if test $stat -eq 0; then :
else
rm -f "$tmpdepfile"
exit $stat
fi
rm -f "$depfile"
# Each line is of the form `foo.o: dependent.h'.
# Do two passes, one to just change these to
# `$object: dependent.h' and one to simply `dependent.h:'.
sed -e "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile"
sed -e "s,^[^:]*: \(.*\)$,\1:," < "$tmpdepfile" >> "$depfile"
rm -f "$tmpdepfile"
;;
tru64)
# The Tru64 AIX compiler uses -MD to generate dependencies as a side
# effect. `cc -MD -o foo.o ...' puts the dependencies into `foo.o.d'.
# At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
# dependencies in `foo.d' instead, so we check for that too.
# Subdirectories are respected.
tmpdepfile1="$object.d"
tmpdepfile2=`echo "$object" | sed -e 's/.o$/.d/'`
if test "$libtool" = yes; then
"$@" -Wc,-MD
else
"$@" -MD
fi
stat=$?
if test $stat -eq 0; then :
else
rm -f "$tmpdepfile1" "$tmpdepfile2"
exit $stat
fi
if test -f "$tmpdepfile1"; then
tmpdepfile="$tmpdepfile1"
else
tmpdepfile="$tmpdepfile2"
fi
if test -f "$tmpdepfile"; then
sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
# That's a space and a tab in the [].
sed -e 's,^.*\.[a-z]*:[ ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
else
echo "#dummy" > "$depfile"
fi
rm -f "$tmpdepfile"
;;
#nosideeffect)
# This comment above is used by automake to tell side-effect
# dependency tracking mechanisms from slower ones.
dashmstdout)
# Important note: in order to support this mode, a compiler *must*
# always write the proprocessed file to stdout, regardless of -o,
# because we must use -o when running libtool.
test -z "$dashmflag" && dashmflag=-M
( IFS=" "
case " $* " in
*" --mode=compile "*) # this is libtool, let us make it quiet
for arg
do # cycle over the arguments
case "$arg" in
"--mode=compile")
# insert --quiet before "--mode=compile"
set fnord "$@" --quiet
shift # fnord
;;
esac
set fnord "$@" "$arg"
shift # fnord
shift # "$arg"
done
;;
esac
"$@" $dashmflag | sed 's:^[^:]*\:[ ]*:'"$object"'\: :' > "$tmpdepfile"
) &
proc=$!
"$@"
stat=$?
wait "$proc"
if test "$stat" != 0; then exit $stat; fi
rm -f "$depfile"
cat < "$tmpdepfile" > "$depfile"
tr ' ' '
' < "$tmpdepfile" | \
## Some versions of the HPUX 10.20 sed can't process this invocation
## correctly. Breaking it into two sed invocations is a workaround.
sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
rm -f "$tmpdepfile"
;;
dashXmstdout)
# This case only exists to satisfy depend.m4. It is never actually
# run, as this mode is specially recognized in the preamble.
exit 1
;;
makedepend)
# X makedepend
(
shift
cleared=no
for arg in "$@"; do
case $cleared in no)
set ""; shift
cleared=yes
esac
case "$arg" in
-D*|-I*)
set fnord "$@" "$arg"; shift;;
-*)
;;
*)
set fnord "$@" "$arg"; shift;;
esac
done
obj_suffix="`echo $object | sed 's/^.*\././'`"
touch "$tmpdepfile"
${MAKEDEPEND-makedepend} 2>/dev/null -o"$obj_suffix" -f"$tmpdepfile" "$@"
) &
proc=$!
"$@"
stat=$?
wait "$proc"
if test "$stat" != 0; then exit $stat; fi
rm -f "$depfile"
cat < "$tmpdepfile" > "$depfile"
tail +3 "$tmpdepfile" | tr ' ' '
' | \
## Some versions of the HPUX 10.20 sed can't process this invocation
## correctly. Breaking it into two sed invocations is a workaround.
sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
rm -f "$tmpdepfile" "$tmpdepfile".bak
;;
cpp)
# Important note: in order to support this mode, a compiler *must*
# always write the proprocessed file to stdout, regardless of -o,
# because we must use -o when running libtool.
( IFS=" "
case " $* " in
*" --mode=compile "*)
for arg
do # cycle over the arguments
case $arg in
"--mode=compile")
# insert --quiet before "--mode=compile"
set fnord "$@" --quiet
shift # fnord
;;
esac
set fnord "$@" "$arg"
shift # fnord
shift # "$arg"
done
;;
esac
"$@" -E |
sed -n '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' |
sed '$ s: \\$::' > "$tmpdepfile"
) &
proc=$!
"$@"
stat=$?
wait "$proc"
if test "$stat" != 0; then exit $stat; fi
rm -f "$depfile"
echo "$object : \\" > "$depfile"
cat < "$tmpdepfile" >> "$depfile"
sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile"
rm -f "$tmpdepfile"
;;
msvisualcpp)
# Important note: in order to support this mode, a compiler *must*
# always write the proprocessed file to stdout, regardless of -o,
# because we must use -o when running libtool.
( IFS=" "
case " $* " in
*" --mode=compile "*)
for arg
do # cycle over the arguments
case $arg in
"--mode=compile")
# insert --quiet before "--mode=compile"
set fnord "$@" --quiet
shift # fnord
;;
esac
set fnord "$@" "$arg"
shift # fnord
shift # "$arg"
done
;;
esac
"$@" -E |
sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::echo "`cygpath -u \\"\1\\"`":p' | sort | uniq > "$tmpdepfile"
) &
proc=$!
"$@"
stat=$?
wait "$proc"
if test "$stat" != 0; then exit $stat; fi
rm -f "$depfile"
echo "$object : \\" > "$depfile"
. "$tmpdepfile" | sed 's% %\\ %g' | sed -n '/^\(.*\)$/ s:: \1 \\:p' >> "$depfile"
echo " " >> "$depfile"
. "$tmpdepfile" | sed 's% %\\ %g' | sed -n '/^\(.*\)$/ s::\1\::p' >> "$depfile"
rm -f "$tmpdepfile"
;;
none)
exec "$@"
;;
*)
echo "Unknown depmode $depmode" 1>&2
exit 1
;;
esac
exit 0
================================================
FILE: doc/CMakeLists.txt
================================================
INSTALL(FILES ng4.pdf DESTINATION ${NG_INSTALL_DIR_RES}/${NG_INSTALL_SUFFIX}/doc COMPONENT netgen_doc)
================================================
FILE: doc/element_types.tex
================================================
\documentclass[convert=pdf2svg]{standalone}
% \documentclass{article}
\usepackage[T1]{fontenc}
\usepackage{lmodern}
\renewcommand{\familydefault}{\sfdefault}
\usepackage{tikz}
\usepackage{tikz-3dplot}
\usetikzlibrary{external}
\tikzset{external/force remake}
\tikzset{external/disable dependency files}
\tikzset{external/aux in dpth={false}}
% uncomment this to generate a figure for each cell type (and change documentclass to article)
% \tikzexternalize
\tikzstyle{vertex} = [circle,draw=black,fill=black,scale = 0.5]
\tdplotsetmaincoords{70}{110}
% cnode(tag,x,y,z,label,label_pos)
\def\cnode(#1,#2,#3,#4,#5,#6){
\node (#1) at (#2,#3,#4) [vertex,label=#6:$\mathsf{#5}$] {};
}
\pagestyle{empty}
\begin{document}
\begin{tabular}{cc}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SEGMENT &
SEGMENT3
\\
\tikzsetnextfilename{line}
\begin{tikzpicture}[scale = 2]
\cnode(n0,0,0,0,1,below right);
\cnode(n1,2,0,0,2,below right);
\draw (n0) -- (n1);
\end{tikzpicture}
&
\tikzsetnextfilename{line3}
\begin{tikzpicture}[scale = 2]
\cnode(n0,0,0,0,1,below right);
\cnode(n1,2,0,0,2,below right);
\cnode(n2,1,0,0,3,below right);
\draw (n0) -- (n2) -- (n1);
\end{tikzpicture}
\\[1 em]
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
TRIG &
TRIG6
\\
\tikzsetnextfilename{triangle}
\begin{tikzpicture}[scale = 2]
\cnode(n0,0,0,0,1,below right);
\cnode(n1,2,0,0,2,below right);
\cnode(n2,0,2,0,3,right);
\draw (n0) -- (n1) -- (n2) -- (n0);
\end{tikzpicture}
&
\tikzsetnextfilename{triangle6}
\begin{tikzpicture}[scale = 2]
\cnode(n0,0,0,0,1,below right);
\cnode(n1,2,0,0,2,below right);
\cnode(n2,0,2,0,3,right);
\cnode(n3,1,0,0,6,below right);
\cnode(n4,1,1,0,4,right);
\cnode(n5,0,1,0,5,below right);
\draw (n0) -- (n3) -- (n1) -- (n4) -- (n2) -- (n5) -- (n0);
\end{tikzpicture}
\\[1 em]
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
QUAD &
QUAD8
\\
\tikzsetnextfilename{quad}
\begin{tikzpicture}[scale = 2]
\cnode(n0,0,0,0,1,below right);
\cnode(n1,2,0,0,2,below right);
\cnode(n2,2,2,0,3,below right);
\cnode(n3,0,2,0,4,below right);
\draw (n0) -- (n1) -- (n2) -- (n3) -- (n0);
\end{tikzpicture}
&
\tikzsetnextfilename{quad8}
\begin{tikzpicture}[scale = 2]
\cnode(n0,0,0,0,1,below right);
\cnode(n1,2,0,0,2,below right);
\cnode(n2,2,2,0,3,below right);
\cnode(n3,0,2,0,4,below right);
\cnode(n4,1,0,0,5,below right);
\cnode(n5,2,1,0,8,below right);
\cnode(n6,1,2,0,6,below right);
\cnode(n7,0,1,0,7,below right);
\draw (n0) -- (n4) -- (n1) -- (n5) -- (n2) -- (n6) -- (n3) -- (n7) -- (n0);
\end{tikzpicture}
\\[1 em]
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
TET &
TET10
\\
\tikzsetnextfilename{tetra}
\begin{tikzpicture}[scale = 2, tdplot_main_coords]
\cnode(n0,0,0,0,1,below right);
\cnode(n1,2,0,0,3,below right);
\cnode(n2,0,2,0,2,below right);
\cnode(n3,0,0,2,4,right);
\draw (n0) -- (n1) -- (n2) -- (n0);
\draw (n0) -- (n3);
\draw (n1) -- (n3);
\draw (n2) -- (n3);
\end{tikzpicture}
&
\tikzsetnextfilename{tetra10} % VTK
\begin{tikzpicture}[scale = 2, tdplot_main_coords]
\cnode(n0,0,0,0,1,below right);
\cnode(n1,2,0,0,3,below right);
\cnode(n2,0,2,0,2,below right);
\cnode(n3,0,0,2,4,right);
\cnode(n4,1,0,0,6,below right);
\cnode(n5,1,1,0,8,below right);
\cnode(n6,0,1,0,5,below right);
\cnode(n7,0,0,1,7,below right);
\cnode(n8,1,0,1,10,below right);
\cnode(n9,0,1,1,9,right);
\draw (n0) -- (n4) -- (n1) -- (n5) -- (n2) -- (n6) -- (n0);
\draw (n0) -- (n7) -- (n3);
\draw (n1) -- (n8) -- (n3);
\draw (n2) -- (n9) -- (n3);
\end{tikzpicture}
\\[1 em]
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
PYRAMID &
PYRAMID13
\\
\tikzsetnextfilename{pyramid}
\begin{tikzpicture}[scale = 2, tdplot_main_coords]
\cnode(n0,0,0,0,1,below right);
\cnode(n1,2,0,0,4,below right);
\cnode(n2,2,2,0,3,below right);
\cnode(n3,0,2,0,2,below right);
\cnode(n4,1,1,2,5,right);
\draw (n0) -- (n1) -- (n2) -- (n3) -- (n0);
\draw (n0) -- (n4);
\draw (n1) -- (n4);
\draw (n2) -- (n4);
\draw (n3) -- (n4);
\end{tikzpicture}
&
\tikzsetnextfilename{pyramid13} % VTK != gmsh
\begin{tikzpicture}[scale = 2, tdplot_main_coords]
\cnode(n0,0,0,0,1,below right);
\cnode(n1,2,0,0,4,below right);
\cnode(n2,2,2,0,3,below right);
\cnode(n3,0,2,0,2,below right);
\cnode(n4,1,1,2,5,right);
\cnode(n5,1,0,0,8,below right);
\cnode(n6,2,1,0,7,below right);
\cnode(n7,1,2,0,9,below right);
\cnode(n8,0,1,0,6,below right);
\cnode(n9,0.5,0.5,1,10,below right);
\cnode(n10,1.5,0.5,1,13,below right);
\cnode(n11,1.5,1.5,1,12,below right);
\cnode(n12,0.5,1.5,1,11,right);
\draw (n0) -- (n5) -- (n1) -- (n6) -- (n2) -- (n7) -- (n3) -- (n8) -- (n0);
\draw (n0) -- (n9) -- (n4);
\draw (n1) -- (n10) -- (n4);
\draw (n2) -- (n11) -- (n4);
\draw (n3) -- (n12) -- (n4);
\end{tikzpicture}
\\[1 em]
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
PRISM &
PRISM15
\\
\tikzsetnextfilename{wedge} % gmsh != VTK
\begin{tikzpicture}[scale = 2, tdplot_main_coords]
\cnode(n0,0,0,0,1,below right);
\cnode(n1,2,0,0,3,below right);
\cnode(n2,0,2,0,2,below right);
\cnode(n3,0,0,2,4,below right);
\cnode(n4,2,0,2,6,below right);
\cnode(n5,0,2,2,5,below right);
\draw (n0) -- (n1) -- (n2) -- (n0);
\draw (n3) -- (n4) -- (n5) -- (n3);
\draw (n0) -- (n3);
\draw (n1) -- (n4);
\draw (n2) -- (n5);
\end{tikzpicture}
&
\tikzsetnextfilename{wedge15} % VTK != gmsh
\begin{tikzpicture}[scale = 2, tdplot_main_coords]
\cnode(n0,0,0,0,1,below right);
\cnode(n1,2,0,0,3,below right);
\cnode(n2,0,2,0,2,below right);
\cnode(n3,0,0,2,4,below right);
\cnode(n4,2,0,2,6,below right);
\cnode(n5,0,2,2,5,below right);
\cnode(n6,1,0,0,8,below right);
\cnode(n7,1,1,0,9,below right);
\cnode(n8,0,1,0,7,below right);
\cnode(n9,1,0,2,14,below right);
\cnode(n10,1,1,2,15,below right);
\cnode(n11,0,1,2,13,below right);
\cnode(n12,0,0,1,10,below right);
\cnode(n13,2,0,1,12,below right);
\cnode(n14,0,2,1,11,below right);
\draw (n0) -- (n6) -- (n1) -- (n7) -- (n2) -- (n8) -- (n0);
\draw (n3) -- (n9) -- (n4) -- (n10) -- (n5) -- (n11) -- (n3);
\draw (n0) -- (n12) -- (n3);
\draw (n1) -- (n13) -- (n4);
\draw (n2) -- (n14) -- (n5);
\end{tikzpicture}
\\[1 em]
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
HEX &
HEX20
\\
\tikzsetnextfilename{hexahedron}
\begin{tikzpicture}[scale = 2, tdplot_main_coords]
\cnode(n0,0,0,0,1,below right);
\cnode(n1,2,0,0,4,below right);
\cnode(n2,2,2,0,3,below right);
\cnode(n3,0,2,0,2,below right);
\cnode(n4,0,0,2,5,below right);
\cnode(n5,2,0,2,8,below right);
\cnode(n6,2,2,2,7,below right);
\cnode(n7,0,2,2,6,below right);
\draw (n0) -- (n1) -- (n2) -- (n3) -- (n0);
\draw (n4) -- (n5) -- (n6) -- (n7) -- (n4);
\draw (n0) -- (n4);
\draw (n1) -- (n5);
\draw (n2) -- (n6);
\draw (n3) -- (n7);
\end{tikzpicture}
&
\tikzsetnextfilename{hexahedron20} % VTK != gmsh
\begin{tikzpicture}[scale = 2, tdplot_main_coords]
\cnode(n0,0,0,0,1,below right);
\cnode(n1,2,0,0,4,below right);
\cnode(n2,2,2,0,3,below right);
\cnode(n3,0,2,0,2,below right);
\cnode(n4,0,0,2,5,below right);
\cnode(n5,2,0,2,8,below right);
\cnode(n6,2,2,2,7,below right);
\cnode(n7,0,2,2,6,below right);
\cnode(n8,1,0,0,11,below right);
\cnode(n9,2,1,0,10,below right);
\cnode(n10,1,2,0,12,below right);
\cnode(n11,0,1,0,9,below right);
\cnode(n12,1,0,2,15,below right);
\cnode(n13,2,1,2,14,below right);
\cnode(n14,1,2,2,16,below right);
\cnode(n15,0,1,2,13,below right);
\cnode(n16,0,0,1,17,below right);
\cnode(n17,2,0,1,20,below right);
\cnode(n18,2,2,1,19,below right);
\cnode(n19,0,2,1,18,below right);
\draw (n0) -- (n8) -- (n1) -- (n9) -- (n2) -- (n10) -- (n3) -- (n11) -- (n0);
\draw (n4) -- (n12) -- (n5) -- (n13) -- (n6) -- (n14) -- (n7) -- (n15) -- (n4);
\draw (n0) -- (n16) -- (n4);
\draw (n1) -- (n17) -- (n5);
\draw (n2) -- (n18) -- (n6);
\draw (n3) -- (n19) -- (n7);
\end{tikzpicture}
\end{tabular}
\end{document}
================================================
FILE: doc/ng4.tex
================================================
%
% Requires latex and latex2html packages
%
% Generate pdf-file with
% pdflatex ng4.tex
%
% Generate html docu with
% latex2html ng4.tex
%
\documentclass[12pt]{book}
\usepackage{a4, epsf, graphicx}
\usepackage{html}
\title{NETGEN - 4.X}
\author{Joachim Sch\"oberl}
\unitlength=1cm
\begin{document}
\maketitle
\tableofcontents
\chapter{Getting Started}
WARNING: DOCUMENTATION IS NOT UP TO DATE
\section{What is NETGEN}
NETGEN is an automatic mesh generation tool for two and three
dimensions. Netgen is open source under the conditions of the LGPL.
It comes as stand alone programme with graphical user
interface, or as C++ library to be linked into an other application.
Netgen is available for Unix/Linux and Windows 98/NT. Netgen
generates triangular or quadrilateral meshes in 2D, and tetrahedral
meshes in 3D. The input for 2D is described by spline curves, and the
input for 3D problems is either defined by constructive solid
geometries (CSG), see Chapter \ref{chap_csg}, or by the standard STL
file format. NETGEN contains modules for mesh optimization and
hierarchical mesh refinement. Curved elements are supported of arbitrary
order.
\section{The history of NETGEN}
%
The NETGEN project was started 1994 in the master's programme of
Joachim Sch\"oberl, under supervision of Prof. Ulrich Langer, at the
Department of Computational Mathematics and Optimization, University
Linz, Austria. Its further development was supported by the Austrian
science Fund ``Fonds zur F\"orderung der wissenschaftlichen
Forschung'' (http://www.fwf.ac.at) under projects P 10643-TEC and SFB
1306. Starting from 2002, the development continued within the Start
project ``hp-FEM'' (http://www.hpfem.jku.at) granted by the FWF. In
2006, the Netgen development moved together with J.~Sch\"oberl to RWTH
Aachen University, Germany (http://www.mathcces.rwth-aachen.de/netgen).
\section{How to receive NETGEN}
%
The latest NETGEN source code release is available from sourceforge
\begin{center}
http://sourceforge.net/projects/netgen-mesher
\end{center}
There are file releases, as well as a public SVN repository containing
the latest sources.
The latest NETGEN Windows executable is available from
\begin{center}
http://www.mathcces.rwth-aachen.de/netgen
\end{center}
\section{Installing NETGEN}
THIS SECTION NEEDS UPDATE
INFORMATION AVAILABLE AT http://netgen-mesher.wiki.sourceforge.net/
\subsection{Installing NETGEN for Unix/Linux}
To install NETGEN on Unix/Linux you will download the source code and
compile it yourself. You need the following libraries:
\begin{itemize}
\item
The 3D visualization library {\bf OpenGL}.
It comes with most systems with hardware graphics. The free
software version mesagl is available from
\htmladdnormallink{http://www.mesa3d.org}{http://www.mesa3d.org/}.
\item
The graphical toolkit {\bf TclTk} developed by John Ousterhout
(available from \htmladdnormallink{http://www.scriptics.com/}{http://www.scriptics.com/}) and its extension {\bf Tix} available from \htmladdnormallink{http://www.sourceforge.com}{http://www.sourceforge.com/}) by Iam Lan.
Netgen has been tested with version TclTk 8.0 - TclTk 8.4 and Tix 4.6. - Tix 8.2
\end{itemize}
You can also download these packages from the Netgen site.
To install NETGEN please move into the directory ng4.
You set the Unix-variable MACHINE according to
your machine/operating system, e.g.
\begin{quote}
\tt
setenv MACHINE LINUX
\end{quote}
%
(in bash shell you type {\tt export MACHINE=LINUX}).
The Makefile includes the makefile-include
\begin{quote}
\tt
libsrc/makefile.mach.\$(MACHINE)
%$
\end{quote}
Please create/modify the according file,
(e.g. copy makefile.mach.LINUX to makefile.mach.SUN). Then you enter
{\bf \tt make} to build the executable.
\medskip
To make NETGEN globally available you just copy the binary ``ng''
to the global bin - directory. In difference to earlier versions,
it needs no additional files.
\subsection{Installing NETGEN for Windows}
NETGEN is available now for Windows in binary form. You download
the zip - archive {\tt ng4win.zip}. After unpacking it with winzip,
you can start the executable ``ng4.exe''.
\subsection{Adding IGES/STEP file support via OpenCascade}
\label{subsec_occ}
NETGEN is capable of importing IGES and STEP geometry files. If you want to use this functionality you have the add the OpenCascade library to your NETGEN distribution.
OpenCascade is an open source 3D solid modeller library by OpenCASCADE S.A. You can obtain it from \htmladdnormallink{http://www.opencascade.org}{http://www.opencascade.org/} (Linux and Windows).
To compile NETGEN with OpenCascade for Windows just choose the project settings ``Release (OCC)'' and adjust the proper search paths.
For Linux adjust the directory search paths OCC\_DIR, OCCINC\_DIR and OCCLIB\_DIR in the Makefile and in libsrc/makefile.inc. Then add -DOCCGEOMETRY to the CPLUSPLUSFLAGS2 in libsrc/makefile.mach.\$(MACHINE). If you use OpenCascade version 5.2 also add -DOCC52 and -DHAVE\_IOSTREAM to the CPLUSPLUSFLAGS2.
\subsection{Testing Netgen}
Please start Netgen by entering ``ng'' or clicking the ``ng.exe'' icon.
A white window with menu items should appear. Please load a geometry
file by selecting "File {\tt ->} Load Geometry", choose e.g.
tutorials/cube.geo. Then press the button "Generate Mesh". By keeping
pressed the left, middle or right button of your mouse you can rotate,
move or zoom the object. With ``File {\tt->} Export Mesh'' you can
save the mesh file.
\chapter{Constructive Solid Geometry (CSG)}
\label{chap_csg}
%
The CSG input format is a useful geometry format for small and
medium size geometries. One defines the geometry by writing an
ASCII file in a text editor.
The geometry is defined by the Eulerian operations (union,
intersection and complement) from primitives. A complete list of
available primitives is given in Section~\ref{sec_primitives}.
The following input describes a cube:
\begin{quote}
\begin{verbatim}
# A cube
algebraic3d
solid cube = orthobrick (0, 0, 0; 1, 1, 1);
tlo cube;
\end{verbatim}
\end{quote}
Lines starting with $\#$ are comment lines. Every CSG file must contain the
keyword {\tt algebraic3d} before any non-comment line.
The keyword {\tt solid} defines a named solid, here the solid {\it cube}
is defined. A solid is defined by the Eulerian operations applied to
primitives. Here, the solid is just the primitive defined by {\tt orthobrick}.
This is a brick parallel to the axis, specified by the minimal $x$, $y$, and
$z$ coordinates, and the maximal $x$, $y$, and $z$ coordinates. The present
definition gives the cube $[0,1]^3$. Finally, the definition {\tt tlo cube}
declares the solid {\it cube} as a top-level-object, what is necessary for
meshing.
Please start netgen with the geometry file above by entering
\begin{quote}
ng cube.geo
\end{quote}
Instead, you can also load the geometry from the file menu. You will
see a blue cube, which you can rotate by keeping the left mouse button
pressed. Pressing the big {\bf generate mesh} button will result in a
(very coarse) mesh of that cube.
Instead of using the primitive {\tt orthobrick}, one can also specify
a cube by intersecting six halfspaces (called planes). Each primitive
{\tt plane} is given by an arbitrary point in the plane, and a outward
vector, not necessarily a unit vector. The six halfspaces are intersected
by the keyword {\tt and}. The following input gives an equivalent result:
\begin{quote}
\begin{verbatim}
# A cube
algebraic3d
solid cube = plane (0, 0, 0; 0, 0, -1)
and plane (0, 0, 0; 0, -1, 0)
and plane (0, 0, 0; -1, 0, 0)
and plane (1, 1, 1; 0, 0, 1)
and plane (1, 1, 1; 0, 1, 0)
and plane (1, 1, 1; 1, 0, 0);
tlo cube;
\end{verbatim}
\end{quote}
To drill a hole though the cube, we will intersect the cube
and the complement of a cylinder. A cylinder is defined by two points
on the central axis, and the radius. Please note, a cylinder is
understood as an infinitely long cylinder (although the visualization
may suggest a finite cylinder):
\begin{quote}
\begin{verbatim}
# cube with hole
algebraic3d
solid cubehole = orthobrick (0, 0, 0; 1, 1, 1)
and not cylinder (0.5, 0.5, 0; 0.5, 0.5, 1; 0.1);
tlo cubehole;
\end{verbatim}
\end{quote}
Like {\tt and} denotes the intersection, {\tt or} denotes the union:
\begin{quote}
\begin{verbatim}
solid cubeball = orthobrick (0, 0, 0; 1, 1, 1)
or sphere (0, 0, 0; 0.5) -maxh=0.2;
\end{verbatim}
\end{quote}
The flag {\tt -maxh=0.2} assigns the maximal mesh size of $0.2$ to
the solid. The current version, NG4.1, uses the mesh size assigned to
the main solid of the top-level-object for the domain. Future version
will contain more possibilities to define mesh-sizes for parts of a
domain.
It is possible to define geometries with several sub-domains, simply
by declaring several tlos:
\begin{quote}
\begin{verbatim}
algebraic3d
solid cube = orthobrick (0, 0, 0; 1, 1, 1);
solid cyl = cylinder (0.5, 0.5, 0; 0.5, 0.5, 1; 0.1);
solid dom1 = cube and not cyl;
solid dom2 = cube and cyl;
tlo dom1 -col=[0,0,1] -transparent;
tlo dom2 -col=[1,0,0];
\end{verbatim}
\end{quote}
This example show also solid trees involving previously defined named
solids. Top-level-objects can be assigned a color specified by the
amount of red, green and blue (RGB) values. The flag {\tt
-transparent} makes the solid appear transparent.
It is possible to specify boundary condition numbers for individual
surfaces of a solid. The flag {\tt -bc} assigns the bc to all
surfaces of that solid-tree. If several flags are given the one closest
to the leaves of the tree dominates. The following file defines a
cube, with $bc=1$ at the bottom, $bc=2$ at the top, and $bc=3$ for
all other surfaces:
\begin{quote}
\begin{verbatim}
algebraic3d
solid bottom = plane (0, 0, 0; 0, 0, -1) -bc=1;
solid top = plane (1, 1, 1; 0, 0, 1) -bc=2;
solid cube = bottm and top
and plane (0, 0, 0; 0, -1, 0)
and plane (0, 0, 0; -1, 0, 0)
and plane (1, 1, 1; 0, 1, 0)
and plane (1, 1, 1; 1, 0, 0) -bc=3;
tlo cube;
\end{verbatim}
\end{quote}
\section{Curves}
For the construction of some of the primitives in the following section it is necessary to define 2D or
3D curves, which are given in terms of straight lines and of quadratic rational spline patches. A line is given
by the two endpoints, a spline patch by three d'Boor points. The patch is an elliptic arc from point 1 to point 3,
such that the lines 1--2 and 2--3 are tangents.
A 2D curve is defined as
\begin{quote}
\samepage
\tt
\begin{tabbing}
aaa\=aaa\=aaa\=aaa\=aaa\=aaa\= \kill
curve2d $name$ = ($np$;\\
\>\> $x_1$, $y_1$;\\
\>\> \ldots\\
\>\> $x_{np}$, $y_{np}$;\\
\>\> $ns$;\\
\>\> [ 2 | 3 ], $p_{1,1}$, $p_{1,2}$ [, $p_{1,3}$];\\
\>\> \ldots\\
\>\> [ 2 | 3 ], $p_{ns,1}$, $p_{ns,2}$ [, $p_{ns,3}$]);
\end{tabbing}
\end{quote}
The number of points is given by $np$, the number of segments by $ns$. Each point is
given by its coordinates, each segment by the number of points
(2 for line segments, 3 for spline patches) and the pointnumbers.
The 3D curves are given analogously by
\begin{quote}
\samepage
\tt
\begin{tabbing}
aaa\=aaa\=aaa\=aaa\=aaa\=aaa\= \kill
curve3d $name$ = ($np$;\\
\>\> $x_1$, $y_1$, $z_1$;\\
\>\> \ldots\\
\>\> $x_{np}$, $y_{np}$, $z_{np}$;\\
\>\> $ns$;\\
\>\> [ 2 | 3 ], $p_{1,1}$, $p_{1,2}$ [, $p_{1,3}$];\\
\>\> \ldots\\
\>\> [ 2 | 3 ], $p_{ns,1}$, $p_{ns,2}$ [, $p_{ns,3}$]);
\end{tabbing}
\end{quote}
\section{Available Primitives}
\label{sec_primitives}
Netgen %4.1
supports the following primitives:
\begin{enumerate}
\item A halfspace, i.e., a plane and everything on one side of it,
given by an arbitrary point~$p = (p_x, p_y, p_z)$ in the plane and
an outside normal vector~$n = (n_x, n_y, n_z)$, not necessarily a
unit vector:
\begin{quote}
\tt
plane ( $p_x$, $p_y$, $p_z$ ; $n_x$, $n_y$, $n_z$ )
\end{quote}
\item
A cylinder of infinite length, given by two points~$a=(a_x, a_y,a_z)$
and $b=(b_x, b_y, b_z)$ on the central axis and the radius $r$:
\begin{quote}
\tt cylinder ( $a_x$, $a_y$, $a_z$ ; $b_x$, $b_y$, $b_z$ ; $r$ )
\end{quote}
\item
A sphere, given by the center~ $c=(c_x,c_y,c_z)$ and the radius~$r$:
\begin{quote}
\tt
sphere ( $c_x$, $c_y$, $c_z$ ; $r$ )
\end{quote}
\item
An elliptic cylinder, given by the point $c=(c_x, c_y, c_z)$ on the main axis,
and the vectors $v$ and $w$ of the long and short axis of the ellipse, respectively:
\begin{quote}
\tt
ellipticcylinder ($c_x$, $c_y$, $c_z$ ; $v_x$, $v_y$, $v_z$ ; $w_x$, $w_y$, $w_z$)
\end{quote}
\item
An ellipsoid, given by the center $c=(c_x, c_y, c_z)$,
and the vectors $u$, $v$ and $w$ of the main axis of the ellipsoid:
\begin{quote}
\tt
ellipsoid ($c_x$, $c_y$, $c_z$ ; $u_x$, $u_y$, $u_z$; $v_x$, $v_y$, $v_z$ ; $w_x$, $w_y$, $w_z$)
\end{quote}
\item A cone is given by two points on the central axis and the two
corresponding radii. It is not possible to mesh the top of the cone
yet, it must be cut off.
\begin{quote}
\tt
cone ( $a_x$, $a_y$, $a_z$ ; $r_a$; $b_x$, $b_y$, $b_z$ ; $r_b$ )
\end{quote}
\item A orthobrick is a brick parallel to the coordinate axis. It is
specified by two opposite corner points $a = (a_x, a_y, a_z)$ and
$b = (b_x, b_y, b_z)$:
\begin{quote}
\tt
orthobrick ( $a_x$, $a_y$, $a_z$ ; $b_x$, $b_y$, $b_z$ )
\end{quote}
\item A polyhedron is defined by a set of triangles forming
a closed polyhedron. First, a set of points is defined, then
the triangles are given by point indices. The triangles must be
oriented counter-clockwise when looking onto the object. The
following polyhedron describes a tetrahedron:
\begin{quote}
\begin{verbatim}
algebraic3d
solid poly = polyhedron (0,0,0; 1,0,0; 0,1,0; 0,0,1 ;;
1,3,2 ; 1,4,3; 1,2,4 ; 2,3,4 );
tlo poly;
\end{verbatim}
\end{quote}
\item A body of extrusion is defined by its profile
(which has to be a closed, \textit{clockwise} oriented 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 $\bar{y} := d - (d \cdot t) t$ and the (local) x-direction $\bar{x} := t \times \bar{y}$. The
syntax is:
\begin{quote}
\tt
extrusion ( <name of pathcurve>; <name of profilecurve>; $d_x$, $d_y$, $d_z$ )
\end{quote}
The following points have to be noticed:
\begin{itemize}
\item 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.
\item The path has to be smooth, i.e.\ the tangents at the end- resp.\ startpoint of two consecutive spline or line patches have
to have the same directions.
\end{itemize}
\item A body of revolution is given by two points, defining the axis of revolution, and the 2D curve which is rotated:
\begin{quote}
\tt
revolution ( $p_{1,x}$, $p_{1,y}$, $p_{1,z}$; $p_{2,x}$, $p_{2,y}$, $p_{2,z}$; <name of curve>)
\end{quote}
The first point defines the origin of the local 2D coordinate system of the curve. It is assumed, that the curve lies above the
(local) x-axis, and that it is described \textit{clockwise}.
If the curve is not closed, then the start point and the end point have to lie on the x-axis, and the tangents at those points
have to be orthogonal to the x-axis.
\end{enumerate}
\section{Surface Identification}
In Netgen it is possible to construct prismatic meshes between two surfaces, where these surfaces
have to be specified explicitly in the .geo file with the command
\begin{quote}
\tt
identify closesurfaces <surface1> <surface2>;
\end{quote}
(this feature originally was intended for close surface, which is the reason for the command name).
\paragraph{Optional parameters:} (selection)
\begin{itemize}
\item \texttt{-tlo=<name of top level object>}\\
the prisms are only constructed between two faces of a tlo.
\item \texttt{-direction=[<x>,<y>,<z>]}\\
This parameter has to be used if \textbf{skew prisms} should be built. In this case netgen ``needs help'' by the user,
it needs to know the direction of identification.
\textit{Example:} We start with a cylinder with the axis given by the points $(-1,0,4)$ and $(4,10,1)$. This cylinder
is cut by the planes \texttt{p1} and \texttt{p2} (which are not necessarily normal to the axis and not necessarily parallel)
and we want to build prisms between
these planes. Then the command would, e.g., look like
\begin{quote}
\tt identify closesurfaces p1 p2 -direction=[5,10,-3]
\end{quote}
\end{itemize}
\section{Known problems and work-arounds}
\subsection{Interfaces}
A airdomain with two connected interior parts may be described by
\begin{quote}
\begin{verbatim}
algebraic3d
solid cube = orthobrick (0, 0, 0; 1, 1, 1);
solid part1 = orthobrick (0.2, 0.2, 0.2; 0.5, 0.8, 0.8);
solid part2 = orthobrick (0.5, 0.2, 0.2; 0.8, 0.8, 0.8);
solid air = cube and not part1 and not part2;
tlo air;
tlo part1;
tlo part2;
\end{verbatim}
\end{quote}
The problem is, that a domain is an open domain. Thus, the domain
{\it air} is not only the outer part, but also the interface between
{\it part1} and {\it part2}. The result is unspecified. To fix this
problem, one can define the {\it air}-domain by cutting out one big
brick:
\begin{quote}
\begin{verbatim}
solid air = cube and not othrobrick (0.2, 0.2, 0.2; 0.8, 0.8, 0.8);
\end{verbatim}
\end{quote}
\subsection{Degenerated edges}
Degenerated edges are found sometimes, but some still cause troubles.
A sphere on top of a cylinder my be described by:
\begin{quote}
\begin{verbatim}
solid cyl = cylinder (0, 0, 0; 1, 0, 0; 0.5)
and plane (0, 0, 0; -1, 0, 0)
and plane (1, 0, 0; 1, 0, 0);
solid main = cyl or sphere (1, 0, 0; 0.5);
tlo main;
\end{verbatim}
\end{quote}
The edge is a degenerated one. A work-around is to split the
domain (artificially) into two non-degenerated parts:
\begin{quote}
\begin{verbatim}
solid cyl = cylinder (0, 0, 0; 1, 0, 0; 0.5)
and plane (0, 0, 0; -1, 0, 0)
and plane (1, 0, 0; 1, 0, 0);
solid hemisphere = sphere (1, 0, 0; 0.5) and not plane (1, 0, 0; -1, 0, 0);
tlo cyl;
tlo hemisphere;
\end{verbatim}
\end{quote}
\chapter{Other Geometry Formats}
\section{Using IGES/STEP Geometries}
%
IGES and STEP are standard exchange formats for CAD files. Contrary to the STL format, IGES and STEP deliver an exact representation of the geometry and do not approximate it. In order to use IGES/STEP geometries you have to install NETGEN with the OpenCascade Geometry Kernel as described in \ref{subsec_occ}. Most solid modellers can export IGES or STEP files. However, often these files are not as exact as a mesher needs them to be. So is meshing fails, try repairing the model via {\bf IGES/STEP Topology Explorer/Doctor}.
\section{Using STL Geometries}
%
STL is a standardized file format to describe (approximate) geometies
by triangulated surfaces. It is useful to describe complicated parts
which are modeled with some CAD programmes. Also, some users have written
their own (C) programmes to define STL geometries, where was not so easy
to use the CSG format. The syntax of STL files is as follows
\begin{quote}
(not available yet. please figure out the syntax from the examples)
\end{quote}
We found that many STL geometries have some difficulties. Some of them
can be corrected (removed) by the {\bf STL - Doctor}. Please see the
corresponding manual pages (not available yet).
\section{2D Spline Geometry}
%
The extension for 2D spline geometry is ``.in2d''.
The boundary is given in terms of straight lines and of quadratic rational
spline patches.
A line is given by the two endpoints, a spline patch by 3 d'Boor
points. The patch is an elliptic arc from point 1 to point 3, such that
the lines 1-2 and 2-3 are tangents.
It is possible to use different subdomains with this format.
This file format also supports a priori mesh grading. To the spline
point i one adds a local refinement factor {\tt rp}$_i$ . Close to
this point the mesh-size $h(x)$ is {\tt h}$_{Glob}$ / {\tt rp}$_i$ .
The global parameter {\tt grading} describes how fast the mesh-size decreases.
The gradient of the local mesh-size function $h(x)$ is bounded by
$| \nabla_x h(x)| \leq \mbox{grading}^{-1}$
Also a refinement by a factor {\tt rs}$_i$ > 1 along the whole
segment i is possible.
The file looks like:
%
\begin{quote}
\samepage
\tt
splinecurves2d \\
grading \\
np \\
x$_1$ y$_1$ rp$_1$ \\
... \\
x$_{np}$ y$_{np}$ rp$_{np}$ \\
ns \\
dil$_1$ dir$_1$ [ 2 | 3 ] pi$_{1,1}$ pi$_{1,2}$ [ pi$_{1,3}$ ] rs$_1$ \\
... \\
dil$_{nl}$ dir$_{nl}$ [ 2 | 3 ] pi$_{nl,1}$ pi$_{nl,2}$ [ pi$_{nl,3}$ ] rs$_{nl}$ \\
\end{quote}
%
{\tt np} is the number of points, {\tt ns} the number of spline segments.
Every segment starts with the domain numbers at the left and at the
right sides of the segment. Domain number 0 is reserved for the exterior.
Then the number of points and two or three point indices follow.
Finally, the refinement factor along the line follows.
\chapter{Mesh and Solution Formats}
You can export meshes to a couple of file formats. Some are self-defined,
some other are standard formats. The self-defined are the following:
\section{Mesh Size File}
By means of a mesh size file you can provide a local mesh size density. The file extension must be {\it .msz}. If you want to use the mesh size file, you specify it in the ``Meshing Options'', dialog box, page ``Mesh Size''.
The syntay is:
\begin{verbatim}
np
x1 y1 z1 h1
x2 y2 z2 h2
....
xnp ynp znp hnp
nl
xs1 ys1 zs1 xe1 ye1 ze1 h1
xs2 ys2 zs2 xe2 ye2 ze2 h2
....
xsnl ysnl zsnl xenl yenl zenl hnl
\end{verbatim}
You specify {\tt np} points, given by the $(x_i,y_i,z_i)$-coordinates,
where the mesh size will be reduced at least to $h_i$. You specify
also {\tt nl} line-segments by the start-point and end-point
coordinates. The mesh-size along the whole line will be reduced to the given $h_i$.
\section{Neutral Format}
The neutral volume mesh format contains the following sections:
\begin{enumerate}
\item
nodes \\
After the number of nodes there follows a list of $x$, $y$,
and $z$-coordinates of the mesh-nodes.
\item
volume elements \\
After the number of volume elements there follows the list of tetrahedra.
Each element is specified by the sub-domain number, and 4 node indices. The
node indices start with 1.
\item
surface elements \\
After the number of surface elements there follows
the list of triangles. Each element is specified by the boundary
condition number, and 3 node indices. The node indices start with 1.
\end{enumerate}
\section{Fepp Format 2D}
The Fepp 2D format contains the following sections:
\begin{enumerate}
\item
boundary segments \\
After the number of boundary segments there follows a list of
segments. Each segment is specified by the spline - patch number,
and the two node indices. Counting starts with 1
\item
domain elements \\
After the number of domain elements there follows the list of elements.
Each element is specified by the sub-domain number, the number of nodes (3 or 4) and the node indices. Counting starts with 1
\item
nodes \\
After the number of nodes there follows a list of $x$ and $y$
-coordinates of the mesh-nodes.
\item
geometric information \\
After the number of spline patches there follows a list of spline specifications. Each spline patch is given by the 6 coefficients of the describing
quadratic polynomial equation
$$
c_1 x^2 + c_2 y^2 + c_3 xy + c_4 x + c_5 y + c_6 = 0
$$
\end{enumerate}
\section{Surface triangulaton file}
One can export to and import from a surface mesh file. It´s structure
is as follows:
\begin{enumerate}
\item
{\tt surfacemesh} \\
starts with that keyword
\item
number of points \\
point coordinates $(x,y,z)$.
\item
number of surface triangles, \\
surface triangles oriented counter-clock wise when looking at the
object, index starts from 1.
\end{enumerate}
\section{Solution File Format}
The Netgen software includes also a simple visualizer for finite
element gridfunctions. It supports scalar fields (e.g. temperature),
and vector valued fields (flow velocities, mechanical deformations).
The solution field is imported by the menu item File $->$ Import Solution.
It is important to load the corresponding mesh in advance.
The format of the solution file is as follows. It consists of an
arbitrary number of blocks of this structure:
\begin{enumerate}
\item
{\tt solution} {\it function-name} flags
{\tt solution} is the keyword, {\it function-name} is a string to
refer to that functions. The supported flags are
\begin{enumerate}
\item -size=s \\
number of entries (default: number of mesh-points)
\item -components=c \\
number of components (default: 1). Mechanical deformations have 3 components.
\item -type=[nodal,element,surfaceelement] \\
the grid-funciton has nodal values, or one value per volume element,
or one value per surface element (default: nodal)
\end{enumerate}
\item
block of $size \times components$ values
\end{enumerate}
Please try out to import the solution file 'tutorials/cube.sol' fitting
to the mesh 'tutorials/cube.vol'.
\chapter{Netgen operations}
You can use netgen in interactive mode using its menus, or, you
can run netgen in batch-mode using command line arguments.
\section{Command line arguments}
Command line arguments are specified as {\it -flag=value}.
\begin{itemize}
\item -help \newline
Prints the available command line arguments
\item -geofile=filename \newline
Specifies geometry file. Is equivalent to {\it filename}, i.e., you can
scip {\it -geofile=}.
\item -meshfile=filename \newline
Mesh file will be stored in file {\it filename}.
\item -batchmode \newline
Exit after mesh generation. Otherwise, the GUI will be started
\item -V \newline
Verbose mode. Prints some additional information
\item -verycoarse, -coarse, -moderate, -fine, -veryfine \newline
Mesh size control
\end{itemize}
\chapter{Using the Graphical User Interface}
The Netgen main window looks like:
\begin{center}
\includegraphics[width=12cm]{pictures/screenshot}
\end{center}
It consists of the menuline and the button line at the top, the status line at
the bottom, and the large drawing window. The menu items will be explained in
\ref{sec_menuitems}. The button line provides shot-cuts for common opteration:
\begin{itemize}
\item Quit \newline
Terminate Netgen
\item Generate mesh \newline
Perform mesh generation
\item Stop Meshing \newline
Stop mesh generation
\item Geometry/Edges/Mesh/Solution \newline
Switch between operation modes of visualization.
\item Zoom all \newline
Zooms such that the whole visualization scene fits into the window.
\item Center \newline
Center rotation and scaling at marked point, available only in mesh - visuailzation mode.
\item Rotate/Move/Zoom
Left mouse drag rotates/moves/zooms object.
\end{itemize}
The status line shows information, namely
\begin{itemize}
\item Points \newline
Number of points in the mesh
\item Elements \newline
Number of volume elements (3D) in the mesh
\item Surf Elements \newline
Number of surface elements (3D) or inner elements (2d) in the mesh.
\item Mem \newline
Used memory in the large memory arena
\item Meshing Job, percentage
Douriing mesh generation, the current job as well as the progress is displayed on the
right side of the statu line.
\end{itemize}
The drawing window displays the geometry or the mesh. The view
can be changed with the mouse:
\begin{itemize}
\item drag with left button pressed rotates the object,
\item drag with middle button pressed moves the object,
\item drag with right button pressed zooms the object.
\end{itemize}
The view can also be changed with the keyboard:
\begin{itemize}
\item cursor keys rotate the object
\item shift + cursor keys move the object
\item control + cursor keys zoom the object
\end{itemize}
When in Mesh - visualization scene, double clicking on triangles mark the
surface. The point cursor is set.
\section{The Netgen menu items}
\label{sec_menuitems}
\subsection{The menu item {\em File}}
\includegraphics[height=7.8cm]{pictures/menufile}
\subsection{The menu item {\em Geometry}}
\includegraphics[height=2.7cm]{pictures/menugeometry}
\subsection{The menu item {\em Mesh}}
\includegraphics[height=9.8cm]{pictures/menumesh}
\subsection{The menu item {\em View}}
\includegraphics[height=6.0cm]{pictures/menuview}
\subsection{The menu item {\em Refinement}}
\includegraphics[width=3.2cm]{pictures/menurefinement}
\section{Meshing Options}
\includegraphics[width=10cm]{pictures/meshingoptions_1}
\includegraphics[width=10cm]{pictures/meshingoptions_2}
\includegraphics[width=10cm]{pictures/meshingoptions_3}
\includegraphics[width=10cm]{pictures/meshingoptions_4}
\includegraphics[width=10cm]{pictures/meshingoptions_5}
\includegraphics[width=10cm]{pictures/meshingoptions_6}
\section{Visualization Options}
% \chapter{The Algorithms of Netgen}
%
% Netgen follows a top down strategy. It starts from computing the
% corner points (CSG only). Then, the edges are defined and meshed into
% segments (CSG and STL). Next, the faces are meshed by an advancing front
% surface mesh generator. After meshing, the faces meshes are optimized.
% Finally, the individual sub-domains are filled with tets. Therefore,
% a fast Delaunay algorithm generates most of the elements (about 98 percent).
% But often it fails for mesh the whole domain, then the slower back-tracking
% rule-base algorithm takes over. Finally, the volume is optimized by the
% usual node - movement, element swapping and splitting algorithms.
\chapter{Programming Interfaces}
%
\section{The nginterface}
By means of the nginterface one's own simulation code can be
included into the netgen environment. This is particular useful
for FEM (FVM,BEM) code developers, since they may profit from the
netgen preprocessing and postprocessing possibilities.
Please download the example Netgen-add-on module {\it demoapp} and
follow the instructions therein
\section{The nglib}
\subsection{Introduction}
The NETGEN mesh generation library {\it nglib} is available in C++
source code and can be compiled for Unix/Linux as well as Win95/98/NT
and linked to one library file. The interface to the application
programme is by the C language header file {\it nglib.h}.
The functionality of nglib is volume mesh generation by a domain given
by a surface triangulation, and surface mesh generation from a domain
described by an STL file (standard file format for geometries defined by
triangle approximation). It can do mesh optimization as well as mesh
refinement. It can generate 4 node tetrahedra and 10 node tetrahedrons
(with quadratic shape functions). The local mesh size can be defined
automatically by geometric features and/or by user specification.
\subsection{The Header File}
The interface file contains the following type definitions and function
calls. All Netgen types and functions start with {\tt Ng}. Types and
functions have capital initial letters, constants are in capital letters.
\subsection{Types and Constants}
\begin{verbatim}
/// Data type for NETGEN mesh
typedef void * Ng_Mesh;
/// Data type for NETGEN STL geomty
typedef void * Ng_STL_Geometry;
// max number of nodes per element
#define NG_VOLUME_ELEMENT_MAXPOINTS 10
// implemented element types:
enum Ng_Volume_Element_Type { NG_TET = 1, NG_PYRAMID = 2, NG_PRISM = 3,
NG_TET10 = 4 };
// max number of nodes per surface element
#define NG_SURFACE_ELEMENT_MAXPOINTS 6
// implemented element types:
enum Ng_Surface_Element_Type { NG_TRIG = 1, NG_QUAD = 2,
NG_TRIG6 = 3 };
struct Ng_Meshing_Parameters
{
double maxh;
double fineness; // 0 .. coarse, 1 .. fine
int secondorder;
};
enum Ng_Result { NG_OK = 0,
NG_SURFACE_INPUT_ERROR = 1,
NG_VOLUME_FAILURE = 2,
NG_STL_INPUT_ERROR = 3,
NG_SURFACE_FAILURE = 4 };
\end{verbatim}
{\tt Ng\_Mesh} is a data type representing a Netgen mesh. {\tt Ng\_STL\_Geometry}
represents an STL geometry. One can operate on these data structures by
the functions defined below. Netgen can (now and/or in future) work with
various element types defined by generic constants. Several parameters
can be specified in the {\tt Ng\_Meshing\_Parameters} structure for
volume and/or surface mesh generation. The result of Netgen functions
is of type {\tt Ng\_Result}.
\subsection{Initialization}
Please call these functions before using netgen functions and after
using netgen functions, respectively:
\begin{verbatim}
// initialize, deconstruct Netgen library:
void Ng_Init ();
void Ng_Exit ();
\end{verbatim}
\subsection{Mesh access}
Netgen meshes can be processed by the means of the following functions.
A mesh contains nodes, surface elements and volume elements. Counting
starts from 1.
\begin{verbatim}
// Generates new mesh structure
Ng_Mesh * Ng_NewMesh ();
void Ng_DeleteMesh (Ng_Mesh * mesh);
// feeds points, surface elements and volume elements to the mesh
void Ng_AddPoint (Ng_Mesh * mesh, double * x);
void Ng_AddSurfaceElement (Ng_Mesh * mesh, Ng_Surface_Element_Type et,
int * pi);
void Ng_AddVolumeElement (Ng_Mesh * mesh, Ng_Volume_Element_Type et,
int * pi);
// ask for number of points, surface and volume elements
int Ng_GetNP (Ng_Mesh * mesh);
int Ng_GetNSE (Ng_Mesh * mesh);
int Ng_GetNE (Ng_Mesh * mesh);
// return point coordinates
void Ng_GetPoint (Ng_Mesh * mesh, int num, double * x);
// return surface and volume element in pi
Ng_Surface_Element_Type
Ng_GetSurfaceElement (Ng_Mesh * mesh, int num, int * pi);
Ng_Volume_Element_Type
Ng_GetVolumeElement (Ng_Mesh * mesh, int num, int * pi);
\end{verbatim}
\subsubsection{Mesh Generation}
The user can specify the mesh size function by the global parameter
maximal mesh size, and can additionally restrict the mesh size in
points or cubes. The function {\tt Ng\_GenerateVolumeMesh} generates
the volume mesh starting from the surface.
\begin{verbatim}
// Defines MeshSize Functions
void Ng_RestrictMeshSizeGlobal (Ng_Mesh * mesh, double h);
void Ng_RestrictMeshSizePoint (Ng_Mesh * mesh, double * p, double h);
void Ng_RestrictMeshSizeBox (Ng_Mesh * mesh, double * pmin, double * pmax, double h);
// generates volume mesh from surface mesh
Ng_Result Ng_GenerateVolumeMesh (Ng_Mesh * mesh, Ng_Meshing_Parameters * mp);
\end{verbatim}
\subsection{STL Geometry}
A STL geometry can be read from a STL file (ASCII or binary), or can
be assembled by providing triangle by triangle. Either, the user
can specify the edges of the geometry, or netgen can define edges
by {\tt Ng\_STL\_MakeEdges} by using an angle criterium.
\begin{verbatim}
// loads geometry from STL file
Ng_STL_Geometry * Ng_STL_LoadGeometry (char * filename, int binary = 0);
// generate new STL Geometry
Ng_STL_Geometry * Ng_STL_NewGeometry ();
// fills STL Geometry
// positive orientation
// normal vector may be null-pointer
void Ng_STL_AddTriangle (Ng_STL_Geometry * geom,
double * p1, double * p2, double * p3, double * nv);
// add (optional) edges:
void Ng_STL_AddEdge (Ng_STL_Geometry * geom,
double * p1, double * p2);
// after adding triangles (and edges) initialize
Ng_Result Ng_STL_InitSTLGeometry (Ng_STL_Geometry * geom);
// automatically generates edges:
void Ng_STL_MakeEdges (Ng_STL_Geometry * geom);
// generates mesh, empty mesh be already created.
Ng_Result Ng_STL_GenerateSurfaceMesh (Ng_STL_Geometry * geom,
Ng_Mesh * mesh,
Ng_Meshing_Parameters * mp);
\end{verbatim}
\subsection{Programming Example}
The File {\it ngcore.cc}, see Appendix A, is a simple application
using the netgen volume mesh generator. First, the surface mesh
is read from a file containing point coordinates and surface triangles
(see e.g. file {\it cube.surf}). The volume mesh generate is called,
and the volume mesh is written to the standard output, see file {\it cube.vol}.
\end{document}
================================================
FILE: external_dependencies/.gitignore
================================================
*.tar.gz
================================================
FILE: libsrc/CMakeLists.txt
================================================
add_subdirectory(core)
add_subdirectory(general)
add_subdirectory(gprim)
add_subdirectory(linalg)
add_subdirectory(include)
add_subdirectory(meshing)
if(USE_OCC)
add_subdirectory(occ)
endif(USE_OCC)
if(USE_STLGEOM)
add_subdirectory(stlgeom)
endif(USE_STLGEOM)
if(USE_GUI)
add_subdirectory(visualization)
endif(USE_GUI)
if(USE_INTERFACE)
add_subdirectory(interface)
endif(USE_INTERFACE)
if(USE_CSG)
add_subdirectory(csg)
endif(USE_CSG)
if(USE_GEOM2D)
add_subdirectory(geom2d)
endif(USE_GEOM2D)
================================================
FILE: libsrc/core/.clang-tidy
================================================
Checks: '*,-cppcoreguidelines-avoid-non-const-global-variables,-llvmlibc-restrict-system-libc-headers,-clang-analyzer-alpha.*,-*braces-around-statements,-fuchsia-*,-google-runtime-references,-readability-implicit-bool-conversion,-google-explicit-constructor,-hicpp-explicit-conversions,-google-runtime-int,-llvm-header-guard,-modernize-pass-by-value,-cppcoreguidelines-non-private-member-variables-in-classes,-misc-non-private-member-variables-in-classes,-readability-magic-numbers,-cppcoreguidelines-avoid-magic-numbers'
CheckOptions:
- key: cppcoreguidelines-special-member-functions.AllowSoleDefaultDtor
value: 1
- key: cppcoreguidelines-macro-usage.AllowedRegexp
value: NGCORE_*|NETGEN_*|NG_EXCEPTION*
WarningsAsErrors: '*'
================================================
FILE: libsrc/core/CMakeLists.txt
================================================
add_library(ngcore ${NGCORE_LIBRARY_TYPE}
archive.cpp
bitarray.cpp
exception.cpp
localheap.cpp
logging.cpp
flags.cpp
paje_trace.cpp
profiler.cpp
table.cpp
taskmanager.cpp
utils.cpp
version.cpp
ng_mpi_wrapper.cpp
statushandler.cpp
)
string(REPLACE "|" ";" ng_compile_flags_replace_sep "${NG_COMPILE_FLAGS}")
target_compile_options(ngcore PUBLIC ${ng_compile_flags_replace_sep})
if(EMSCRIPTEN)
set(PYTHON_MODULE_EXTENSION ".so")
target_link_options(ngcore PUBLIC -sALLOW_MEMORY_GROWTH -sENVIRONMENT=web -sWASM_BIGINT -fwasm-exceptions)
target_compile_options(ngcore PUBLIC -fwasm-exceptions)
endif()
if (CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND USE_PYTHON)
# Python packages on Linux are compiled with the old ABI,
# make sure that the same ABI is used in plugins aswell
try_run(
ret_val can_compile
${CMAKE_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/_get_glibcxx_use_cxx11_abi.cpp
RUN_OUTPUT_VARIABLE use_glibcxx_cxx11_abi
)
target_compile_definitions(ngcore PUBLIC -D_GLIBCXX_USE_CXX11_ABI=${use_glibcxx_cxx11_abi})
try_run(
ret_val can_compile
${CMAKE_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/_get_gxx_abi.cpp
RUN_OUTPUT_VARIABLE default_cxx_abi_version
)
if(${can_compile} AND (${ret_val} EQUAL 0))
# Different python modules using pybind11 need to use the same C++ ABI version
# for compatibility
set(cxx_abi_version 17)
message(STATUS "GNU C++ ABI version: ${cxx_abi_version}")
target_compile_options(ngcore PUBLIC "-fabi-version=${cxx_abi_version}")
endif()
endif()
if(USE_PYTHON)
target_sources(ngcore PRIVATE python_ngcore.cpp)
target_compile_definitions(ngcore PUBLIC NETGEN_PYTHON NG_PYTHON PYBIND11_SIMPLE_GIL_MANAGEMENT)
endif(USE_PYTHON)
if(WIN32)
target_compile_options(ngcore PUBLIC /bigobj $<BUILD_INTERFACE:/MP;/W1;/wd4068>)
get_WIN32_WINNT(ver)
target_compile_definitions(ngcore PUBLIC _WIN32_WINNT=${ver} WNT WNT_WINDOW NOMINMAX MSVC_EXPRESS _CRT_SECURE_NO_WARNINGS HAVE_STRUCT_TIMESPEC WIN32)
target_link_options(ngcore PUBLIC /ignore:4273 /ignore:4217 /ignore:4049)
else(WIN32)
target_link_libraries(ngcore PUBLIC dl)
endif(WIN32)
target_compile_definitions(ngcore PRIVATE NGCORE_EXPORTS)
target_include_directories(ngcore INTERFACE $<INSTALL_INTERFACE:${NG_INSTALL_DIR_INCLUDE}> $<INSTALL_INTERFACE:${NG_INSTALL_DIR_INCLUDE}/include>)
if(CHECK_RANGE)
target_compile_definitions(ngcore PUBLIC NETGEN_ENABLE_CHECK_RANGE)
endif(CHECK_RANGE)
if(CMAKE_BUILD_TYPE STREQUAL "Debug" OR CMAKE_BUILD_TYPE STREQUAL "DEBUG")
target_compile_definitions(ngcore PUBLIC _DEBUG NETGEN_ENABLE_CHECK_RANGE)
endif(CMAKE_BUILD_TYPE STREQUAL "Debug" OR CMAKE_BUILD_TYPE STREQUAL "DEBUG")
if(TRACE_MEMORY)
target_compile_definitions(ngcore PUBLIC NETGEN_TRACE_MEMORY)
endif(TRACE_MEMORY)
if(USE_NUMA)
find_library(NUMA_LIBRARY libnuma.so)
target_compile_definitions(ngcore PUBLIC USE_NUMA)
target_link_libraries(ngcore PRIVATE ${NUMA_LIBRARY})
endif(USE_NUMA)
install(TARGETS ngcore DESTINATION ${NG_INSTALL_DIR} COMPONENT netgen)
target_link_libraries(ngcore PRIVATE "$<BUILD_INTERFACE:netgen_python>" ${CMAKE_THREAD_LIBS_INIT})
install(FILES ngcore.hpp archive.hpp type_traits.hpp version.hpp ngcore_api.hpp logging.hpp memtracer.hpp
exception.hpp symboltable.hpp paje_trace.hpp utils.hpp profiler.hpp mpi_wrapper.hpp
array.hpp taskmanager.hpp concurrentqueue.h localheap.hpp python_ngcore.hpp flags.hpp
xbool.hpp signal.hpp bitarray.hpp table.hpp hashtable.hpp ranges.hpp ngstream.hpp
simd.hpp simd_avx.hpp simd_avx512.hpp simd_generic.hpp simd_math.hpp simd_sse.hpp simd_arm64.hpp
register_archive.hpp autodiff.hpp autodiffdiff.hpp
ng_mpi.hpp ng_mpi_generated_declarations.hpp mpi4py_pycapi.h ng_mpi_native.hpp statushandler.hpp
DESTINATION ${NG_INSTALL_DIR_INCLUDE}/core COMPONENT netgen_devel)
if(ENABLE_CPP_CORE_GUIDELINES_CHECK)
set_target_properties(ngcore PROPERTIES CXX_CLANG_TIDY "${DO_CLANG_TIDY}")
endif(ENABLE_CPP_CORE_GUIDELINES_CHECK)
add_dependencies(ngcore ng_generate_version_file)
if(USE_PYTHON)
pybind11_add_module(pyngcore MODULE python_ngcore_export.cpp)
target_link_libraries(pyngcore PUBLIC ngcore PRIVATE "$<BUILD_INTERFACE:netgen_python>")
set_target_properties(pyngcore PROPERTIES INSTALL_RPATH "${NG_RPATH_TOKEN}/../${NETGEN_PYTHON_RPATH}")
if(EMSCRIPTEN)
target_link_options(pyngcore PUBLIC -sALLOW_MEMORY_GROWTH -sENVIRONMENT=web -sWASM_BIGINT -fwasm-exceptions)
endif(EMSCRIPTEN)
install(TARGETS pyngcore DESTINATION ${NG_INSTALL_DIR_PYTHON}/pyngcore COMPONENT netgen)
endif(USE_PYTHON)
function (build_mpi_variant)
set(target ng_${ARGV0})
set(include_dir ${ARGV1})
message("1Building MPI variant: ${ARGV0} ${ARGV1}")
add_library(${target} SHARED ng_mpi.cpp)
target_link_libraries(${target} PUBLIC ngcore PRIVATE "$<BUILD_INTERFACE:netgen_python>")
target_compile_definitions(${target} PUBLIC PARALLEL NG_MPI_WRAPPER)
target_include_directories(${target} PRIVATE ${include_dir})
set_target_properties(${target} PROPERTIES PREFIX "")
install(TARGETS ${target} RUNTIME DESTINATION ${NG_INSTALL_DIR_BIN} LIBRARY DESTINATION ${NG_INSTALL_DIR_LIB} COMPONENT netgen)
endfunction()
if(USE_MPI)
target_compile_definitions(ngcore PUBLIC PARALLEL)
message(STATUS "Found MPI version\n${MPI_C_LIBRARY_VERSION_STRING}")
if(USE_MPI_WRAPPER)
target_compile_definitions(ngcore PUBLIC NG_MPI_WRAPPER)
if(MPI_C_LIBRARY_VERSION_STRING MATCHES "Microsoft MPI.*")
set(MICROSOFT_MPI_INCLUDE_DIR ${MPI_C_HEADER_DIR})
set(MICROSOFT_MPI_LIBRARY ${MPI_msmpi_LIBRARY})
endif()
if(MPI_C_LIBRARY_VERSION_STRING MATCHES "Open MPI.*")
set(OPENMPI_INCLUDE_DIR ${MPI_C_INCLUDE_PATH})
endif()
if(MPI_C_LIBRARY_VERSION_STRING MATCHES "MPICH.*")
set(MPICH_INCLUDE_DIR ${MPI_C_INCLUDE_PATH})
endif()
if(MPI_C_LIBRARY_VERSION_STRING MATCHES "Intel.*")
set(INTEL_MPI_INCLUDE_DIR ${MPI_C_INCLUDE_PATH})
endif()
if(OPENMPI_INCLUDE_DIR)
build_mpi_variant(openmpi ${OPENMPI_INCLUDE_DIR})
endif()
if(MPICH_INCLUDE_DIR)
build_mpi_variant(mpich ${MPICH_INCLUDE_DIR})
endif()
if(INTEL_MPI_INCLUDE_DIR)
build_mpi_variant(intel_mpi ${INTEL_MPI_INCLUDE_DIR})
if(WIN32)
target_link_libraries(ng_intel_mpi PUBLIC ${INTEL_MPI_LIBRARY})
endif()
endif()
if(MICROSOFT_MPI_INCLUDE_DIR)
build_mpi_variant(microsoft_mpi ${MICROSOFT_MPI_INCLUDE_DIR})
target_link_libraries(ng_microsoft_mpi PUBLIC ${MICROSOFT_MPI_LIBRARY})
endif()
else()
target_link_libraries(ngcore PUBLIC ${MPI_C_LIBRARIES})
target_include_directories(ngcore PUBLIC ${MPI_C_INCLUDE_PATH})
endif(USE_MPI_WRAPPER)
endif(USE_MPI)
================================================
FILE: libsrc/core/_get_glibcxx_use_cxx11_abi.cpp
================================================
#include <iostream>
int main() {
#ifdef _GLIBCXX_USE_CXX11_ABI
if(_GLIBCXX_USE_CXX11_ABI)
std::cout << 1;
else
std::cout << 0;
#else // _GLIBCXX_USE_CXX11_ABI
std::cout << 0;
#endif // _GLIBCXX_USE_CXX11_ABI
return 0;
}
================================================
FILE: libsrc/core/_get_gxx_abi.cpp
================================================
#include <iostream>
int main() {
if (__GXX_ABI_VERSION >= 2000 || __GXX_ABI_VERSION < 1000) return 1;
std::cout << (__GXX_ABI_VERSION % 100);
return 0;
}
================================================
FILE: libsrc/core/archive.cpp
================================================
#include "archive.hpp"
#include "register_archive.hpp"
#include "version.hpp"
#ifndef WIN32
#include <cxxabi.h>
#endif
namespace ngcore
{
std::map<std::string, detail::ClassArchiveInfo> & GetTypeRegister()
{
static std::map<std::string, detail::ClassArchiveInfo> type_register;
return type_register;
}
const detail::ClassArchiveInfo& Archive :: GetArchiveRegister(const std::string& classname)
{
// if(type_register == nullptr) type_register =
// std::make_unique<std::map<std::string, detail::ClassArchiveInfo>>();
return GetTypeRegister()[classname];
}
void Archive :: SetArchiveRegister(const std::string& classname, const detail::ClassArchiveInfo& info)
{
// if(type_register == nullptr) type_register =
// std::make_unique<std::map<std::string, detail::ClassArchiveInfo>>();
GetTypeRegister()[classname] = info;
}
bool Archive :: IsRegistered(const std::string& classname)
{
// if(type_register == nullptr) type_register =
// std::make_unique<std::map<std::string, detail::ClassArchiveInfo>>();
return GetTypeRegister().count(classname) != 0;
}
#ifdef NETGEN_PYTHON
pybind11::object CastAnyToPy(const std::any& a)
{
auto info = Archive::GetArchiveRegister(Demangle(a.type().name()));
return info.anyToPyCaster(a);
}
std::any CastPyToAny(pybind11::object& obj)
{
auto name = Demangle(pybind11::detail::get_type_info((PyTypeObject*) pybind11::type::of(obj).ptr())->cpptype->name());
auto info = Archive::GetArchiveRegister(name);
if(!info.pyToAnyCaster)
throw Exception("Need to register class " + name + " for Archive using std::any");
return info.pyToAnyCaster(obj);
}
#endif // NETGEN_PYTHON
} // namespace ngcore
================================================
FILE: libsrc/core/archive.hpp
================================================
#ifndef NETGEN_CORE_ARCHIVE_HPP
#define NETGEN_CORE_ARCHIVE_HPP
#include <algorithm>
#include <any>
#include <array> // for array
#include <complex> // for complex
#include <cstring> // for size_t, strlen
#include <filesystem> // for path
#include <fstream> // for ifstream, ofstream
#include <functional> // for function
#include <map> // for map
#include <memory> // for shared_ptr
#include <optional> // for optional
#include <string> // for string
#include <type_traits> // for declval, enable_if_t, false_type, is_co...
#include <cstddef> // for std::byte
#include <set> // for set
#include <typeinfo> // for type_info
#include <utility> // for move, swap, pair
#include <vector> // for vector
#include "exception.hpp" // for UnreachableCodeException, Exception
#include "ngcore_api.hpp" // for NGCORE_API
#include "type_traits.hpp" // for all_of_tmpl
#include "utils.hpp" // for Demangle, unlikely
#include "version.hpp" // for VersionInfo
#ifdef NETGEN_PYTHON
namespace pybind11
{
class object;
}
#endif // NETGEN_PYTHON
namespace ngcore
{
template <typename T>
struct Shallow {
T val;
Shallow() = default;
Shallow(T aval) : val(aval) { ; }
operator T&() { return val; }
};
// Helper to detect shared_from_this
template <typename T>
class has_shared_from_this2
{
private:
// typedef T* T_ptr;
template <typename C> static std::true_type test(decltype(((C*)nullptr)->shared_from_this()));
template <typename C> static std::false_type test(...);
public:
// If the test returns true_type, then T has shared_from_this
static constexpr bool value = decltype(test<T>(0))::value;
};
template <typename T, typename = void>
class has_shallow_archive : public std::false_type {};
template <typename T>
class has_shallow_archive<T, std::void_t<decltype(T::shallow_archive)>>
: public std::is_same<decltype(T::shallow_archive), std::true_type> {};
#ifdef NETGEN_PYTHON
NGCORE_API pybind11::object CastAnyToPy(const std::any& a);
NGCORE_API std::any CastPyToAny(pybind11::object& h);
#endif // NETGEN_PYTHON
class NGCORE_API Archive;
namespace detail
{
template <class T, class Tuple, size_t... Is>
T* construct_from_tuple(Tuple&& tuple, std::index_sequence<Is...> ) {
// return new T{std::get<Is>(std::forward<Tuple>(tuple))...};
return new T{std::get<Is>(std::move(tuple))...};
}
template <class T, class Tuple>
T* construct_from_tuple(Tuple&& tuple) {
return construct_from_tuple<T>(std::forward<Tuple>(tuple),
std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>::value>{}
);
}
// create new pointer of type T if it is default constructible, else throw
template<typename T, typename... TArgs>
T* constructIfPossible(std::tuple<TArgs...> args)
{
if constexpr(std::is_constructible_v<T, TArgs...>)
return construct_from_tuple<T>(args);
throw Exception(std::string(Demangle(typeid(T).name())) +
" is not constructible!");
}
template <typename T> T *constructIfPossible()
{
if constexpr(std::is_constructible_v<T>)
return new T();
throw Exception(std::string(Demangle(typeid(T).name())) +
" is not default constructible!");
}
//Type trait to check if a class implements a 'void DoArchive(Archive&)' function
template<typename T>
struct has_DoArchive
{
private:
template<typename T2>
static constexpr auto check(T2*) ->
typename std::is_same<decltype(std::declval<T2>().DoArchive(std::declval<Archive&>())),void>::type;
template<typename>
static constexpr std::false_type check(...);
using type = decltype(check<T>(nullptr)); // NOLINT
public:
NGCORE_API static constexpr bool value = type::value;
};
// Check if class is archivable
template<typename T>
struct is_Archivable_struct
{
private:
template<typename T2>
static constexpr auto check(T2*) ->
typename std::is_same<decltype(std::declval<Archive>() & std::declval<T2&>()),Archive&>::type;
template<typename>
static constexpr std::false_type check(...);
using type = decltype(check<T>(nullptr)); // NOLINT
public:
NGCORE_API static constexpr bool value = type::value;
};
template <typename T>
struct has_GetCArgs
{
template <typename C> static std::true_type check( decltype( sizeof(&C::GetCArgs )) ) { return std::true_type(); }
template <typename> static std::false_type check(...) { return std::false_type(); }
typedef decltype( check<T>(sizeof(char)) ) type;
static constexpr type value = type();
};
template<typename T>
constexpr bool has_GetCArgs_v = has_GetCArgs<T>::value;
template<typename T,
typename std::enable_if<!has_GetCArgs_v<T>>::type* = nullptr>
std::tuple<> Get
gitextract_bskl7z7q/
├── .clang-format
├── .gitignore
├── .gitlab-ci.yml
├── .gitmodules
├── AUTHORS
├── CMakeLists.txt
├── CONTRIBUTING.md
├── ChangeLog
├── INSTALL
├── LICENSE
├── NEWS
├── README.md
├── TODO
├── cmake/
│ ├── NetgenConfig.cmake.in
│ ├── SuperBuild.cmake
│ ├── check_submodules.cmake
│ ├── cmake_modules/
│ │ ├── FindFFMPEG.cmake
│ │ └── FindMETIS.cmake
│ ├── cmake_uninstall.cmake.in
│ ├── external_projects/
│ │ ├── catch.cmake
│ │ ├── cgns.cmake
│ │ ├── metis.cmake
│ │ ├── spdlog.cmake
│ │ ├── tcltk.cmake
│ │ └── zlib.cmake
│ ├── generate_version_file.cmake
│ ├── mic.cmake
│ └── netgen_fixup.cmake
├── depcomp
├── doc/
│ ├── CMakeLists.txt
│ ├── element_types.tex
│ └── ng4.tex
├── external_dependencies/
│ └── .gitignore
├── libsrc/
│ ├── CMakeLists.txt
│ ├── core/
│ │ ├── .clang-tidy
│ │ ├── CMakeLists.txt
│ │ ├── _get_glibcxx_use_cxx11_abi.cpp
│ │ ├── _get_gxx_abi.cpp
│ │ ├── archive.cpp
│ │ ├── archive.hpp
│ │ ├── array.hpp
│ │ ├── autodiff.hpp
│ │ ├── autodiffdiff.hpp
│ │ ├── bitarray.cpp
│ │ ├── bitarray.hpp
│ │ ├── concurrentqueue.h
│ │ ├── exception.cpp
│ │ ├── exception.hpp
│ │ ├── flags.cpp
│ │ ├── flags.hpp
│ │ ├── generate_mpi_sources.py
│ │ ├── hashtable.hpp
│ │ ├── localheap.cpp
│ │ ├── localheap.hpp
│ │ ├── logging.cpp
│ │ ├── logging.hpp
│ │ ├── memtracer.hpp
│ │ ├── mpi4py_pycapi.h
│ │ ├── mpi_wrapper.hpp
│ │ ├── ng_mpi.cpp
│ │ ├── ng_mpi.hpp
│ │ ├── ng_mpi_generated_declarations.hpp
│ │ ├── ng_mpi_generated_dummy_init.hpp
│ │ ├── ng_mpi_generated_init.hpp
│ │ ├── ng_mpi_native.hpp
│ │ ├── ng_mpi_wrapper.cpp
│ │ ├── ngcore.hpp
│ │ ├── ngcore_api.hpp
│ │ ├── ngstream.hpp
│ │ ├── paje_trace.cpp
│ │ ├── paje_trace.hpp
│ │ ├── profiler.cpp
│ │ ├── profiler.hpp
│ │ ├── python_ngcore.cpp
│ │ ├── python_ngcore.hpp
│ │ ├── python_ngcore_export.cpp
│ │ ├── ranges.hpp
│ │ ├── register_archive.hpp
│ │ ├── signal.hpp
│ │ ├── simd.hpp
│ │ ├── simd_arm64.hpp
│ │ ├── simd_avx.hpp
│ │ ├── simd_avx512.hpp
│ │ ├── simd_generic.hpp
│ │ ├── simd_math.hpp
│ │ ├── simd_sse.hpp
│ │ ├── statushandler.cpp
│ │ ├── statushandler.hpp
│ │ ├── symboltable.hpp
│ │ ├── table.cpp
│ │ ├── table.hpp
│ │ ├── taskmanager.cpp
│ │ ├── taskmanager.hpp
│ │ ├── type_traits.hpp
│ │ ├── utils.cpp
│ │ ├── utils.hpp
│ │ ├── version.cpp
│ │ ├── version.hpp
│ │ └── xbool.hpp
│ ├── csg/
│ │ ├── CMakeLists.txt
│ │ ├── algprim.cpp
│ │ ├── algprim.hpp
│ │ ├── brick.cpp
│ │ ├── brick.hpp
│ │ ├── bspline2d.cpp
│ │ ├── csg.hpp
│ │ ├── csgeom.cpp
│ │ ├── csgeom.hpp
│ │ ├── csgparser.cpp
│ │ ├── csgparser.hpp
│ │ ├── csgpkg.cpp
│ │ ├── curve2d.cpp
│ │ ├── curve2d.hpp
│ │ ├── edgeflw.cpp
│ │ ├── edgeflw.hpp
│ │ ├── explicitcurve2d.cpp
│ │ ├── explicitcurve2d.hpp
│ │ ├── extrusion.cpp
│ │ ├── extrusion.hpp
│ │ ├── gencyl.cpp
│ │ ├── gencyl.hpp
│ │ ├── genmesh.cpp
│ │ ├── geoml.hpp
│ │ ├── identify.cpp
│ │ ├── identify.hpp
│ │ ├── manifold.cpp
│ │ ├── manifold.hpp
│ │ ├── meshsurf.cpp
│ │ ├── meshsurf.hpp
│ │ ├── polyhedra.cpp
│ │ ├── polyhedra.hpp
│ │ ├── python_csg.cpp
│ │ ├── revolution.cpp
│ │ ├── revolution.hpp
│ │ ├── singularref.cpp
│ │ ├── singularref.hpp
│ │ ├── solid.cpp
│ │ ├── solid.hpp
│ │ ├── specpoin.cpp
│ │ ├── specpoin.hpp
│ │ ├── spline3d.cpp
│ │ ├── spline3d.hpp
│ │ ├── splinesurface.cpp
│ │ ├── splinesurface.hpp
│ │ ├── surface.cpp
│ │ ├── surface.hpp
│ │ ├── triapprox.cpp
│ │ ├── triapprox.hpp
│ │ ├── vscsg.cpp
│ │ ├── vscsg.hpp
│ │ └── zrefine.cpp
│ ├── general/
│ │ ├── CMakeLists.txt
│ │ ├── autodiff.hpp
│ │ ├── autoptr.hpp
│ │ ├── dynamicmem.cpp
│ │ ├── dynamicmem.hpp
│ │ ├── gzstream.cpp
│ │ ├── gzstream.h
│ │ ├── hashtabl.cpp
│ │ ├── hashtabl.hpp
│ │ ├── myadt.hpp
│ │ ├── mystring.cpp
│ │ ├── mystring.hpp
│ │ ├── netgenout.hpp
│ │ ├── ngarray.hpp
│ │ ├── ngbitarray.cpp
│ │ ├── ngbitarray.hpp
│ │ ├── ngpython.hpp
│ │ ├── optmem.cpp
│ │ ├── optmem.hpp
│ │ ├── parthreads.cpp
│ │ ├── parthreads.hpp
│ │ ├── seti.cpp
│ │ ├── seti.hpp
│ │ ├── sort.cpp
│ │ ├── sort.hpp
│ │ ├── spbita2d.cpp
│ │ ├── spbita2d.hpp
│ │ ├── stack.hpp
│ │ ├── table.cpp
│ │ ├── table.hpp
│ │ └── template.hpp
│ ├── geom2d/
│ │ ├── CMakeLists.txt
│ │ ├── csg2d.cpp
│ │ ├── csg2d.hpp
│ │ ├── genmesh2d.cpp
│ │ ├── geom2dpkg.cpp
│ │ ├── geometry2d.cpp
│ │ ├── geometry2d.hpp
│ │ ├── python_geom2d.cpp
│ │ ├── spline2d.hpp
│ │ ├── vsgeom2d.cpp
│ │ └── vsgeom2d.hpp
│ ├── gprim/
│ │ ├── CMakeLists.txt
│ │ ├── adtree.cpp
│ │ ├── adtree.hpp
│ │ ├── geom2d.cpp
│ │ ├── geom2d.hpp
│ │ ├── geom3d.cpp
│ │ ├── geom3d.hpp
│ │ ├── geomfuncs.cpp
│ │ ├── geomfuncs.hpp
│ │ ├── geomobjects.hpp
│ │ ├── geomops.hpp
│ │ ├── geomtest3d.cpp
│ │ ├── geomtest3d.hpp
│ │ ├── gprim.hpp
│ │ ├── spline.cpp
│ │ ├── spline.hpp
│ │ ├── splinegeometry.cpp
│ │ ├── splinegeometry.hpp
│ │ ├── transform3d.cpp
│ │ └── transform3d.hpp
│ ├── include/
│ │ ├── CMakeLists.txt
│ │ ├── acisgeom.hpp
│ │ ├── csg.hpp
│ │ ├── geometry2d.hpp
│ │ ├── gprim.hpp
│ │ ├── incopengl.hpp
│ │ ├── inctcl.hpp
│ │ ├── incvis.hpp
│ │ ├── linalg.hpp
│ │ ├── meshing.hpp
│ │ ├── myadt.hpp
│ │ ├── mydefs.hpp
│ │ ├── mystdlib.h
│ │ ├── nginterface.h
│ │ ├── nginterface_v2.hpp
│ │ ├── nginterface_v2_impl.hpp
│ │ ├── ngsimd.hpp
│ │ ├── occgeom.hpp
│ │ ├── opti.hpp
│ │ ├── parallel.hpp
│ │ ├── stlgeom.hpp
│ │ └── visual.hpp
│ ├── interface/
│ │ ├── CMakeLists.txt
│ │ ├── nginterface.cpp
│ │ ├── nginterface_v2.cpp
│ │ ├── read_fnf_mesh.cpp
│ │ ├── readtetmesh.cpp
│ │ ├── readuser.cpp
│ │ ├── rw_cgns.cpp
│ │ ├── rw_medit.cpp
│ │ ├── rw_medit.hpp
│ │ ├── writeOpenFOAM15x.cpp
│ │ ├── writeabaqus.cpp
│ │ ├── writediffpack.cpp
│ │ ├── writedolfin.cpp
│ │ ├── writeelmer.cpp
│ │ ├── writefeap.cpp
│ │ ├── writefluent.cpp
│ │ ├── writegmsh.cpp
│ │ ├── writegmsh2.cpp
│ │ ├── writejcm.cpp
│ │ ├── writepermas.cpp
│ │ ├── writetecplot.cpp
│ │ ├── writetet.cpp
│ │ ├── writetochnog.cpp
│ │ ├── writeuser.cpp
│ │ ├── writeuser.hpp
│ │ └── wuchemnitz.cpp
│ ├── linalg/
│ │ ├── CMakeLists.txt
│ │ ├── bfgs.cpp
│ │ ├── densemat.cpp
│ │ ├── densemat.hpp
│ │ ├── linalg.hpp
│ │ ├── linopt.cpp
│ │ ├── linsearch.cpp
│ │ ├── opti.hpp
│ │ ├── polynomial.cpp
│ │ ├── polynomial.hpp
│ │ └── vector.hpp
│ ├── meshing/
│ │ ├── CMakeLists.txt
│ │ ├── adfront2.cpp
│ │ ├── adfront2.hpp
│ │ ├── adfront3.cpp
│ │ ├── adfront3.hpp
│ │ ├── basegeom.cpp
│ │ ├── basegeom.hpp
│ │ ├── bcfunctions.cpp
│ │ ├── bcfunctions.hpp
│ │ ├── bisect.cpp
│ │ ├── bisect.hpp
│ │ ├── boundarylayer.cpp
│ │ ├── boundarylayer.hpp
│ │ ├── boundarylayer2d.cpp
│ │ ├── boundarylayer_interpolate.cpp
│ │ ├── boundarylayer_limiter.hpp
│ │ ├── classifyhpel.hpp
│ │ ├── clusters.cpp
│ │ ├── clusters.hpp
│ │ ├── curvedelems.cpp
│ │ ├── curvedelems.hpp
│ │ ├── debugging.cpp
│ │ ├── debugging.hpp
│ │ ├── delaunay.cpp
│ │ ├── delaunay2d.cpp
│ │ ├── delaunay2d.hpp
│ │ ├── fieldlines.cpp
│ │ ├── fieldlines.hpp
│ │ ├── findip.hpp
│ │ ├── findip2.hpp
│ │ ├── geomsearch.cpp
│ │ ├── geomsearch.hpp
│ │ ├── global.cpp
│ │ ├── global.hpp
│ │ ├── hpref_hex.hpp
│ │ ├── hpref_prism.hpp
│ │ ├── hpref_pyramid.hpp
│ │ ├── hpref_quad.hpp
│ │ ├── hpref_segm.hpp
│ │ ├── hpref_tet.hpp
│ │ ├── hpref_trig.hpp
│ │ ├── hprefinement.cpp
│ │ ├── hprefinement.hpp
│ │ ├── improve2.cpp
│ │ ├── improve2.hpp
│ │ ├── improve2gen.cpp
│ │ ├── improve3.cpp
│ │ ├── improve3.hpp
│ │ ├── localh.cpp
│ │ ├── localh.hpp
│ │ ├── meshclass.cpp
│ │ ├── meshclass.hpp
│ │ ├── meshfunc.cpp
│ │ ├── meshfunc.hpp
│ │ ├── meshfunc2d.cpp
│ │ ├── meshing.hpp
│ │ ├── meshing2.cpp
│ │ ├── meshing2.hpp
│ │ ├── meshing3.cpp
│ │ ├── meshing3.hpp
│ │ ├── meshtool.cpp
│ │ ├── meshtool.hpp
│ │ ├── meshtype.cpp
│ │ ├── meshtype.hpp
│ │ ├── msghandler.cpp
│ │ ├── msghandler.hpp
│ │ ├── netrule2.cpp
│ │ ├── netrule3.cpp
│ │ ├── parallelmesh.cpp
│ │ ├── paralleltop.cpp
│ │ ├── paralleltop.hpp
│ │ ├── parser2.cpp
│ │ ├── parser3.cpp
│ │ ├── python_mesh.cpp
│ │ ├── python_mesh.hpp
│ │ ├── refine.cpp
│ │ ├── ruler2.cpp
│ │ ├── ruler2.hpp
│ │ ├── ruler3.cpp
│ │ ├── ruler3.hpp
│ │ ├── secondorder.cpp
│ │ ├── smoothing2.5.cpp
│ │ ├── smoothing2.cpp
│ │ ├── smoothing3.cpp
│ │ ├── soldata.hpp
│ │ ├── specials.cpp
│ │ ├── specials.hpp
│ │ ├── surfacegeom.cpp
│ │ ├── surfacegeom.hpp
│ │ ├── topology.cpp
│ │ ├── topology.hpp
│ │ ├── validate.cpp
│ │ ├── validate.hpp
│ │ ├── visual_interface.cpp
│ │ └── visual_interface.hpp
│ ├── occ/
│ │ ├── CMakeLists.txt
│ │ ├── Partition_Inter2d.cxx
│ │ ├── Partition_Inter2d.hxx
│ │ ├── Partition_Inter2d.ixx
│ │ ├── Partition_Inter2d.jxx
│ │ ├── Partition_Inter3d.cxx
│ │ ├── Partition_Inter3d.hxx
│ │ ├── Partition_Inter3d.ixx
│ │ ├── Partition_Inter3d.jxx
│ │ ├── Partition_Loop.cxx
│ │ ├── Partition_Loop.hxx
│ │ ├── Partition_Loop.ixx
│ │ ├── Partition_Loop.jxx
│ │ ├── Partition_Loop2d.cxx
│ │ ├── Partition_Loop2d.hxx
│ │ ├── Partition_Loop2d.ixx
│ │ ├── Partition_Loop2d.jxx
│ │ ├── Partition_Loop3d.cxx
│ │ ├── Partition_Loop3d.hxx
│ │ ├── Partition_Loop3d.ixx
│ │ ├── Partition_Loop3d.jxx
│ │ ├── Partition_Spliter.cxx
│ │ ├── Partition_Spliter.hxx
│ │ ├── Partition_Spliter.ixx
│ │ ├── Partition_Spliter.jxx
│ │ ├── cross_section.cpp
│ │ ├── occ_edge.cpp
│ │ ├── occ_edge.hpp
│ │ ├── occ_face.cpp
│ │ ├── occ_face.hpp
│ │ ├── occ_solid.hpp
│ │ ├── occ_utils.cpp
│ │ ├── occ_utils.hpp
│ │ ├── occ_vertex.cpp
│ │ ├── occ_vertex.hpp
│ │ ├── occconstruction.cpp
│ │ ├── occgenmesh.cpp
│ │ ├── occgeom.cpp
│ │ ├── occgeom.hpp
│ │ ├── occmeshsurf.cpp
│ │ ├── occmeshsurf.hpp
│ │ ├── occpkg.cpp
│ │ ├── python_occ.cpp
│ │ ├── python_occ_basic.cpp
│ │ ├── python_occ_shapes.cpp
│ │ ├── utilities.h
│ │ ├── vsocc.cpp
│ │ └── vsocc.hpp
│ ├── stlgeom/
│ │ ├── CMakeLists.txt
│ │ ├── meshstlsurface.cpp
│ │ ├── meshstlsurface.hpp
│ │ ├── python_stl.cpp
│ │ ├── stlgeom.cpp
│ │ ├── stlgeom.hpp
│ │ ├── stlgeomchart.cpp
│ │ ├── stlgeommesh.cpp
│ │ ├── stlline.cpp
│ │ ├── stlline.hpp
│ │ ├── stlpkg.cpp
│ │ ├── stltool.cpp
│ │ ├── stltool.hpp
│ │ ├── stltopology.cpp
│ │ ├── stltopology.hpp
│ │ ├── vsstl.cpp
│ │ └── vsstl.hpp
│ └── visualization/
│ ├── CMakeLists.txt
│ ├── importsolution.cpp
│ ├── meshdoc.cpp
│ ├── meshdoc.hpp
│ ├── mvdraw.cpp
│ ├── mvdraw.hpp
│ ├── vispar.hpp
│ ├── visual.hpp
│ ├── visual_api.hpp
│ ├── visualpkg.cpp
│ ├── vsfieldlines.cpp
│ ├── vsmesh.cpp
│ ├── vssolution.cpp
│ └── vssolution.hpp
├── mkinstalldirs
├── netgen.icns
├── ng/
│ ├── CMakeLists.txt
│ ├── Togl2.1/
│ │ ├── CMakeLists.txt
│ │ ├── LICENSE
│ │ ├── Makefile.in
│ │ ├── README.stubs
│ │ ├── Togl.py
│ │ ├── Xmu/
│ │ │ ├── CmapAlloc.c
│ │ │ ├── CrCmap.c
│ │ │ ├── DelCmap.c
│ │ │ ├── LookupCmap.c
│ │ │ ├── README.togl
│ │ │ ├── StdCmap.c
│ │ │ └── StdCmap.h
│ │ ├── aclocal.m4
│ │ ├── ben.rgb
│ │ ├── configure
│ │ ├── configure.in
│ │ ├── doc/
│ │ │ ├── README.txt
│ │ │ ├── capi.html
│ │ │ ├── download.html
│ │ │ ├── faq.html
│ │ │ ├── header.js
│ │ │ ├── index.html
│ │ │ ├── stereo.html
│ │ │ ├── tclapi.html
│ │ │ ├── upgrading.html
│ │ │ └── using.html
│ │ ├── double.c
│ │ ├── double.tcl
│ │ ├── gears.c
│ │ ├── gears.tcl
│ │ ├── gl/
│ │ │ ├── glext.h
│ │ │ ├── glxext.h
│ │ │ └── wglext.h
│ │ ├── image.c
│ │ ├── image.h
│ │ ├── index.c
│ │ ├── index.tcl
│ │ ├── multisample.tcl
│ │ ├── overlay.c
│ │ ├── overlay.tcl
│ │ ├── pbuffer.c
│ │ ├── pbuffer.tcl
│ │ ├── pkgIndex.tcl.in
│ │ ├── stereo.c
│ │ ├── stereo.tcl
│ │ ├── tclconfig/
│ │ │ ├── install-sh
│ │ │ └── tcl.m4
│ │ ├── texture.c
│ │ ├── texture.tcl
│ │ ├── togl.c
│ │ ├── togl.decls
│ │ ├── togl.h
│ │ ├── toglAGL.c
│ │ ├── toglDecls.h
│ │ ├── toglFont.c
│ │ ├── toglGLX.c
│ │ ├── toglNSOpenGL.c
│ │ ├── toglProcAddr.c
│ │ ├── toglStubInit.c
│ │ ├── toglStubLib.c
│ │ ├── toglWGL.c
│ │ ├── togl_ws.h.in
│ │ ├── toglpy.h
│ │ └── tree2.rgba
│ ├── acisgeom.tcl
│ ├── csgeom.tcl
│ ├── demoview.cpp
│ ├── demoview.hpp
│ ├── dialog.tcl
│ ├── drawing.tcl
│ ├── drawing_togl17.tcl
│ ├── encoding.hpp
│ ├── fonts.hpp
│ ├── gui.cpp
│ ├── menustat.tcl
│ ├── netgen.ocf
│ ├── netgenpy.cpp
│ ├── ng.tcl
│ ├── ng_acis.hpp
│ ├── ngappinit.cpp
│ ├── ngguipy.cpp
│ ├── nghelp.tcl
│ ├── ngicon.tcl
│ ├── ngpkg.cpp
│ ├── ngshell.tcl
│ ├── ngtcl.cpp
│ ├── ngtesting.tcl
│ ├── ngvisual.tcl
│ ├── occgeom.tcl
│ ├── onetcl.cpp
│ ├── onetcl.py
│ ├── parallelfunc.cpp
│ ├── parallelfunc.hpp
│ ├── parameters.tcl
│ ├── sockets.tcl
│ ├── stlgeom.tcl
│ └── variables.tcl
├── nglib/
│ ├── CMakeLists.txt
│ ├── cube.surf
│ ├── hinge.stl
│ ├── netgen.py
│ ├── ng_occ.cpp
│ ├── ng_stl.cpp
│ ├── ng_vol.cpp
│ ├── nglib.cpp
│ ├── nglib.h
│ ├── nglib_occ.cpp
│ ├── nglib_occ.h
│ └── parallelfunc.cpp
├── py_tutorials/
│ ├── CMakeLists.txt
│ ├── csg2d.py
│ ├── csg_first_example.py
│ ├── cube.geo
│ ├── exportNeutral.py
│ ├── merge.py
│ ├── mesh.py
│ ├── opengl.py
│ ├── opengl_thread.py
│ ├── opengl_window.py
│ ├── python_geometry.py
│ └── shaft.geo
├── python/
│ ├── .gitignore
│ ├── CMakeLists.txt
│ ├── NgOCC.py
│ ├── __init__.py
│ ├── __main__.py
│ ├── config/
│ │ ├── __init__.py
│ │ ├── __main__.py
│ │ └── config_template.py
│ ├── csg.py
│ ├── gengeom.py
│ ├── gengeom_curve.py
│ ├── geom2d.py
│ ├── gui.py
│ ├── init_geom2d.py
│ ├── meshing.py
│ ├── occ.py
│ ├── pyngcore/
│ │ └── __init__.py
│ ├── read_gmsh.py
│ ├── read_meshio.py
│ ├── stl.py
│ ├── version_template.py
│ └── webgui.py
├── rules/
│ ├── CMakeLists.txt
│ ├── hexrules.rls
│ ├── makerlsfile.cpp
│ ├── prismrules2.rls
│ ├── prisms.rls
│ ├── pyramidrules.rls
│ ├── pyramidrules2.rls
│ ├── quadrules.rls
│ ├── tetrules.rls
│ └── triarules.rls
├── setup.py
├── tests/
│ ├── CMakeLists.txt
│ ├── build_debug.sh
│ ├── build_guidelines.sh
│ ├── build_mpi.sh
│ ├── build_ngsolve.sh
│ ├── build_nospdlog.sh
│ ├── build_pip.ps1
│ ├── build_pip.sh
│ ├── build_pip_mac.sh
│ ├── catch/
│ │ ├── CMakeLists.txt
│ │ ├── archive.cpp
│ │ ├── array.cpp
│ │ ├── main.cpp
│ │ ├── ranges.cpp
│ │ ├── symboltable.cpp
│ │ ├── utils.cpp
│ │ └── version.cpp
│ ├── dockerfile
│ ├── dockerfile_mpi
│ ├── pytest/
│ │ ├── CMakeLists.txt
│ │ ├── compare_results.py
│ │ ├── conftest.py
│ │ ├── geofiles/
│ │ │ └── plane.stl
│ │ ├── meshes.py
│ │ ├── test_array.py
│ │ ├── test_bitarray.py
│ │ ├── test_boundarylayer.py
│ │ ├── test_csg.py
│ │ ├── test_csg2d.py
│ │ ├── test_geom2d.py
│ │ ├── test_meshclass.py
│ │ ├── test_mpi4py.py
│ │ ├── test_nonnative_master
│ │ ├── test_occ.py
│ │ ├── test_occ_identifications.py
│ │ ├── test_pickling.py
│ │ ├── test_savemesh.py
│ │ ├── test_splinegeo_tensordomainmeshing.py
│ │ └── test_tutorials.py
│ └── utils.py
├── tutorials/
│ ├── CMakeLists.txt
│ ├── boundarycondition.geo
│ ├── boxcyl.geo
│ ├── circle_on_cube.geo
│ ├── cone.geo
│ ├── cube.geo
│ ├── cubeandring.geo
│ ├── cubeandspheres.geo
│ ├── cubemcyl.geo
│ ├── cubemsphere.geo
│ ├── cylinder.geo
│ ├── cylsphere.geo
│ ├── ellipsoid.geo
│ ├── ellipticcone.geo
│ ├── ellipticcyl.geo
│ ├── extrusion.geo
│ ├── fichera.geo
│ ├── frame.step
│ ├── hinge.stl
│ ├── lense.in2d
│ ├── lshape3d.geo
│ ├── manyholes.geo
│ ├── manyholes2.geo
│ ├── matrix.geo
│ ├── ortho.geo
│ ├── part1.stl
│ ├── period.geo
│ ├── revolution.geo
│ ├── screw.step
│ ├── sculpture.geo
│ ├── shaft.geo
│ ├── shell.geo
│ ├── sphere.geo
│ ├── sphereincube.geo
│ ├── square.in2d
│ ├── squarecircle.in2d
│ ├── squarehole.in2d
│ ├── test.dem
│ ├── torus.geo
│ ├── trafo.geo
│ ├── twobricks.geo
│ ├── twocubes.geo
│ └── twocyl.geo
└── windows/
├── .gitignore
├── CMakeLists.txt
├── netgen.rc.template
└── resource.h
Showing preview only (756K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (7050 symbols across 439 files)
FILE: libsrc/core/_get_glibcxx_use_cxx11_abi.cpp
function main (line 3) | int main() {
FILE: libsrc/core/_get_gxx_abi.cpp
function main (line 3) | int main() {
FILE: libsrc/core/archive.cpp
type ngcore (line 10) | namespace ngcore
function CastAnyToPy (line 38) | pybind11::object CastAnyToPy(const std::any& a)
function CastPyToAny (line 44) | std::any CastPyToAny(pybind11::object& obj)
FILE: libsrc/core/archive.hpp
type pybind11 (line 30) | namespace pybind11
class object (line 32) | class object
type ngcore (line 36) | namespace ngcore
type Shallow (line 39) | struct Shallow {
method Shallow (line 41) | Shallow() = default;
method Shallow (line 42) | Shallow(T aval) : val(aval) { ; }
class has_shared_from_this2 (line 48) | class has_shared_from_this2
class has_shallow_archive (line 64) | class has_shallow_archive : public std::false_type {}
class has_shallow_archive<T, std::void_t<decltype(T::shallow_archive)>> (line 67) | class has_shallow_archive<T, std::void_t<decltype(T::shallow_archive)>>
class NGCORE_API (line 77) | class NGCORE_API
type detail (line 78) | namespace detail
function T (line 81) | T* construct_from_tuple(Tuple&& tuple, std::index_sequence<Is...> ) {
function T (line 87) | T* construct_from_tuple(Tuple&& tuple) {
function T (line 95) | T* constructIfPossible(std::tuple<TArgs...> args)
function T (line 103) | T *constructIfPossible()
type has_DoArchive (line 113) | struct has_DoArchive
type is_Archivable_struct (line 128) | struct is_Archivable_struct
type has_GetCArgs (line 142) | struct has_GetCArgs
method check (line 144) | static std::true_type check( decltype( sizeof(&C::GetCArgs )) ) { ...
method check (line 145) | static std::false_type check(...) { return std::false_type(); }
function GetCArgs (line 154) | std::tuple<> GetCArgs(T&val) { return {}; }
function GetCArgs (line 158) | auto GetCArgs(T&val) {
type ClassArchiveInfo (line 166) | struct ClassArchiveInfo
function TotSize (line 198) | constexpr size_t TotSize ()
function Archive (line 208) | class NGCORE_API Archive
function BinaryOutArchive (line 866) | class NGCORE_API BinaryOutArchive : public Archive
function BinaryInArchive (line 968) | class NGCORE_API BinaryInArchive : public Archive
function TextOutArchive (line 1068) | class NGCORE_API TextOutArchive : public Archive
function TextInArchive (line 1123) | class NGCORE_API TextInArchive : public Archive
function HashArchive (line 1210) | class NGCORE_API HashArchive : public Archive
function Archive (line 1220) | Archive & operator & (std::byte & d) override { return ApplyHash(d); }
function Archive (line 1221) | Archive & operator & (float & f) override { return ApplyHash(f); }
function Archive (line 1222) | Archive & operator & (double & d) override { return ApplyHash(d); }
function Archive (line 1223) | Archive & operator & (int & i) override { return ApplyHash(i); }
function Archive (line 1224) | Archive & operator & (short & i) override { return ApplyHash(i); }
function Archive (line 1225) | Archive & operator & (long & i) override { return ApplyHash(i); }
function Archive (line 1226) | Archive & operator & (size_t & i) override { return ApplyHash(i); }
function Archive (line 1227) | Archive & operator & (unsigned char & i) override { return ApplyHash(i...
function Archive (line 1228) | Archive & operator & (bool & b) override { return ApplyHash(b); }
function Archive (line 1229) | Archive & operator & (std::string & str) override
function Archive (line 1231) | Archive & operator & (char *& str) override
function Archive (line 1236) | Archive & operator& (const T& val) const
function GetHash (line 1239) | size_t GetHash() const { return hash_value; }
FILE: libsrc/core/array.hpp
type ngcore (line 22) | namespace ngcore
class Tuple (line 26) | class Tuple
method Size (line 29) | int Size() const { return 0; }
function ostream (line 48) | ostream & operator<< (ostream & ost, Tuple<ARGS...> /* tup */)
function ostream (line 54) | ostream & operator<< (ostream & ost, Tuple<FIRST, ARGS...> tup)
function MakeTuple (line 62) | Tuple<ARGS...> MakeTuple (ARGS ... args)
class AOWrapperIterator (line 69) | class AOWrapperIterator
function NETGEN_INLINE (line 78) | NETGEN_INLINE AOWrapperIterator& operator++ ()
function NETGEN_INLINE (line 82) | NETGEN_INLINE bool operator != (AOWrapperIterator d2) { return ind != ...
function NETGEN_INLINE (line 83) | NETGEN_INLINE bool operator == (AOWrapperIterator d2) { return ind == ...
class Tuple<HEAD, TAIL...> (line 33) | class Tuple<HEAD, TAIL...> : Tuple<TAIL...>
method Tuple (line 38) | Tuple () { ; }
method Tuple (line 39) | Tuple (HEAD h, TAIL ... t) : Tuple<TAIL...> (t...), head(h) { ; }
method HEAD (line 41) | HEAD Head() const { return head; }
method Tail (line 42) | Tuple<TAIL...> Tail() const { return *this; }
method Size (line 44) | int Size() const { return BASE::Size()+1; }
class BaseArrayObject (line 93) | class BaseArrayObject
method NETGEN_INLINE (line 96) | NETGEN_INLINE BaseArrayObject() { ; }
method NETGEN_INLINE (line 98) | NETGEN_INLINE const T & Spec() const { return static_cast<const T&> (*...
method NETGEN_INLINE (line 99) | NETGEN_INLINE size_t Size() const { return Spec().Size(); }
method NETGEN_INLINE (line 101) | NETGEN_INLINE bool Contains(const T2 & el) const
method NETGEN_INLINE (line 111) | NETGEN_INLINE size_t Pos(const T2 & el) const
method NETGEN_INLINE (line 120) | NETGEN_INLINE size_t PosSure(const T2 & el) const
method begin (line 131) | NETGEN_INLINE auto begin () const { return AOWrapperIterator<BaseArray...
method end (line 132) | NETGEN_INLINE auto end () const { return AOWrapperIterator<BaseArrayOb...
class AOWrapper (line 138) | class AOWrapper : public BaseArrayObject<AOWrapper<T>>
method NETGEN_INLINE (line 142) | NETGEN_INLINE AOWrapper (T aar) : ar(aar) { ; }
method NETGEN_INLINE (line 143) | NETGEN_INLINE operator T () const { return ar; }
method NETGEN_INLINE (line 144) | NETGEN_INLINE size_t Size() const { return ar.Size(); }
method NETGEN_INLINE (line 147) | NETGEN_INLINE AOWrapperIterator<AOWrapper> begin () const { return AOW...
method NETGEN_INLINE (line 148) | NETGEN_INLINE AOWrapperIterator<AOWrapper> end () const { return AOWra...
function NETGEN_INLINE (line 152) | NETGEN_INLINE AOWrapper<const T&> ArrayObject (const T & ar)
function NETGEN_INLINE (line 158) | NETGEN_INLINE AOWrapper<T> ArrayObject (T && ar)
function ArrayObject (line 164) | auto ArrayObject (size_t s, FUNC f)
function Substitute (line 179) | auto Substitute (const BaseArrayObject<T> & ao, FUNC f)
class CArray (line 193) | class CArray
method NETGEN_INLINE (line 201) | NETGEN_INLINE CArray () { data = 0; }
method NETGEN_INLINE (line 204) | NETGEN_INLINE CArray (T * adata)
method NETGEN_INLINE (line 208) | NETGEN_INLINE T & operator[] (size_t i) const
method NETGEN_INLINE (line 213) | NETGEN_INLINE operator T* () const { return data; }
function T (line 218) | constexpr T IndexBASE () { return T(0); }
function T (line 221) | constexpr T IndexBASE (T ind) { return IndexBASE<T>(); }
class IndexFromEnd (line 225) | class IndexFromEnd
method IndexFromEnd (line 229) | constexpr IndexFromEnd (ptrdiff_t ai) : i(ai) { }
method IndexFromEnd (line 230) | IndexFromEnd operator+ (ptrdiff_t inc) const { return i+inc; }
method IndexFromEnd (line 231) | IndexFromEnd operator- (ptrdiff_t dec) const { return i-dec; }
method Value (line 233) | ptrdiff_t Value() const { return i; }
class FlatArray (line 239) | class FlatArray
method FlatArray (line 464) | FlatArray () = default;
method FlatArray (line 468) | FlatArray (const FlatArray & a2) = default;
class ArrayIterator (line 243) | class ArrayIterator
function NETGEN_INLINE (line 252) | NETGEN_INLINE ArrayIterator operator++ ()
function NETGEN_INLINE (line 258) | NETGEN_INLINE bool operator != (ArrayIterator d2) { return ind != d2.ind; }
function NETGEN_INLINE (line 259) | NETGEN_INLINE bool operator == (ArrayIterator d2) { return ind == d2.ind; }
class ArrayRangeIterator (line 265) | class ArrayRangeIterator
method NETGEN_INLINE (line 269) | NETGEN_INLINE ArrayRangeIterator (TSIZE ai) : ind(ai) { ; }
method NETGEN_INLINE (line 272) | NETGEN_INLINE TSIZE operator*() const { return ind; }
method NETGEN_INLINE (line 273) | NETGEN_INLINE TSIZE Index() { return ind; }
method NETGEN_INLINE (line 274) | NETGEN_INLINE operator TSIZE () const { return ind; }
method NETGEN_INLINE (line 275) | NETGEN_INLINE bool operator != (ArrayRangeIterator d2) { return ind !=...
method NETGEN_INLINE (line 276) | NETGEN_INLINE bool operator == (ArrayRangeIterator d2) { return ind ==...
class T_Range (line 281) | class T_Range : public BaseArrayObject <T_Range<T>>
method NETGEN_INLINE (line 285) | NETGEN_INLINE T_Range () { ; }
function NETGEN_INLINE (line 291) | NETGEN_INLINE T First() const { return first; }
function NETGEN_INLINE (line 292) | NETGEN_INLINE T Next() const { return next; }
function NETGEN_INLINE (line 293) | NETGEN_INLINE T & First() { return first; }
function NETGEN_INLINE (line 294) | NETGEN_INLINE T & Next() { return next; }
function Size (line 295) | NETGEN_INLINE auto Size() const { return next-first; }
function NETGEN_INLINE (line 296) | NETGEN_INLINE T operator[] (size_t i) const { return first+i; }
function NETGEN_INLINE (line 297) | NETGEN_INLINE bool Contains (T i) const { return ((i >= first) && (i < n...
function NETGEN_INLINE (line 298) | NETGEN_INLINE T_Range Modify(int inc_beg, int inc_end) const
function NETGEN_INLINE (line 300) | NETGEN_INLINE ArrayRangeIterator<T> begin() const { return first; }
function NETGEN_INLINE (line 301) | NETGEN_INLINE ArrayRangeIterator<T> end() const { return next; }
function NETGEN_INLINE (line 303) | NETGEN_INLINE T_Range Split (size_t nr, int tot) const
function NETGEN_INLINE (line 315) | NETGEN_INLINE T_Range<T> Range (T a, T b)
function Range (line 321) | NETGEN_INLINE auto Range (const T& ao)
function Range (line 326) | NETGEN_INLINE auto Range (FlatArray<T> fa)
function NETGEN_INLINE (line 332) | NETGEN_INLINE T_Range<T> Range_impl (T n, std::true_type)
function Range_impl (line 338) | NETGEN_INLINE auto Range_impl (const TA & ao, std::false_type)
function Range (line 356) | NETGEN_INLINE auto Range(const T & x)
function NETGEN_INLINE (line 363) | NETGEN_INLINE IntRange operator+ (const IntRange & range, int shift)
function NETGEN_INLINE (line 368) | NETGEN_INLINE IntRange operator+ (int shift, const IntRange & range)
function NETGEN_INLINE (line 373) | NETGEN_INLINE IntRange operator* (int scale, const IntRange & range)
function NETGEN_INLINE (line 378) | NETGEN_INLINE IntRange operator* (const IntRange & range, int scale)
function ostream (line 384) | inline ostream & operator<< (ostream & s, T_Range<TI> ir)
function ostream (line 391) | ostream & operator<< (ostream & ost, Tuple<IntRange, ARGS...> tup)
function ostream (line 399) | inline ostream & operator<< (ostream & ost, const BaseArrayObject<T> & a...
function Size (line 408) | class IndirectArray : public BaseArrayObject<IndirectArray<T, TI, INDEX_...
function NETGEN_INLINE (line 419) | NETGEN_INLINE T & operator[] (size_t i) const { return ba[ia[i]]; }
function NETGEN_INLINE (line 422) | NETGEN_INLINE IndirectArray operator= (const T & val)
function NETGEN_INLINE (line 430) | NETGEN_INLINE IndirectArray operator= (const BaseArrayObject<T2> & a2)
function NETGEN_INLINE (line 437) | NETGEN_INLINE AOWrapperIterator<IndirectArray> begin() const { return { ...
function NETGEN_INLINE (line 438) | NETGEN_INLINE AOWrapperIterator<IndirectArray> end() const { return { *t...
class FlatArray (line 450) | class FlatArray : public BaseArrayObject<FlatArray<T,IndexType> >
method FlatArray (line 464) | FlatArray () = default;
method FlatArray (line 468) | FlatArray (const FlatArray & a2) = default;
function NETGEN_INLINE (line 489) | NETGEN_INLINE size_t Size() const { return size; }
function NETGEN_INLINE (line 492) | NETGEN_INLINE T* Data() const { return data; }
function NETGEN_INLINE (line 495) | NETGEN_INLINE const FlatArray & operator= (const T & val) const
function NETGEN_INLINE (line 505) | NETGEN_INLINE const FlatArray & operator= (const FlatArray & a2) const
function NETGEN_INLINE (line 514) | NETGEN_INLINE const FlatArray & operator= (const BaseArrayObject<T2> & a...
function NETGEN_INLINE (line 524) | NETGEN_INLINE const FlatArray & operator= (const T2 & func) const
function NETGEN_INLINE (line 537) | NETGEN_INLINE const FlatArray & Assign (const FlatArray & a2)
function NETGEN_INLINE (line 545) | NETGEN_INLINE const FlatArray & Assign (size_t asize, LocalHeap & lh)
function NETGEN_INLINE (line 553) | NETGEN_INLINE T & operator[] (IndexType i) const
function NETGEN_INLINE (line 559) | NETGEN_INLINE T_Range<index_type> Range () const
function NETGEN_INLINE (line 564) | NETGEN_INLINE const CArray<T> Addr (size_t pos) const
function NETGEN_INLINE (line 571) | NETGEN_INLINE T * operator+ (size_t pos) const { return data+pos; }
function T (line 574) | T & First () const
function T (line 581) | T & Last () const
function NETGEN_INLINE (line 588) | NETGEN_INLINE const FlatArray<T> Part (size_t pos)
function NETGEN_INLINE (line 594) | NETGEN_INLINE const FlatArray<T> Part (size_t pos, size_t subsize)
function NETGEN_INLINE (line 600) | NETGEN_INLINE FlatArray<T> Range (size_t start, size_t end) const
function NETGEN_INLINE (line 606) | NETGEN_INLINE FlatArray<T> Range (size_t start, IndexFromEnd indend) const
function NETGEN_INLINE (line 612) | NETGEN_INLINE FlatArray<T> Range (T_Range<size_t> range) const
function NETGEN_INLINE (line 618) | NETGEN_INLINE const FlatArray<T> operator[] (T_Range<IndexType> range) c...
function NETGEN_INLINE (line 630) | NETGEN_INLINE size_t Pos(const T & el) const
function NETGEN_INLINE (line 639) | NETGEN_INLINE bool Contains(const T & elem) const
function begin (line 646) | NETGEN_INLINE auto begin() const { return data; }
function end (line 647) | NETGEN_INLINE auto end() const { return data+Size(); }
function View (line 651) | FlatArray<T> View (FlatArray<T> fa) { return fa; }
function Max (line 654) | auto Max (FlatArray<T,TI> array, typename std::remove_const<T>::type max...
function Min (line 662) | auto Min (FlatArray<T,TI> array, typename std::remove_const<T>::type min...
function ostream (line 671) | inline ostream & operator<< (ostream & s, const FlatArray<T, TIND> & a)
class Array (line 706) | class Array : public FlatArray<T, IndexType>
method Array (line 723) | Array()
method Array (line 730) | Array(size_t asize)
method NETGEN_INLINE (line 740) | NETGEN_INLINE Array(size_t asize, T* adata, bool ownMemory = false)
method NETGEN_INLINE (line 755) | NETGEN_INLINE Array(size_t asize, ALLOCATOR & lh)
method NETGEN_INLINE (line 762) | NETGEN_INLINE Array (Array && a2)
method Array (line 776) | Array (const Array & a2)
method Array (line 797) | explicit Array (const BaseArrayObject<TA> & a2)
method Array (line 814) | Array (std::initializer_list<T> list)
method Array (line 827) | explicit Array (const Array<T> & a2, const Array<T> & a3)
method NETGEN_INLINE (line 841) | NETGEN_INLINE ~Array()
method DoArchive (line 850) | auto DoArchive(ARCHIVE& archive)
method NETGEN_INLINE (line 865) | NETGEN_INLINE void NothingToDelete ()
method NETGEN_INLINE (line 874) | NETGEN_INLINE void SetSize(size_t nsize)
method NETGEN_INLINE (line 881) | NETGEN_INLINE void SetSize0()
method NETGEN_INLINE (line 887) | NETGEN_INLINE void SetAllocSize (size_t nallocsize)
method NETGEN_INLINE (line 894) | NETGEN_INLINE size_t AllocSize () const
method NETGEN_INLINE (line 901) | NETGEN_INLINE const Array & Assign (size_t asize, LocalHeap & lh)
method NETGEN_INLINE (line 914) | NETGEN_INLINE index_type Append (const T & el)
method NETGEN_INLINE (line 924) | NETGEN_INLINE index_type AppendHaveMem (const T & el)
method NETGEN_INLINE (line 934) | NETGEN_INLINE index_type Append (T && el)
method NETGEN_INLINE (line 943) | NETGEN_INLINE void Append(std::initializer_list<T> lst)
method NETGEN_INLINE (line 952) | NETGEN_INLINE void Insert (size_t pos, const T & el)
method NETGEN_INLINE (line 962) | NETGEN_INLINE Array & operator += (const T & el)
method NETGEN_INLINE (line 970) | NETGEN_INLINE void Append (FlatArray<T> source)
method NETGEN_INLINE (line 984) | NETGEN_INLINE void DeleteElement (IndexType i)
method NETGEN_INLINE (line 993) | NETGEN_INLINE void RemoveElement (IndexType i)
method NETGEN_INLINE (line 1002) | NETGEN_INLINE void RemoveElementIf (FUNC func)
method NETGEN_INLINE (line 1019) | NETGEN_INLINE void DeleteLast ()
method NETGEN_INLINE (line 1026) | NETGEN_INLINE void DeleteAll ()
method NETGEN_INLINE (line 1037) | NETGEN_INLINE Array & operator= (const T & val)
method NETGEN_INLINE (line 1044) | NETGEN_INLINE Array & operator= (const Array & a2)
method NETGEN_INLINE (line 1062) | NETGEN_INLINE Array & operator= (Array && a2)
method NETGEN_INLINE (line 1074) | NETGEN_INLINE Array & operator= (const FlatArray<T> & a2)
method Array (line 1093) | Array & operator= (const BaseArrayObject<T2> & a2)
method Array (line 1108) | Array & operator= (Tuple<ARGS...> tup)
method Array (line 1115) | Array & operator= (std::initializer_list<T> list)
method NETGEN_INLINE (line 1136) | NETGEN_INLINE void Swap (Array & b)
method NETGEN_INLINE (line 1145) | NETGEN_INLINE void StartMemoryTracing () const
method MemoryTracer (line 1151) | const MemoryTracer& GetMemoryTracer() const { return mt; }
function NETGEN_INLINE (line 1162) | NETGEN_INLINE void Array<T, IndexType> :: ReSize (size_t minsize)
class ArrayMem (line 1201) | class ArrayMem : public Array<T>
method ArrayMem (line 1214) | explicit ArrayMem(size_t asize = 0)
method ArrayMem (line 1228) | explicit ArrayMem(const Array<T> & a2)
method ArrayMem (line 1235) | explicit ArrayMem(const ArrayMem & a2)
method ArrayMem (line 1241) | ArrayMem(ArrayMem && a2)
method ArrayMem (line 1262) | ArrayMem (std::initializer_list<T> list)
method ArrayMem (line 1271) | ArrayMem (const BaseArrayObject<T2> & a2)
method ArrayMem (line 1279) | ArrayMem & operator= (const T & val)
method ArrayMem (line 1285) | ArrayMem & operator= (ArrayMem && a2)
method ArrayMem (line 1306) | ArrayMem & operator= (const FlatArray<T> & a2)
method ArrayMem (line 1316) | ArrayMem & operator= (const BaseArrayObject<T2> & a2)
function ArraySize (line 1334) | size_t ArraySize (Tuple<ARGS...> /* tup */)
function ArraySize (line 1338) | size_t ArraySize (Tuple<int,ARGS...> tup)
function ArraySize (line 1342) | size_t ArraySize (Tuple<IntRange,ARGS...> tup)
function StoreToArray (line 1347) | void StoreToArray (FlatArray<T> /* a */, Tuple<ARGS...> /* tup */) { ; }
function StoreToArray (line 1350) | void StoreToArray (FlatArray<T> a, Tuple<int,ARGS...> tup)
function StoreToArray (line 1357) | void StoreToArray (FlatArray<T> a, Tuple<IntRange,ARGS...> tup)
function BubbleSort (line 1430) | inline void BubbleSort (FlatArray<T> data)
function BubbleSort (line 1445) | inline void BubbleSort (FlatArray<T> data, FlatArray<S> index)
function QuickSort (line 1465) | void QuickSort (FlatArray<T> data, TLESS less)
function NETGEN_INLINE (line 1508) | NETGEN_INLINE bool DefaultLess (const T & a, const T & b)
class DefaultLessCl (line 1514) | class DefaultLessCl
function NETGEN_INLINE (line 1526) | NETGEN_INLINE void QuickSort (FlatArray<T> data)
function QuickSortI (line 1534) | void QuickSortI (FlatArray<T> data, FlatArray<int> index, TLESS less)
function NETGEN_INLINE (line 1562) | NETGEN_INLINE void QuickSortI (FlatArray<T> data, FlatArray<int> index)
function NETGEN_INLINE (line 1572) | NETGEN_INLINE T xxxRemoveRef (const T & x)
class SumArray (line 1578) | class SumArray : public BaseArrayObject<SumArray<TA1,TA2>>
method SumArray (line 1583) | SumArray (const TA1 & aa1, const TA2 & aa2) : a1(aa1), a2(aa2) { ; }
method Size (line 1584) | size_t Size() const { return a1.Size()+a2.Size(); }
type HTAHelp (line 1599) | struct HTAHelp { }
class HTArray (line 1603) | class HTArray
method HTArray (line 1608) | constexpr HTArray () = default;
method HTArray (line 1609) | constexpr HTArray (const HTArray &) = default;
method HTArray (line 1611) | constexpr HTArray (const HTArray<S,T2> & a2) : tail(a2.Tail()), head(a...
method HTArray (line 1613) | constexpr HTArray (T v) : tail(v), head(v) { }
method HTArray (line 1617) | constexpr HTArray (const T &v, T2... rest)
method HTArray (line 1621) | constexpr HTArray (HTAHelp h, const T &v, T2... rest)
method HTArray (line 1625) | HTArray & operator= (const HTArray &) = default;
method T (line 1627) | T * Ptr () { return tail.Ptr(); }
method T (line 1628) | T & operator[] (size_t i) { return Ptr()[i]; }
method T (line 1630) | const T * Ptr () const { return tail.Ptr(); }
method T (line 1631) | const T & operator[] (size_t i) const { return Ptr()[i]; }
method T (line 1633) | T & Elem() { return (NR==S-1) ? head : tail.template Elem<NR>(); }
method Tail (line 1635) | auto Tail() const { return tail; }
method Head (line 1636) | auto Head() const { return head; }
class HTArray<1,T> (line 1640) | class HTArray<1,T>
method HTArray (line 1644) | constexpr HTArray () = default;
method HTArray (line 1645) | constexpr HTArray (const HTArray &) = default;
method HTArray (line 1647) | constexpr HTArray (const HTArray<1,T2> & a2) : head(a2.Head()) { ; }
method HTArray (line 1648) | constexpr HTArray (T v) : head(v) { }
method HTArray (line 1650) | constexpr HTArray (HTAHelp h, const T &v, T2... rest)
method HTArray (line 1654) | HTArray & operator= (const HTArray &) = default;
method T (line 1656) | T * Ptr () { return &head; }
method T (line 1657) | T & operator[] (size_t i) { return Ptr()[i]; }
method T (line 1659) | const T * Ptr () const { return &head; }
method T (line 1660) | const T & operator[] (size_t i) const { return Ptr()[i]; }
method T (line 1662) | T & Elem()
method Head (line 1668) | auto Head() const { return head; }
class HTArray<0,T> (line 1672) | class HTArray<0,T>
method HTArray (line 1676) | HTArray () = default;
method HTArray (line 1677) | HTArray (const HTArray &) = default;
method HTArray (line 1679) | HTArray (const HTArray<0,T2> & a2) { ; }
method HTArray (line 1680) | constexpr HTArray (T v) { }
method HTArray (line 1681) | HTArray & operator= (const HTArray &) = default;
method T (line 1697) | T * Ptr () { return (T*)(void*)this; }
method T (line 1698) | T & operator[] (size_t i) { return Ptr()[i]; }
method T (line 1700) | const T * Ptr () const { return (const T*)(const void*)this; }
method T (line 1701) | const T & operator[] (size_t i) const { return Ptr()[i]; }
method T (line 1703) | T & Elem()
function T (line 1711) | const T * operator+ (const HTArray<S,T> & ar, size_t i)
function T (line 1716) | T * operator+ (HTArray<S,T> & ar, size_t i)
class IteratorPair (line 1731) | class IteratorPair
method IteratorPair (line 1736) | IteratorPair (TIA _a, TIB _b) : a(_a), b(_b) { ; }
method IteratorPair (line 1738) | IteratorPair & operator++() { ++a; ++b; return *this; }
class Zip (line 1750) | class Zip
method Zip (line 1755) | Zip(const TA & _a, const TB & _b) : a(_a), b(_b) { ; }
method begin (line 1756) | auto begin() const { return IteratorPair(a.begin(), b.begin()); }
method end (line 1757) | auto end() const { return IteratorPair(a.end(), b.end()); }
function size (line 1761) | inline size_t size (const BaseArrayObject<T> & ao) { return ao.Size(); }
class Enumerate (line 1764) | class Enumerate
method Enumerate (line 1769) | Enumerate(const TA & _a) : r(size(_a)), a(_a) { ; }
method begin (line 1770) | auto begin() const { return IteratorPair(r.begin(), a.begin()); }
method end (line 1771) | auto end() const { return IteratorPair(r.end(), a.end()); }
FILE: libsrc/core/autodiff.hpp
type ngcore (line 10) | namespace ngcore
class AutoDiffRec (line 15) | class AutoDiffRec
method AutoDiffRec (line 646) | AutoDiffRec () = default;
method AutoDiffRec (line 647) | AutoDiffRec (const AutoDiffRec &) = default;
class AutoDiffVec (line 24) | class AutoDiffVec
method AutoDiffVec (line 36) | AutoDiffVec() = default;
method AutoDiffVec (line 40) | AutoDiffVec (const AutoDiffVec & ad2) = default;
method NETGEN_INLINE (line 50) | NETGEN_INLINE AutoDiffVec (SCAL aval) throw()
method NETGEN_INLINE (line 58) | NETGEN_INLINE AutoDiffVec (SCAL aval, int diffindex) throw()
method NETGEN_INLINE (line 66) | NETGEN_INLINE AutoDiffVec (SCAL aval, const SCAL * grad)
method NETGEN_INLINE (line 73) | NETGEN_INLINE AutoDiffVec & operator= (SCAL aval) throw()
method AutoDiffVec (line 81) | AutoDiffVec & operator= (const AutoDiffVec & ad2) = default;
method NETGEN_INLINE (line 84) | NETGEN_INLINE SCAL Value() const throw() { return val; }
method NETGEN_INLINE (line 87) | NETGEN_INLINE SCAL DValue (int i) const throw() { return dval[i]; }
method NETGEN_INLINE (line 90) | NETGEN_INLINE void StoreGradient (SCAL * p) const
method NETGEN_INLINE (line 96) | NETGEN_INLINE void LoadGradient (const SCAL * p)
method NETGEN_INLINE (line 103) | NETGEN_INLINE SCAL & Value() throw() { return val; }
method NETGEN_INLINE (line 106) | NETGEN_INLINE SCAL & DValue (int i) throw() { return dval[i]; }
function ostream (line 114) | inline ostream & operator<< (ostream & ost, const AutoDiffVec<D,SCAL> ...
function NETGEN_INLINE (line 124) | NETGEN_INLINE AutoDiffVec<D,SCAL> operator+ (const AutoDiffVec<D,SCAL>...
function NETGEN_INLINE (line 137) | NETGEN_INLINE AutoDiffVec<D,SCAL> operator- (const AutoDiffVec<D,SCAL>...
function NETGEN_INLINE (line 150) | NETGEN_INLINE AutoDiffVec<D,SCAL> operator+ (SCAL2 x, const AutoDiffVe...
function NETGEN_INLINE (line 162) | NETGEN_INLINE AutoDiffVec<D,SCAL> operator+ (const AutoDiffVec<D,SCAL>...
function NETGEN_INLINE (line 174) | NETGEN_INLINE AutoDiffVec<D,SCAL> operator- (const AutoDiffVec<D,SCAL>...
function NETGEN_INLINE (line 186) | NETGEN_INLINE AutoDiffVec<D,SCAL> operator- (const AutoDiffVec<D,SCAL>...
function NETGEN_INLINE (line 198) | NETGEN_INLINE AutoDiffVec<D,SCAL> operator- (SCAL2 x, const AutoDiffVe...
function NETGEN_INLINE (line 211) | NETGEN_INLINE AutoDiffVec<D,SCAL> operator* (SCAL2 x, const AutoDiffVe...
function NETGEN_INLINE (line 224) | NETGEN_INLINE AutoDiffVec<D,SCAL> operator* (const AutoDiffVec<D,SCAL>...
function NETGEN_INLINE (line 235) | NETGEN_INLINE AutoDiffVec<D,SCAL> operator* (const AutoDiffVec<D,SCAL>...
function NETGEN_INLINE (line 250) | NETGEN_INLINE AutoDiffVec<D,SCAL> sqr (const AutoDiffVec<D,SCAL> & x) ...
function NETGEN_INLINE (line 263) | NETGEN_INLINE AutoDiffVec<D,SCAL> Inv (const AutoDiffVec<D,SCAL> & x)
function NETGEN_INLINE (line 274) | NETGEN_INLINE AutoDiffVec<D,SCAL> operator/ (const AutoDiffVec<D,SCAL>...
function NETGEN_INLINE (line 282) | NETGEN_INLINE AutoDiffVec<D,SCAL> operator/ (const AutoDiffVec<D,SCAL>...
function NETGEN_INLINE (line 290) | NETGEN_INLINE AutoDiffVec<D,SCAL> operator/ (SCAL2 x, const AutoDiffVe...
function NETGEN_INLINE (line 299) | NETGEN_INLINE AutoDiffVec<D,SCAL> & operator+= (AutoDiffVec<D,SCAL> & ...
function NETGEN_INLINE (line 308) | NETGEN_INLINE AutoDiffVec<D,SCAL> & operator+= (AutoDiffVec<D,SCAL> & ...
function NETGEN_INLINE (line 318) | NETGEN_INLINE AutoDiffVec<D,SCAL> & operator-= (AutoDiffVec<D,SCAL> & ...
function NETGEN_INLINE (line 328) | NETGEN_INLINE AutoDiffVec<D,SCAL> & operator-= (AutoDiffVec<D,SCAL> & ...
function NETGEN_INLINE (line 336) | NETGEN_INLINE AutoDiffVec<D,SCAL> & operator*= (AutoDiffVec<D,SCAL> & ...
function NETGEN_INLINE (line 346) | NETGEN_INLINE AutoDiffVec<D,SCAL> & operator*= (AutoDiffVec<D,SCAL> & ...
function NETGEN_INLINE (line 356) | NETGEN_INLINE AutoDiffVec<D,SCAL> & operator/= (AutoDiffVec<D,SCAL> & ...
function NETGEN_INLINE (line 370) | NETGEN_INLINE bool operator== (AutoDiffVec<D,SCAL> x, SCAL val2)
function NETGEN_INLINE (line 377) | NETGEN_INLINE bool operator!= (AutoDiffVec<D,SCAL> x, SCAL val2) throw()
function NETGEN_INLINE (line 384) | NETGEN_INLINE bool operator< (AutoDiffVec<D,SCAL> x, SCAL val2) throw()
function NETGEN_INLINE (line 391) | NETGEN_INLINE bool operator> (AutoDiffVec<D,SCAL> x, SCAL val2) throw()
function NETGEN_INLINE (line 400) | NETGEN_INLINE AutoDiffVec<D,SCAL> fabs (const AutoDiffVec<D,SCAL> & x)
function NETGEN_INLINE (line 415) | NETGEN_INLINE AutoDiffVec<D,SCAL> sqrt (const AutoDiffVec<D,SCAL> & x)
function log (line 426) | AutoDiffVec<D,SCAL> log (AutoDiffVec<D,SCAL> x)
function NETGEN_INLINE (line 437) | NETGEN_INLINE AutoDiffVec<D,SCAL> exp (AutoDiffVec<D,SCAL> x)
function NETGEN_INLINE (line 448) | NETGEN_INLINE AutoDiffVec<D,SCAL> pow (AutoDiffVec<D,SCAL> x, AutoDiff...
function NETGEN_INLINE (line 468) | NETGEN_INLINE AutoDiffVec<D,SCAL> sin (AutoDiffVec<D,SCAL> x)
function NETGEN_INLINE (line 487) | NETGEN_INLINE AutoDiffVec<D,SCAL> cos (AutoDiffVec<D,SCAL> x)
function NETGEN_INLINE (line 494) | NETGEN_INLINE AutoDiffVec<D,SCAL> tan (AutoDiffVec<D,SCAL> x)
function NETGEN_INLINE (line 499) | NETGEN_INLINE AutoDiffVec<D,SCAL> sinh (AutoDiffVec<D,SCAL> x)
function NETGEN_INLINE (line 511) | NETGEN_INLINE AutoDiffVec<D,SCAL> cosh (AutoDiffVec<D,SCAL> x)
function NETGEN_INLINE (line 523) | NETGEN_INLINE AutoDiffVec<D,SCAL> erf (AutoDiffVec<D,SCAL> x)
function NETGEN_INLINE (line 530) | NETGEN_INLINE AutoDiffVec<D,SCAL> floor (const AutoDiffVec<D,SCAL> & x)
function NETGEN_INLINE (line 541) | NETGEN_INLINE AutoDiffVec<D,SCAL> ceil (const AutoDiffVec<D,SCAL> & x)
function atan (line 565) | AutoDiffVec<D,SCAL> atan (AutoDiffVec<D,SCAL> x)
function NETGEN_INLINE (line 572) | NETGEN_INLINE AutoDiffVec<D,SCAL> atan2 (AutoDiffVec<D,SCAL> x, AutoDi...
function NETGEN_INLINE (line 585) | NETGEN_INLINE AutoDiffVec<D,SCAL> acos (AutoDiffVec<D,SCAL> x)
function NETGEN_INLINE (line 599) | NETGEN_INLINE AutoDiffVec<D,SCAL> asin (AutoDiffVec<D,SCAL> x)
function IfPos (line 614) | auto IfPos (AutoDiffVec<D,SCAL> a, TB b, TC c) // -> decltype(IfPos (a...
function NETGEN_INLINE (line 620) | NETGEN_INLINE AutoDiffVec<D,SCAL> IfPos (SCAL /* SIMD<double> */ a, Au...
function NETGEN_INLINE (line 630) | NETGEN_INLINE AutoDiffVec<D,SCAL> IfPos (SCAL /* SIMD<double> */ a, Au...
class AutoDiffRec (line 640) | class AutoDiffRec
method AutoDiffRec (line 646) | AutoDiffRec () = default;
method AutoDiffRec (line 647) | AutoDiffRec (const AutoDiffRec &) = default;
function NETGEN_INLINE (line 653) | NETGEN_INLINE AutoDiffRec (SCAL aval, const SCAL * grad)
function NETGEN_INLINE (line 663) | NETGEN_INLINE AutoDiffRec & operator= (SCAL aval) { rec = aval; last = 0...
function NETGEN_INLINE (line 664) | NETGEN_INLINE SCAL Value() const { return rec.Value(); }
function NETGEN_INLINE (line 665) | NETGEN_INLINE SCAL DValue(int i) const { return (i == D-1) ? last : rec....
function NETGEN_INLINE (line 666) | NETGEN_INLINE SCAL & Value() { return rec.Value(); }
function NETGEN_INLINE (line 667) | NETGEN_INLINE SCAL & DValue(int i) { return (i == D-1) ? last : rec.DVal...
function Rec (line 668) | NETGEN_INLINE auto Rec() const { return rec; }
function Last (line 669) | NETGEN_INLINE auto Last() const { return last; }
function NETGEN_INLINE (line 672) | NETGEN_INLINE operator AutoDiffVec<D,SCAL> () const
function ostream (line 682) | ostream & operator<< (ostream & ost, AutoDiffRec<D,SCAL> ad)
class AutoDiffRec<0,SCAL> (line 688) | class AutoDiffRec<0,SCAL>
method AutoDiffRec (line 692) | AutoDiffRec () = default;
method AutoDiffRec (line 693) | AutoDiffRec (const AutoDiffRec &) = default;
method NETGEN_INLINE (line 694) | NETGEN_INLINE AutoDiffRec (SCAL _val) : val(_val) { ; }
method NETGEN_INLINE (line 695) | NETGEN_INLINE AutoDiffRec (SCAL _val, SCAL /* _dummylast */) : val(_va...
method NETGEN_INLINE (line 696) | NETGEN_INLINE AutoDiffRec (SCAL aval, const SCAL * /* grad */)
method AutoDiffRec (line 699) | AutoDiffRec & operator= (const AutoDiffRec &) = default;
method NETGEN_INLINE (line 700) | NETGEN_INLINE AutoDiffRec & operator= (SCAL aval) { val = aval; return...
method NETGEN_INLINE (line 702) | NETGEN_INLINE SCAL Value() const { return val; }
method NETGEN_INLINE (line 703) | NETGEN_INLINE SCAL DValue(int /* i */) const { return SCAL(0); }
method NETGEN_INLINE (line 704) | NETGEN_INLINE SCAL & Value() { return val; }
method Rec (line 706) | NETGEN_INLINE auto Rec() const { return val; }
method Last (line 707) | NETGEN_INLINE auto Last() const { return SCAL(0); }
method NETGEN_INLINE (line 710) | NETGEN_INLINE operator AutoDiffVec<0,SCAL> () const { return AutoDiffV...
class AutoDiffRec<1,SCAL> (line 715) | class AutoDiffRec<1,SCAL>
method AutoDiffRec (line 720) | AutoDiffRec () = default;
method AutoDiffRec (line 721) | AutoDiffRec (const AutoDiffRec &) = default;
function NETGEN_INLINE (line 725) | NETGEN_INLINE AutoDiffRec (SCAL aval, const SCAL * grad)
function NETGEN_INLINE (line 735) | NETGEN_INLINE AutoDiffRec & operator= (SCAL aval) { val = aval; last = 0...
function NETGEN_INLINE (line 737) | NETGEN_INLINE SCAL Value() const { return val; }
function NETGEN_INLINE (line 738) | NETGEN_INLINE SCAL DValue(int /* i */) const { return last; }
function NETGEN_INLINE (line 739) | NETGEN_INLINE SCAL & Value() { return val; }
function NETGEN_INLINE (line 740) | NETGEN_INLINE SCAL & DValue(int /* i */) { return last; }
function Rec (line 741) | NETGEN_INLINE auto Rec() const { return val; }
function Last (line 742) | NETGEN_INLINE auto Last() const { return last; }
function NETGEN_INLINE (line 746) | NETGEN_INLINE operator AutoDiffVec<1,SCAL> () const
function NETGEN_INLINE (line 756) | NETGEN_INLINE AutoDiffRec<D,SCAL> operator+ (SCAL2 a, AutoDiffRec<D,SCAL...
function NETGEN_INLINE (line 763) | NETGEN_INLINE AutoDiffRec<D,SCAL> operator+ (AutoDiffRec<D,SCAL> a, SCAL...
function NETGEN_INLINE (line 769) | NETGEN_INLINE AutoDiffRec<D,SCAL> operator+ (AutoDiffRec<D,SCAL> a, Auto...
function NETGEN_INLINE (line 776) | NETGEN_INLINE AutoDiffRec<D,SCAL> operator- (SCAL2 b, AutoDiffRec<D,SCAL...
function NETGEN_INLINE (line 783) | NETGEN_INLINE AutoDiffRec<D,SCAL> operator- (AutoDiffRec<D,SCAL> a, SCAL...
function NETGEN_INLINE (line 789) | NETGEN_INLINE AutoDiffRec<D,SCAL> operator- (AutoDiffRec<D,SCAL> a, Auto...
function NETGEN_INLINE (line 796) | NETGEN_INLINE AutoDiffRec<D,SCAL> operator- (AutoDiffRec<D,SCAL> a)
function NETGEN_INLINE (line 802) | NETGEN_INLINE AutoDiffRec<D,SCAL> operator* (AutoDiffRec<D,SCAL> a, Auto...
function NETGEN_INLINE (line 809) | NETGEN_INLINE AutoDiffRec<D,SCAL> operator* (AutoDiffRec<D,SCAL> b, SCAL...
function NETGEN_INLINE (line 816) | NETGEN_INLINE AutoDiffRec<D,SCAL> operator* (SCAL1 a, AutoDiffRec<D,SCAL...
function NETGEN_INLINE (line 822) | NETGEN_INLINE AutoDiffRec<D,SCAL> & operator+= (AutoDiffRec<D,SCAL> & a,...
function NETGEN_INLINE (line 830) | NETGEN_INLINE AutoDiffRec<D,SCAL> & operator-= (AutoDiffRec<D,SCAL> & a,...
function NETGEN_INLINE (line 837) | NETGEN_INLINE AutoDiffRec<D,SCAL> & operator-= (AutoDiffRec<D,SCAL> & a,...
function NETGEN_INLINE (line 846) | NETGEN_INLINE AutoDiffRec<D,SCAL> & operator*= (AutoDiffRec<D,SCAL> & a,...
function NETGEN_INLINE (line 854) | NETGEN_INLINE AutoDiffRec<D,SCAL> & operator*= (AutoDiffRec<D,SCAL> & b,...
function Inv1 (line 864) | auto Inv1 (SCAL x) { return 1.0/x; }
function NETGEN_INLINE (line 867) | NETGEN_INLINE AutoDiffRec<D,SCAL> Inv1 (AutoDiffRec<D,SCAL> x)
function NETGEN_INLINE (line 874) | NETGEN_INLINE AutoDiffRec<D,SCAL> operator/ (const AutoDiffRec<D,SCAL> &...
function NETGEN_INLINE (line 883) | NETGEN_INLINE AutoDiffRec<D,SCAL> operator/ (const AutoDiffRec<D,SCAL> &...
function NETGEN_INLINE (line 892) | NETGEN_INLINE AutoDiffRec<D,SCAL> operator/ (SCAL2 x, const AutoDiffRec<...
function NETGEN_INLINE (line 905) | NETGEN_INLINE bool operator== (AutoDiffRec<D,SCAL> x, SCAL val2)
function NETGEN_INLINE (line 912) | NETGEN_INLINE bool operator!= (AutoDiffRec<D,SCAL> x, SCAL val2) throw()
function NETGEN_INLINE (line 919) | NETGEN_INLINE bool operator< (AutoDiffRec<D,SCAL> x, SCAL val2) throw()
function NETGEN_INLINE (line 926) | NETGEN_INLINE bool operator> (AutoDiffRec<D,SCAL> x, SCAL val2) throw()
function NETGEN_INLINE (line 933) | NETGEN_INLINE AutoDiffRec<D,SCAL> fabs (const AutoDiffRec<D,SCAL> & x)
function sqrt (line 953) | NETGEN_INLINE auto sqrt (const AutoDiffRec<D,SCAL> & x)
function log (line 961) | auto log (AutoDiffRec<D,SCAL> x)
function exp (line 967) | auto exp (AutoDiffRec<D,SCAL> x)
function NETGEN_INLINE (line 973) | NETGEN_INLINE AutoDiffRec<D,SCAL> pow (AutoDiffRec<D,SCAL> x, AutoDiffRe...
function sin (line 980) | auto sin (AutoDiffRec<D,SCAL> x)
function cos (line 986) | auto cos (AutoDiffRec<D,SCAL> x)
function tan (line 992) | auto tan (AutoDiffRec<D,SCAL> x)
function sinh (line 998) | auto sinh (AutoDiffRec<D,SCAL> x)
function cosh (line 1004) | auto cosh (AutoDiffRec<D,SCAL> x)
function asinh (line 1010) | auto asinh (AutoDiffRec<D,SCAL> x)
function acosh (line 1016) | auto acosh (AutoDiffRec<D,SCAL> x)
function erf (line 1023) | auto erf (AutoDiffRec<D,SCAL> x)
function floor (line 1029) | auto floor (AutoDiffRec<D,SCAL> x)
function ceil (line 1035) | auto ceil (AutoDiffRec<D,SCAL> x)
function atan (line 1043) | auto atan (AutoDiffRec<D,SCAL> x)
function atan2 (line 1049) | auto atan2 (AutoDiffRec<D,SCAL> x, AutoDiffRec<D,SCAL> y)
function acos (line 1056) | auto acos (AutoDiffRec<D,SCAL> x)
function asin (line 1062) | auto asin (AutoDiffRec<D,SCAL> x)
function IfPos (line 1069) | auto IfPos (AutoDiffRec<D,SCAL> a, TB b, TC c) // -> decltype(IfPos (a.V...
function NETGEN_INLINE (line 1075) | NETGEN_INLINE AutoDiffRec<D,SCAL> IfPos (SCAL /* SIMD<double> */ a, Auto...
function NETGEN_INLINE (line 1088) | NETGEN_INLINE AutoDiffRec<D,SCAL> IfPos (SCAL /* SIMD<double> */ a, Auto...
type ngbla (line 1102) | namespace ngbla
type is_scalar_type (line 1104) | struct is_scalar_type
type is_scalar_type<ngcore::AutoDiff<D,T>> (line 1106) | struct is_scalar_type<ngcore::AutoDiff<D,T>> { static constexpr bool v...
function L2Norm2 (line 1111) | inline auto L2Norm2 (const ngcore::AutoDiff<D,SCAL> & x)
function L2Norm (line 1117) | inline auto L2Norm (const ngcore::AutoDiff<D,SCAL> & x) throw()
function Conj (line 1125) | NETGEN_INLINE auto Conj (const ngcore::AutoDiff<D,TAD> & a)
FILE: libsrc/core/autodiffdiff.hpp
type ngcore (line 10) | namespace ngcore
class AutoDiffDiff (line 21) | class AutoDiffDiff
method AutoDiffDiff (line 32) | AutoDiffDiff () throw() { ; }
method AutoDiffDiff (line 35) | AutoDiffDiff (const AutoDiffDiff & ad2) throw()
method AutoDiffDiff (line 45) | AutoDiffDiff (SCAL aval) throw()
method AutoDiffDiff (line 55) | AutoDiffDiff (const AutoDiff<D, SCAL> & ad2) throw()
method AutoDiffDiff (line 65) | AutoDiffDiff (SCAL aval, int diffindex) throw()
method NETGEN_INLINE (line 75) | NETGEN_INLINE AutoDiffDiff (SCAL aval, const SCAL * grad)
method NETGEN_INLINE (line 83) | NETGEN_INLINE AutoDiffDiff (SCAL aval, const SCAL * grad, const SCAL...
method AutoDiffDiff (line 91) | AutoDiffDiff & operator= (SCAL aval) throw()
method NETGEN_INLINE (line 101) | NETGEN_INLINE void StoreGradient (SCAL * p) const
method NETGEN_INLINE (line 107) | NETGEN_INLINE void LoadGradient (const SCAL * p)
method NETGEN_INLINE (line 113) | NETGEN_INLINE void StoreHessian (SCAL * p) const
method NETGEN_INLINE (line 119) | NETGEN_INLINE void LoadHessian (const SCAL * p)
method SCAL (line 126) | SCAL Value() const throw() { return val; }
method SCAL (line 129) | SCAL DValue (int i) const throw() { return dval[i]; }
method DValueAD (line 131) | AutoDiff<D,SCAL> DValueAD (int i) const
method SCAL (line 140) | SCAL DDValue (int i) const throw() { return ddval[i]; }
method SCAL (line 143) | SCAL DDValue (int i, int j) const throw() { return ddval[i*D+j]; }
method SCAL (line 146) | SCAL & Value() throw() { return val; }
method SCAL (line 149) | SCAL & DValue (int i) throw() { return dval[i]; }
method SCAL (line 152) | SCAL & DDValue (int i) throw() { return ddval[i]; }
method SCAL (line 155) | SCAL & DDValue (int i, int j) throw() { return ddval[i*D+j]; }
function ostream (line 254) | inline ostream & operator<< (ostream & ost, const AutoDiffDiff<D, SCAL...
function Inv (line 415) | inline AutoDiffDiff<D, SCAL> Inv (const AutoDiffDiff<D, SCAL> & x)
function sqrt (line 452) | inline AutoDiffDiff<D, SCAL> sqrt (const AutoDiffDiff<D, SCAL> & x)
function NETGEN_INLINE (line 470) | NETGEN_INLINE AutoDiffDiff<D, SCAL> exp (AutoDiffDiff<D, SCAL> x)
function NETGEN_INLINE (line 484) | NETGEN_INLINE AutoDiffDiff<D,SCAL> pow (AutoDiffDiff<D,SCAL> x, AutoDi...
function NETGEN_INLINE (line 490) | NETGEN_INLINE AutoDiffDiff<D, SCAL> log (AutoDiffDiff<D, SCAL> x)
function NETGEN_INLINE (line 506) | NETGEN_INLINE AutoDiffDiff<D, SCAL> sin (AutoDiffDiff<D, SCAL> x)
function NETGEN_INLINE (line 523) | NETGEN_INLINE AutoDiffDiff<D, SCAL> cos (AutoDiffDiff<D, SCAL> x)
function NETGEN_INLINE (line 539) | NETGEN_INLINE AutoDiffDiff<D, SCAL> tan (AutoDiffDiff<D, SCAL> x)
function NETGEN_INLINE (line 544) | NETGEN_INLINE AutoDiffDiff<D, SCAL> atan (AutoDiffDiff<D, SCAL> x)
function NETGEN_INLINE (line 558) | NETGEN_INLINE AutoDiffDiff<D, SCAL> atan2 (AutoDiffDiff<D, SCAL> x,Aut...
function NETGEN_INLINE (line 576) | NETGEN_INLINE AutoDiffDiff<D,SCAL> acos (AutoDiffDiff<D,SCAL> x)
function NETGEN_INLINE (line 597) | NETGEN_INLINE AutoDiffDiff<D,SCAL> asin (AutoDiffDiff<D,SCAL> x)
function NETGEN_INLINE (line 617) | NETGEN_INLINE AutoDiffDiff<D, SCAL> sinh (AutoDiffDiff<D, SCAL> x)
function NETGEN_INLINE (line 634) | NETGEN_INLINE AutoDiffDiff<D, SCAL> cosh (AutoDiffDiff<D, SCAL> x)
function NETGEN_INLINE (line 650) | NETGEN_INLINE AutoDiffDiff<D, SCAL> erf (AutoDiffDiff<D, SCAL> x)
function NETGEN_INLINE (line 666) | NETGEN_INLINE AutoDiffDiff<D,SCAL> floor (const AutoDiffDiff<D,SCAL> & x)
function NETGEN_INLINE (line 673) | NETGEN_INLINE AutoDiffDiff<D,SCAL> ceil (const AutoDiffDiff<D,SCAL> & x)
function IfPos (line 680) | auto IfPos (AutoDiffDiff<D,SCAL> a, TB b, TC c) -> decltype(IfPos (a.V...
function NETGEN_INLINE (line 686) | NETGEN_INLINE AutoDiffDiff<D,SCAL> IfPos (SCAL /* SIMD<double> */ a, A...
function NETGEN_INLINE (line 699) | NETGEN_INLINE AutoDiffDiff<D,SCAL> IfPos (SCAL /* SIMD<double> */ a, A...
type ngbla (line 712) | namespace ngbla
type is_scalar_type (line 714) | struct is_scalar_type
type is_scalar_type<ngcore::AutoDiffDiff<D,T>> (line 716) | struct is_scalar_type<ngcore::AutoDiffDiff<D,T>> { static constexpr bo...
function L2Norm2 (line 722) | inline auto L2Norm2 (const ngcore::AutoDiffDiff<D,SCAL> & x)
FILE: libsrc/core/bitarray.cpp
type ngcore (line 14) | namespace ngcore
function BitArray (line 52) | BitArray & BitArray :: Set () throw()
function BitArray (line 60) | BitArray & BitArray :: Clear () throw()
function BitArray (line 68) | BitArray & BitArray :: Invert ()
function BitArray (line 76) | BitArray & BitArray :: And (const BitArray & ba2)
function BitArray (line 85) | BitArray & BitArray :: Or (const BitArray & ba2)
function BitArray (line 106) | BitArray & BitArray :: operator= (const BitArray & ba2)
FILE: libsrc/core/bitarray.hpp
type ngcore (line 19) | namespace ngcore
class BitArray (line 27) | class BitArray
method BitArray (line 39) | BitArray ()
method BitArray (line 47) | BitArray (BitArray && ba2)
function Size (line 80) | size_t Size () const { return size; }
function Set (line 89) | [[deprecated("Use either SetBit() or SetBitAtomic()")]]
function SetBit (line 93) | void SetBit (size_t i)
function SetBitAtomic (line 100) | void SetBitAtomic (size_t i)
function Clear (line 110) | void Clear (size_t i)
function Test (line 117) | bool Test (size_t i) const
function BitArray (line 124) | BitArray & operator= (bool b)
method BitArray (line 39) | BitArray ()
method BitArray (line 47) | BitArray (BitArray && ba2)
class Archive (line 154) | class Archive
function GetMemoryUsage (line 158) | size_t GetMemoryUsage() const { return owns_data ? (size+CHAR_BIT-1)/C...
function MemoryTracer (line 159) | const MemoryTracer& GetMemoryTracer() const { return mt; }
function StartMemoryTracing (line 160) | void StartMemoryTracing() const
function Addr (line 171) | size_t Addr (size_t i) const
function BitArray (line 178) | inline BitArray & operator|= (BitArray & me, const BitArray & you)
function BitArray (line 184) | inline BitArray & operator&= (BitArray & me, const BitArray & you)
function BitArray (line 190) | inline BitArray operator| (const BitArray & a, const BitArray & b)
function BitArray (line 197) | inline BitArray operator& (const BitArray & a, const BitArray & b)
function BitArray (line 204) | inline BitArray operator~ (const BitArray & a)
class TBitArray (line 216) | class TBitArray : public BitArray
method SetBit (line 221) | void SetBit (IndexType i) { BitArray::SetBit(i-IndexBASE<IndexType>()); }
method Clear (line 222) | void Clear () { BitArray::Clear(); }
method Clear (line 223) | void Clear (IndexType i) { BitArray::Clear(i-IndexBASE<IndexType>()); }
method SetBitAtomic (line 224) | void SetBitAtomic (IndexType i) { BitArray::SetBitAtomic(i-IndexBASE<I...
method Test (line 225) | bool Test (IndexType i) const { return BitArray::Test(i-IndexBASE<Inde...
method Range (line 228) | T_Range<IndexType> Range() const { return { IndexBASE<IndexType>(), In...
method NGCORE_API (line 229) | NGCORE_API TBitArray & Or (const TBitArray & ba2)
FILE: libsrc/core/concurrentqueue.h
function namespace (line 58) | namespace moodycamel { namespace details {
function namespace (line 66) | namespace moodycamel { namespace details {
function namespace (line 76) | namespace moodycamel { namespace details {
function namespace (line 84) | namespace moodycamel { namespace details {
function namespace (line 129) | namespace moodycamel { namespace details {
function namespace (line 202) | namespace moodycamel { namespace details {
function namespace (line 216) | namespace moodycamel {
type ConsumerToken (line 616) | struct ConsumerToken
function swap (line 855) | inline void swap(ConcurrentQueue& other) MOODYCAMEL_NOEXCEPT
function enqueue (line 906) | inline bool enqueue(T&& item)
function enqueue (line 916) | inline bool enqueue(producer_token_t const& token, T const& item)
function enqueue (line 925) | inline bool enqueue(producer_token_t const& token, T&& item)
function try_enqueue (line 960) | inline bool try_enqueue(T const& item)
function try_enqueue (line 971) | inline bool try_enqueue(T&& item)
function try_enqueue (line 980) | inline bool try_enqueue(producer_token_t const& token, T const& item)
function try_enqueue (line 988) | inline bool try_enqueue(producer_token_t const& token, T&& item)
function size_approx (line 1225) | size_t size_approx() const
type ExplicitProducer (line 1253) | struct ExplicitProducer
type ImplicitProducer (line 1255) | struct ImplicitProducer
type AllocationMode (line 1259) | enum AllocationMode { CanAlloc, CannotAlloc }
function update_current_producer_after_rotation (line 1292) | inline bool update_current_producer_after_rotation(consumer_token_t& token)
function freeListHead (line 1352) | freeListHead(nullptr) { }
function swap (line 1354) | void swap(FreeList& other) { details::swap_relaxed(freeListHead, other.f...
function add (line 1359) | inline void add(N* node)
function N (line 1373) | inline N* try_get()
function N (line 1413) | N* head_unsafe() const { return freeListHead.load(std::memory_order_rela...
type InnerQueueContext (line 1457) | enum InnerQueueContext { implicit_context = 0, explicit_context = 1 }
function else (line 1459) | struct Block
function T (line 1566) | inline T* operator[](index_t idx) MOODYCAMEL_NOEXCEPT { return static_ca...
function T (line 1567) | inline T const* operator[](index_t idx) const MOODYCAMEL_NOEXCEPT { retu...
type MemStats (line 1603) | struct MemStats
type ProducerBase (line 1611) | struct ProducerBase
function virtual (line 1624) | virtual ~ProducerBase() { }
function ProducerBase (line 1648) | inline ProducerBase* next_prod() const { return static_cast<ProducerBase...
function size_approx (line 1650) | inline size_t size_approx() const
function ProducerBase (line 1682) | struct ExplicitProducer : public ProducerBase
type Guard (line 1939) | struct Guard {
type BlockIndexEntry (line 2248) | struct BlockIndexEntry
type BlockIndexHeader (line 2254) | struct BlockIndexHeader
function new_block_index (line 2263) | bool new_block_index(size_t numberOfFilledSlotsToExpose)
function ProducerBase (line 2328) | struct ImplicitProducer : public ProducerBase
type BlockIndexEntry (line 2784) | struct BlockIndexEntry
type BlockIndexHeader (line 2790) | struct BlockIndexHeader
function rewind_block_index_tail (line 2829) | inline void rewind_block_index_tail()
function BlockIndexEntry (line 2835) | inline BlockIndexEntry* get_block_index_entry_for_index(index_t index) c...
function get_block_index_index_for_index (line 2842) | inline size_t get_block_index_index_for_index(index_t index, BlockIndexH...
function new_block_index (line 2860) | bool new_block_index()
function populate_initial_block_list (line 2933) | void populate_initial_block_list(size_t blockCount)
function Block (line 2950) | inline Block* try_get_block_from_initial_pool()
function add_block_to_free_list (line 2961) | inline void add_block_to_free_list(Block* block)
function add_blocks_to_free_list (line 2969) | inline void add_blocks_to_free_list(Block* block)
function Block (line 2978) | inline Block* try_get_block_from_free_list()
type MemStats (line 3007) | struct MemStats {
function MemStats (line 3102) | MemStats getMemStats()
function ProducerBase (line 3115) | ProducerBase* recycle_or_create_producer(bool isExplicit)
function ProducerBase (line 3121) | ProducerBase* recycle_or_create_producer(bool isExplicit, bool& recycled)
function ProducerBase (line 3142) | ProducerBase* add_producer(ProducerBase* producer)
function reown_producers (line 3175) | void reown_producers()
type ImplicitProducerKVP (line 3190) | struct ImplicitProducerKVP
function swap (line 3209) | inline void swap(ImplicitProducerKVP& other) MOODYCAMEL_NOEXCEPT
type ImplicitProducerHash (line 3221) | struct ImplicitProducerHash
function populate_initial_implicit_producer_hash (line 3228) | inline void populate_initial_implicit_producer_hash()
function swap_implicit_producer_hashes (line 3243) | void swap_implicit_producer_hashes(ConcurrentQueue& other)
function ImplicitProducer (line 3278) | ImplicitProducer* get_or_add_implicit_producer()
function swap (line 3599) | inline void swap(ProducerToken& a, ProducerToken& b) MOODYCAMEL_NOEXCEPT
function swap (line 3604) | inline void swap(ConsumerToken& a, ConsumerToken& b) MOODYCAMEL_NOEXCEPT
FILE: libsrc/core/exception.cpp
type ngcore (line 18) | namespace ngcore
function ThrowRangeException (line 72) | void ThrowRangeException(const char * s, ptrdiff_t ind, ptrdiff_t imin...
function ThrowException (line 77) | void ThrowException(const std::string & s)
function ThrowException (line 82) | void ThrowException(const char * s)
function ThrowNotTheSameException (line 88) | void ThrowNotTheSameException(const char * s, ptrdiff_t a, ptrdiff_t b)
type detail (line 114) | namespace detail
function exec (line 116) | static int exec(std::string cmd, std::string & out) {
function TranslateBacktrace (line 135) | static std::string TranslateBacktrace( std::string s, std::string li...
function TranslateBacktrace (line 179) | static std::string TranslateBacktrace( std::string s, std::string /*...
function GetBackTrace (line 238) | std::string GetBackTrace()
function GetBackTrace (line 304) | std::string GetBackTrace()
type ngcore (line 112) | namespace ngcore
function ThrowRangeException (line 72) | void ThrowRangeException(const char * s, ptrdiff_t ind, ptrdiff_t imin...
function ThrowException (line 77) | void ThrowException(const std::string & s)
function ThrowException (line 82) | void ThrowException(const char * s)
function ThrowNotTheSameException (line 88) | void ThrowNotTheSameException(const char * s, ptrdiff_t a, ptrdiff_t b)
type detail (line 114) | namespace detail
function exec (line 116) | static int exec(std::string cmd, std::string & out) {
function TranslateBacktrace (line 135) | static std::string TranslateBacktrace( std::string s, std::string li...
function TranslateBacktrace (line 179) | static std::string TranslateBacktrace( std::string s, std::string /*...
function GetBackTrace (line 238) | std::string GetBackTrace()
function GetBackTrace (line 304) | std::string GetBackTrace()
function ngcore_signal_handler (line 264) | static void ngcore_signal_handler(int sig)
type ngcore (line 302) | namespace ngcore
function ThrowRangeException (line 72) | void ThrowRangeException(const char * s, ptrdiff_t ind, ptrdiff_t imin...
function ThrowException (line 77) | void ThrowException(const std::string & s)
function ThrowException (line 82) | void ThrowException(const char * s)
function ThrowNotTheSameException (line 88) | void ThrowNotTheSameException(const char * s, ptrdiff_t a, ptrdiff_t b)
type detail (line 114) | namespace detail
function exec (line 116) | static int exec(std::string cmd, std::string & out) {
function TranslateBacktrace (line 135) | static std::string TranslateBacktrace( std::string s, std::string li...
function TranslateBacktrace (line 179) | static std::string TranslateBacktrace( std::string s, std::string /*...
function GetBackTrace (line 238) | std::string GetBackTrace()
function GetBackTrace (line 304) | std::string GetBackTrace()
FILE: libsrc/core/exception.hpp
type ngcore (line 13) | namespace ngcore
class NGCORE_API (line 18) | class NGCORE_API
class NGCORE_API (line 27) | class NGCORE_API
function Exception (line 33) | Exception(const Exception&) = default;
function Exception (line 34) | Exception(Exception&&) = default;
function Exception (line 49) | Exception & Append (const std::string & s) { m_what += s; return *this; }
function Exception (line 51) | Exception & Append (const char * s) { m_what += s; return *this; }
function RangeException (line 64) | class NGCORE_API RangeException : public Exception
function ExceptionNOSIMD (line 94) | class NGCORE_API ExceptionNOSIMD : public Exception
type IsSafe (line 98) | struct IsSafe {
type detail (line 101) | namespace detail {
function CheckRange (line 103) | inline static constexpr void CheckRange(const char * s, const T& n, ...
function CheckSame (line 111) | inline static constexpr void CheckSame(const char * s, const Ta& a, ...
FILE: libsrc/core/flags.cpp
type ngcore (line 16) | namespace ngcore
function Flags (line 93) | Flags Flags :: SetFlag (const char * name, bool b) &&
function Flags (line 99) | Flags Flags :: SetFlag (const char * name, double val) &&
function Flags (line 107) | Flags & Flags :: SetFlag (const char * name, const string & val)
function Flags (line 113) | Flags & Flags :: SetFlag (const char * name, double val) &
function Flags (line 119) | Flags & Flags :: SetFlag (const char * name, bool b) &
function Flags (line 125) | Flags & Flags :: SetFlag (const char * name, Flags & val) &
function Flags (line 133) | Flags & Flags :: SetFlag (const string & name, const string & val)
function Flags (line 141) | Flags & Flags :: SetFlag (const string & name, double val)
function Flags (line 147) | Flags & Flags :: SetFlag (const string & name, bool b)
function Flags (line 153) | Flags & Flags :: SetFlag (const string & name, Flags & val)
function Flags (line 159) | Flags & Flags :: SetFlag (const string & name, const Array<string> & val)
function Flags (line 173) | Flags & Flags :: SetFlag (const string & name, const Array<double> & val)
function Flags (line 182) | Flags & Flags :: SetFlag (const string & name, const std::any & val)
function string (line 188) | string Flags :: GetStringFlag (const string & name, const char * def) ...
function string (line 199) | string Flags :: GetStringFlag (const string & name, string def) const
function xbool (line 244) | xbool Flags :: GetDefineFlagX (string_view name) const throw()
function Flags (line 275) | const Flags &
FILE: libsrc/core/flags.hpp
type ngcore (line 20) | namespace ngcore
function Flags (line 28) | class NGCORE_API Flags
FILE: libsrc/core/generate_mpi_sources.py
function get_args (line 83) | def get_args(f, counts=False):
function generate_declarations (line 101) | def generate_declarations():
function generate_dummy_init (line 124) | def generate_dummy_init():
function generate_init (line 140) | def generate_init():
FILE: libsrc/core/hashtable.hpp
type ngcore (line 19) | namespace ngcore
class MakeTupleFromInt (line 24) | class MakeTupleFromInt
class MakeTupleFromInt<1> (line 33) | class MakeTupleFromInt<1>
class IVec (line 47) | class IVec
method IVec (line 56) | constexpr IVec () = default;
method NETGEN_INLINE (line 57) | constexpr NETGEN_INLINE IVec (const IVec & i1) : i(i1.i) { }
method NETGEN_INLINE (line 59) | constexpr NETGEN_INLINE IVec (T ai1) : i(ai1) { }
method IVec (line 63) | constexpr IVec (const T &v, T2... rest)
method DoArchive (line 95) | void DoArchive(ARCHIVE& ar)
method NETGEN_INLINE (line 102) | NETGEN_INLINE IVec (const IVec<N2,T2> & in2)
method NETGEN_INLINE (line 119) | NETGEN_INLINE IVec (const BaseArrayObject<T2> & ao)
method NETGEN_INLINE (line 125) | NETGEN_INLINE size_t Size() const { return N; }
method NETGEN_INLINE (line 127) | NETGEN_INLINE bool operator== (const IVec & in2) const
method NETGEN_INLINE (line 135) | NETGEN_INLINE bool operator!= (const IVec & in2) const
method NETGEN_INLINE (line 143) | NETGEN_INLINE IVec & Sort () &
method NETGEN_INLINE (line 152) | NETGEN_INLINE IVec Sort () &&
method NETGEN_INLINE (line 162) | NETGEN_INLINE T & operator[] (int j)
method NETGEN_INLINE (line 166) | NETGEN_INLINE constexpr const T & operator[] (int j) const
method T (line 170) | constexpr T get() const { return i[J]; }
method NETGEN_INLINE (line 174) | NETGEN_INLINE IVec<N,T> & operator= (T value)
method NETGEN_INLINE (line 182) | NETGEN_INLINE IVec<N,T> & operator= (IVec<N,T2> v2)
method Contains (line 195) | bool Contains (T val)
function NETGEN_INLINE (line 205) | NETGEN_INLINE IVec<2> & IVec<2>::Sort () &
function NETGEN_INLINE (line 212) | NETGEN_INLINE IVec<2> IVec<2>::Sort () &&
function NETGEN_INLINE (line 220) | NETGEN_INLINE IVec<3> IVec<3>::Sort () &&
function ostream (line 230) | inline ostream & operator<<(ostream & s, const IVec<N,T> & i2)
function begin (line 238) | auto begin(const IVec<N,T> & ind)
function end (line 244) | auto end(const IVec<N,T> & ind)
function NETGEN_INLINE (line 255) | NETGEN_INLINE size_t HashValue (const IVec<N,TI> & ind, size_t size)
function NETGEN_INLINE (line 266) | NETGEN_INLINE size_t HashValue (const IVec<1,TI> & ind, size_t size)
function NETGEN_INLINE (line 273) | NETGEN_INLINE size_t HashValue (const IVec<2,TI> & ind, size_t size)
function NETGEN_INLINE (line 281) | NETGEN_INLINE size_t HashValue (const IVec<3,TI> & ind, size_t size)
function NETGEN_INLINE (line 287) | NETGEN_INLINE size_t HashValue (size_t ind, size_t size)
function NETGEN_INLINE (line 291) | NETGEN_INLINE size_t HashValue (int ind, size_t size)
function NETGEN_INLINE (line 303) | NETGEN_INLINE constexpr size_t HashValue2 (const IVec<N,TI> & ind, siz...
function NETGEN_INLINE (line 314) | NETGEN_INLINE constexpr size_t HashValue2 (const IVec<1,TI> & ind, siz...
function NETGEN_INLINE (line 321) | NETGEN_INLINE constexpr size_t HashValue2 (const IVec<2,TI> & ind, siz...
function NETGEN_INLINE (line 329) | NETGEN_INLINE constexpr size_t HashValue2 (const IVec<3,TI> & ind, siz...
function NETGEN_INLINE (line 335) | NETGEN_INLINE constexpr size_t HashValue2 (size_t ind, size_t mask)
function NETGEN_INLINE (line 339) | NETGEN_INLINE constexpr size_t HashValue2 (int ind, size_t mask)
function NETGEN_INLINE (line 351) | NETGEN_INLINE T Max (const IVec<D,T> & i)
function NETGEN_INLINE (line 361) | NETGEN_INLINE T Min (const IVec<D,T> & i)
function NETGEN_INLINE (line 371) | NETGEN_INLINE IVec<D,T> Max (IVec<D,T> i1, IVec<D,T> i2)
function NETGEN_INLINE (line 380) | NETGEN_INLINE IVec<D,T> operator+ (IVec<D,T> i1, IVec<D,T> i2)
class HashTable (line 405) | class HashTable
function Set (line 421) | void Set (const T_HASH & ahash, const T & acont)
function T (line 437) | const T & Get (const T_HASH & ahash) const
function T (line 446) | const T & Get (int bnr, int pos) const
function Used (line 453) | bool Used (const T_HASH & ahash) const
function Used (line 460) | bool Used (const T_HASH & ahash, int & bnr, int & pos) const
function Size (line 470) | size_t Size () const
function EntrySize (line 477) | size_t EntrySize (int bnr) const
function GetData (line 484) | void GetData (int bnr, int colnr, T_HASH & ahash, T & acont) const
function SetData (line 493) | void SetData (int bnr, int colnr, const T_HASH & ahash, const T & acont)
function CheckPosition (line 501) | int CheckPosition (int bnr, const T_HASH & ind) const
function Position (line 515) | int Position (int bnr, const T_HASH & ind) const
function T (line 523) | T & operator[] (T_HASH ahash)
function T (line 538) | const T & operator[] (T_HASH ahash) const
class Iterator (line 543) | class Iterator
method Iterator (line 549) | Iterator (const HashTable & aht, int abnr, int apos)
method Iterator (line 559) | Iterator & operator++()
function Iterator (line 575) | Iterator begin () const
method Iterator (line 549) | Iterator (const HashTable & aht, int abnr, int apos)
method Iterator (line 559) | Iterator & operator++()
function Iterator (line 582) | Iterator end () const { return Iterator(*this, Size(),0); }
method Iterator (line 549) | Iterator (const HashTable & aht, int abnr, int apos)
method Iterator (line 559) | Iterator & operator++()
type MPI_typetrait (line 1261) | struct MPI_typetrait
type MPI_typetrait<IVec<S, T> > (line 1264) | struct MPI_typetrait<IVec<S, T> > {
method MPIType (line 1265) | static auto MPIType () {
function RoundUp2 (line 587) | inline size_t RoundUp2 (size_t i)
function T (line 595) | constexpr inline T InvalidHash() { return T(-1); }
type CHT_trait (line 598) | struct CHT_trait
method T_HASH (line 600) | constexpr static inline T_HASH Invalid() { return InvalidHash<T_HASH>(...
method HashValue (line 601) | constexpr static inline size_t HashValue (const T_HASH & hash, size_t ...
type CHT_trait<std::tuple<T1,T2>> (line 605) | struct CHT_trait<std::tuple<T1,T2>>
method Invalid (line 607) | constexpr static inline std::tuple<T1,T2> Invalid() { return { CHT_tra...
method HashValue (line 608) | constexpr static inline size_t HashValue (const std::tuple<T1,T2> & ha...
class ClosedHashTable (line 622) | class ClosedHashTable
method ClosedHashTable (line 640) | ClosedHashTable (size_t asize = 128)
method ClosedHashTable (line 649) | ClosedHashTable (ClosedHashTable && ht2) = default;
method ClosedHashTable (line 652) | ClosedHashTable (size_t asize, LocalHeap & lh)
method ClosedHashTable (line 659) | ClosedHashTable & operator= (ClosedHashTable && ht2) = default;
method Size (line 662) | size_t Size() const
method UsedPos (line 668) | bool UsedPos (size_t pos) const
method UsedElements (line 674) | size_t UsedElements () const
method Position (line 679) | size_t Position (const T_HASH ind) const
method DoubleSize (line 691) | void DoubleSize()
method PositionCreate (line 700) | bool PositionCreate (const T_HASH ind, size_t & apos)
method Set (line 727) | void Set (const T_HASH & ahash, const T & acont)
method T (line 736) | const T & Get (const T_HASH & ahash) const
method Used (line 745) | bool Used (const T_HASH & ahash) const
method GetIfUsed (line 750) | inline std::optional<T> GetIfUsed (const T_HASH & ahash) const
method SetData (line 760) | void SetData (size_t pos, const T_HASH & ahash, const T & acont)
method GetData (line 766) | void GetData (size_t pos, T_HASH & ahash, T & acont) const
method SetData (line 772) | void SetData (size_t pos, const T & acont)
method GetData (line 777) | void GetData (size_t pos, T & acont) const
method T (line 782) | T GetData (size_t pos) const
method GetBoth (line 787) | std::pair<T_HASH,T> GetBoth (size_t pos) const
method T (line 792) | const T & operator[] (T_HASH key) const { return Get(key); }
method T (line 793) | T & operator[] (T_HASH key)
method SetSize (line 800) | void SetSize (size_t asize)
method Delete (line 811) | void Delete (T_HASH key)
method DeleteData (line 832) | void DeleteData()
method DoArchive (line 839) | void DoArchive (ARCHIVE& ar)
type EndIterator (line 845) | struct EndIterator { }
class Iterator (line 847) | class Iterator
method Iterator (line 852) | Iterator (const ClosedHashTable & _tab, size_t _nr)
method Iterator (line 857) | Iterator & operator++()
method Iterator (line 869) | Iterator begin() const { return Iterator(*this, 0); }
method Iterator (line 852) | Iterator (const ClosedHashTable & _tab, size_t _nr)
method Iterator (line 857) | Iterator & operator++()
method EndIterator (line 870) | EndIterator end() const { return EndIterator(); }
function ostream (line 874) | ostream & operator<< (ostream & ost,
function NETGEN_INLINE (line 893) | NETGEN_INLINE size_t HashValue (const IVec<3,TI> ind)
function NETGEN_INLINE (line 900) | NETGEN_INLINE size_t HashValue (const IVec<2,TI> ind)
function NETGEN_INLINE (line 907) | NETGEN_INLINE size_t HashValue (const IVec<1,TI> ind)
class ParallelHashTable (line 914) | class ParallelHashTable
class ClosedHT (line 916) | class ClosedHT
method ClosedHT (line 923) | ClosedHT(size_t asize = 256) : keys(asize), values(asize), used(0)
method Size (line 928) | size_t Size () const { return keys.Size(); }
method Used (line 929) | size_t Used () const { return used; }
method ClosedHT (line 931) | ClosedHT & operator= (ClosedHT&&) = default;
method Resize (line 933) | void Resize()
method Do (line 949) | auto Do (TKEY key, TFUNC func, size_t hash)
method DoSave (line 957) | auto DoSave (TKEY key, TFUNC func, size_t hash)
method T (line 977) | T Get (TKEY key, size_t hash)
method GetCosts (line 991) | size_t GetCosts (TKEY key, size_t hash)
method Iterate (line 1009) | void Iterate (TFUNC func) const
method Print (line 1016) | void Print (ostream & ost) const
class MyMutex64 (line 1025) | class alignas(64) MyMutex64 : public MyMutex { }
method ParallelHashTable (line 1030) | ParallelHashTable() : hts(256), locks(256) { ; }
method NumBuckets (line 1031) | size_t NumBuckets() const { return hts.Size(); }
method BucketSize (line 1033) | size_t BucketSize(size_t nr) const { return hts[nr].Size(); }
method Used (line 1034) | size_t Used (size_t nr) const { return hts[nr].Used(); }
method Used (line 1035) | size_t Used() const
method Do (line 1043) | auto Do (TKEY key, TFUNC func)
method T (line 1056) | T Get (TKEY key)
method GetCosts (line 1065) | auto GetCosts (TKEY key)
method Iterate (line 1076) | void Iterate(TFUNC func) const
method Iterate (line 1083) | void Iterate(size_t nr, TFUNC func) const
method IterateParallel (line 1090) | void IterateParallel (FUNC func)
method Print (line 1115) | void Print (ostream & ost) const
function ostream (line 1127) | inline ostream & operator<< (ostream & ost, const ParallelHashTable<TKEY...
class CompressedTable (line 1142) | class CompressedTable
method CompressedTable (line 1148) | CompressedTable (Table<T, size_t> && atable, ClosedHashTable<IndexType...
class CompressedTableCreator (line 1163) | class CompressedTableCreator
method CompressedTableCreator (line 1172) | CompressedTableCreator()
method MoveTable (line 1175) | CompressedTable<T,IndexType> MoveTable()
method Done (line 1180) | bool Done () { return mode > 3; }
method GetMode (line 1183) | int GetMode () const { return mode; }
method SetMode (line 1184) | void SetMode (int amode)
method Add (line 1199) | void Add (IndexType blocknr, const T & data)
type ngcore (line 1259) | namespace ngcore
class MakeTupleFromInt (line 24) | class MakeTupleFromInt
class MakeTupleFromInt<1> (line 33) | class MakeTupleFromInt<1>
class IVec (line 47) | class IVec
method IVec (line 56) | constexpr IVec () = default;
method NETGEN_INLINE (line 57) | constexpr NETGEN_INLINE IVec (const IVec & i1) : i(i1.i) { }
method NETGEN_INLINE (line 59) | constexpr NETGEN_INLINE IVec (T ai1) : i(ai1) { }
method IVec (line 63) | constexpr IVec (const T &v, T2... rest)
method DoArchive (line 95) | void DoArchive(ARCHIVE& ar)
method NETGEN_INLINE (line 102) | NETGEN_INLINE IVec (const IVec<N2,T2> & in2)
method NETGEN_INLINE (line 119) | NETGEN_INLINE IVec (const BaseArrayObject<T2> & ao)
method NETGEN_INLINE (line 125) | NETGEN_INLINE size_t Size() const { return N; }
method NETGEN_INLINE (line 127) | NETGEN_INLINE bool operator== (const IVec & in2) const
method NETGEN_INLINE (line 135) | NETGEN_INLINE bool operator!= (const IVec & in2) const
method NETGEN_INLINE (line 143) | NETGEN_INLINE IVec & Sort () &
method NETGEN_INLINE (line 152) | NETGEN_INLINE IVec Sort () &&
method NETGEN_INLINE (line 162) | NETGEN_INLINE T & operator[] (int j)
method NETGEN_INLINE (line 166) | NETGEN_INLINE constexpr const T & operator[] (int j) const
method T (line 170) | constexpr T get() const { return i[J]; }
method NETGEN_INLINE (line 174) | NETGEN_INLINE IVec<N,T> & operator= (T value)
method NETGEN_INLINE (line 182) | NETGEN_INLINE IVec<N,T> & operator= (IVec<N,T2> v2)
method Contains (line 195) | bool Contains (T val)
function NETGEN_INLINE (line 205) | NETGEN_INLINE IVec<2> & IVec<2>::Sort () &
function NETGEN_INLINE (line 212) | NETGEN_INLINE IVec<2> IVec<2>::Sort () &&
function NETGEN_INLINE (line 220) | NETGEN_INLINE IVec<3> IVec<3>::Sort () &&
function ostream (line 230) | inline ostream & operator<<(ostream & s, const IVec<N,T> & i2)
function begin (line 238) | auto begin(const IVec<N,T> & ind)
function end (line 244) | auto end(const IVec<N,T> & ind)
function NETGEN_INLINE (line 255) | NETGEN_INLINE size_t HashValue (const IVec<N,TI> & ind, size_t size)
function NETGEN_INLINE (line 266) | NETGEN_INLINE size_t HashValue (const IVec<1,TI> & ind, size_t size)
function NETGEN_INLINE (line 273) | NETGEN_INLINE size_t HashValue (const IVec<2,TI> & ind, size_t size)
function NETGEN_INLINE (line 281) | NETGEN_INLINE size_t HashValue (const IVec<3,TI> & ind, size_t size)
function NETGEN_INLINE (line 287) | NETGEN_INLINE size_t HashValue (size_t ind, size_t size)
function NETGEN_INLINE (line 291) | NETGEN_INLINE size_t HashValue (int ind, size_t size)
function NETGEN_INLINE (line 303) | NETGEN_INLINE constexpr size_t HashValue2 (const IVec<N,TI> & ind, siz...
function NETGEN_INLINE (line 314) | NETGEN_INLINE constexpr size_t HashValue2 (const IVec<1,TI> & ind, siz...
function NETGEN_INLINE (line 321) | NETGEN_INLINE constexpr size_t HashValue2 (const IVec<2,TI> & ind, siz...
function NETGEN_INLINE (line 329) | NETGEN_INLINE constexpr size_t HashValue2 (const IVec<3,TI> & ind, siz...
function NETGEN_INLINE (line 335) | NETGEN_INLINE constexpr size_t HashValue2 (size_t ind, size_t mask)
function NETGEN_INLINE (line 339) | NETGEN_INLINE constexpr size_t HashValue2 (int ind, size_t mask)
function NETGEN_INLINE (line 351) | NETGEN_INLINE T Max (const IVec<D,T> & i)
function NETGEN_INLINE (line 361) | NETGEN_INLINE T Min (const IVec<D,T> & i)
function NETGEN_INLINE (line 371) | NETGEN_INLINE IVec<D,T> Max (IVec<D,T> i1, IVec<D,T> i2)
function NETGEN_INLINE (line 380) | NETGEN_INLINE IVec<D,T> operator+ (IVec<D,T> i1, IVec<D,T> i2)
class HashTable (line 405) | class HashTable
function Set (line 421) | void Set (const T_HASH & ahash, const T & acont)
function T (line 437) | const T & Get (const T_HASH & ahash) const
function T (line 446) | const T & Get (int bnr, int pos) const
function Used (line 453) | bool Used (const T_HASH & ahash) const
function Used (line 460) | bool Used (const T_HASH & ahash, int & bnr, int & pos) const
function Size (line 470) | size_t Size () const
function EntrySize (line 477) | size_t EntrySize (int bnr) const
function GetData (line 484) | void GetData (int bnr, int colnr, T_HASH & ahash, T & acont) const
function SetData (line 493) | void SetData (int bnr, int colnr, const T_HASH & ahash, const T & acont)
function CheckPosition (line 501) | int CheckPosition (int bnr, const T_HASH & ind) const
function Position (line 515) | int Position (int bnr, const T_HASH & ind) const
function T (line 523) | T & operator[] (T_HASH ahash)
function T (line 538) | const T & operator[] (T_HASH ahash) const
class Iterator (line 543) | class Iterator
method Iterator (line 549) | Iterator (const HashTable & aht, int abnr, int apos)
method Iterator (line 559) | Iterator & operator++()
function Iterator (line 575) | Iterator begin () const
method Iterator (line 549) | Iterator (const HashTable & aht, int abnr, int apos)
method Iterator (line 559) | Iterator & operator++()
function Iterator (line 582) | Iterator end () const { return Iterator(*this, Size(),0); }
method Iterator (line 549) | Iterator (const HashTable & aht, int abnr, int apos)
method Iterator (line 559) | Iterator & operator++()
type MPI_typetrait (line 1261) | struct MPI_typetrait
type MPI_typetrait<IVec<S, T> > (line 1264) | struct MPI_typetrait<IVec<S, T> > {
method MPIType (line 1265) | static auto MPIType () {
type std (line 1273) | namespace std
type tuple_size<ngcore::IVec<N,T>> (line 1277) | struct tuple_size<ngcore::IVec<N,T>> : std::integral_constant<std::siz...
type tuple_element<N,ngcore::IVec<M,T>> (line 1278) | struct tuple_element<N,ngcore::IVec<M,T>> { using type = T; }
FILE: libsrc/core/localheap.cpp
type ngcore (line 13) | namespace ngcore
function LocalHeap (line 37) | LocalHeap LocalHeap :: Split() const
FILE: libsrc/core/localheap.hpp
type ngcore (line 16) | namespace ngcore
class Allocator (line 19) | class Allocator
method Delete (line 27) | virtual void Delete(void* p)
method ArrayDelete (line 31) | virtual void ArrayDelete(void* p)
function LocalHeapOverflow (line 42) | class NGCORE_API LocalHeapOverflow : public Exception
function Borrow (line 58) | class LocalHeap : public Allocator
function NETGEN_INLINE (line 118) | NETGEN_INLINE LocalHeap & operator= (LocalHeap && lh2)
function NETGEN_INLINE (line 146) | NETGEN_INLINE void CleanUp() throw ()
function NETGEN_INLINE (line 154) | NETGEN_INLINE void * GetPointer () throw ()
function NETGEN_INLINE (line 160) | NETGEN_INLINE void CleanUp (void * addr) throw ()
function T (line 184) | T * Alloc (size_t size) // throw (LocalHeapOverflow)
function Delete (line 201) | virtual void Delete(void* /* p */) {}
function ArrayDelete (line 203) | virtual void ArrayDelete(void* /* p */) {}
function NETGEN_INLINE (line 209) | NETGEN_INLINE void ThrowException() { ; }
function NETGEN_INLINE (line 220) | NETGEN_INLINE size_t Available () const throw () { return (totsize - (p-...
function NETGEN_INLINE (line 226) | NETGEN_INLINE LocalHeap Split (int partnr, int nparts) const
function NETGEN_INLINE (line 237) | NETGEN_INLINE void ClearValues ()
function NETGEN_INLINE (line 242) | NETGEN_INLINE size_t UsedSize ()
class LocalHeapMem (line 257) | class LocalHeapMem : public LocalHeap
method NETGEN_INLINE (line 261) | NETGEN_INLINE LocalHeapMem (const char * aname) throw () : LocalHeap (...
class HeapReset (line 275) | class HeapReset
function NETGEN_INLINE (line 295) | NETGEN_INLINE void * operator new (size_t size, ngcore::Allocator & alloc)
function NETGEN_INLINE (line 300) | NETGEN_INLINE void * operator new [] (size_t size, ngcore::Allocator & a...
function NETGEN_INLINE (line 306) | NETGEN_INLINE void operator delete (void * p, ngcore::Allocator & lh)
function NETGEN_INLINE (line 311) | NETGEN_INLINE void operator delete [] (void * p, ngcore::Allocator & lh)
FILE: libsrc/core/logging.cpp
type ngcore (line 5) | namespace ngcore
function GetLogger (line 33) | std::shared_ptr<Logger> GetLogger(const std::string& /*unused*/)
function SetLoggingLevel (line 38) | void SetLoggingLevel(level::level_enum level, const std::string& /*unu...
function AddFileSink (line 43) | void AddFileSink(const std::string& /*unused*/, level::level_enum /*un...
function AddConsoleSink (line 46) | void AddConsoleSink(level::level_enum /*unused*/, const std::string& /...
function ClearLoggingSinks (line 47) | void ClearLoggingSinks(const std::string& /*unused*/) {}
function FlushOnLoggingLevel (line 48) | void FlushOnLoggingLevel(level::level_enum /*unused*/, const std::stri...
type spdlog (line 19) | namespace spdlog
class logger (line 21) | class logger
method logger (line 24) | logger() = default;
type ngcore (line 28) | namespace ngcore
function GetLogger (line 33) | std::shared_ptr<Logger> GetLogger(const std::string& /*unused*/)
function SetLoggingLevel (line 38) | void SetLoggingLevel(level::level_enum level, const std::string& /*unu...
function AddFileSink (line 43) | void AddFileSink(const std::string& /*unused*/, level::level_enum /*un...
function AddConsoleSink (line 46) | void AddConsoleSink(level::level_enum /*unused*/, const std::string& /...
function ClearLoggingSinks (line 47) | void ClearLoggingSinks(const std::string& /*unused*/) {}
function FlushOnLoggingLevel (line 48) | void FlushOnLoggingLevel(level::level_enum /*unused*/, const std::stri...
FILE: libsrc/core/logging.hpp
type spdlog (line 17) | namespace spdlog
class logger (line 19) | class logger
type ngcore (line 22) | namespace ngcore
type level (line 26) | namespace level
type level_enum (line 28) | enum level_enum
class Logger (line 40) | class Logger
method SetGlobalLoggingLevel (line 45) | static auto SetGlobalLoggingLevel( level::level_enum level )
method Logger (line 54) | Logger(std::shared_ptr<spdlog::logger> l) : logger(std::move(l)) {}
method replace (line 59) | std::string replace(std::string s, const T & t)
method log_helper (line 69) | std::string log_helper(std::string s)
method log_helper (line 75) | std::string log_helper(std::string s, const T &t)
method log_helper (line 81) | std::string log_helper( std::string s, const T &t, Args ... args)
method log (line 87) | void log( level::level_enum level, const char* str, Args ... args)
method trace (line 93) | void trace( const char* str, Args ... args) { log(level::level_enum:...
method debug (line 95) | void debug( const char* str, Args ... args) { log(level::level_enum:...
method info (line 97) | void info( const char* str, Args ... args) { log(level::level_enum::...
method warn (line 99) | void warn( const char* str, Args ... args) { log(level::level_enum::...
method error (line 101) | void error( const char* str, Args ... args) { log(level::level_enum:...
method critical (line 103) | void critical( const char* str, Args ... args) { log(level::level_en...
FILE: libsrc/core/memtracer.hpp
class MemoryTracer (line 16) | class MemoryTracer
type detail (line 18) | namespace detail
type has_StartMemoryTracing (line 22) | struct has_StartMemoryTracing
function CreateId (line 47) | static int CreateId(const std::string& name = "")
function MemoryTracer (line 60) | MemoryTracer( std::string name )
function MemoryTracer (line 65) | MemoryTracer() { }
function MemoryTracer (line 67) | MemoryTracer(const MemoryTracer & tracer)
function MemoryTracer (line 72) | MemoryTracer(MemoryTracer && tracer)
function MemoryTracer (line 77) | MemoryTracer & operator=(const MemoryTracer & tracer) {
function MemoryTracer (line 83) | MemoryTracer & operator=(MemoryTracer && tracer) {
function MemoryTracer (line 94) | MemoryTracer( std::string name, TRest & ... rest )
function NETGEN_INLINE (line 108) | NETGEN_INLINE void Alloc(size_t size) const
function Free (line 128) | void Free(size_t size) const
FILE: libsrc/core/mpi4py_pycapi.h
function _mpi4py_ImportType (line 101) | static int _mpi4py_ImportType(PyObject *module,
function _mpi4py_ImportFunc (line 122) | static int _mpi4py_ImportFunc(PyObject *module,
function import_mpi4py_MPI (line 168) | static int import_mpi4py_MPI(void)
FILE: libsrc/core/mpi_wrapper.hpp
type ngcore (line 15) | namespace ngcore
type MPI_typetrait (line 20) | struct MPI_typetrait { }
method NG_MPI_Datatype (line 535) | static NG_MPI_Datatype MPIType () { return -1; }
type MPI_typetrait<int> (line 22) | struct MPI_typetrait<int> {
method NG_MPI_Datatype (line 23) | static NG_MPI_Datatype MPIType () { return NG_MPI_INT; }
type MPI_typetrait<short> (line 25) | struct MPI_typetrait<short> {
method NG_MPI_Datatype (line 26) | static NG_MPI_Datatype MPIType () { return NG_MPI_SHORT; }
type MPI_typetrait<char> (line 28) | struct MPI_typetrait<char> {
method NG_MPI_Datatype (line 29) | static NG_MPI_Datatype MPIType () { return NG_MPI_CHAR; }
type MPI_typetrait<signed char> (line 31) | struct MPI_typetrait<signed char> {
method NG_MPI_Datatype (line 32) | static NG_MPI_Datatype MPIType () { return NG_MPI_CHAR; }
type MPI_typetrait<unsigned char> (line 34) | struct MPI_typetrait<unsigned char> {
method NG_MPI_Datatype (line 35) | static NG_MPI_Datatype MPIType () { return NG_MPI_CHAR; }
type MPI_typetrait<size_t> (line 37) | struct MPI_typetrait<size_t> {
method NG_MPI_Datatype (line 38) | static NG_MPI_Datatype MPIType () { return NG_MPI_UINT64_T; }
type MPI_typetrait<double> (line 40) | struct MPI_typetrait<double> {
method NG_MPI_Datatype (line 41) | static NG_MPI_Datatype MPIType () { return NG_MPI_DOUBLE; }
type MPI_typetrait<std::complex<double>> (line 43) | struct MPI_typetrait<std::complex<double>> {
method NG_MPI_Datatype (line 44) | static NG_MPI_Datatype MPIType () { return NG_MPI_CXX_DOUBLE_COMPLEX; }
type MPI_typetrait<bool> (line 46) | struct MPI_typetrait<bool> {
method NG_MPI_Datatype (line 47) | static NG_MPI_Datatype MPIType () { return NG_MPI_C_BOOL; }
type MPI_typetrait<std::array<T,S>> (line 51) | struct MPI_typetrait<std::array<T,S>>
method NG_MPI_Datatype (line 53) | static NG_MPI_Datatype MPIType ()
function NG_MPI_Datatype (line 66) | inline NG_MPI_Datatype GetMPIType () {
function NG_MPI_Datatype (line 71) | inline NG_MPI_Datatype GetMPIType (T &) {
class NgMPI_Request (line 75) | class NgMPI_Request
method NgMPI_Request (line 79) | NgMPI_Request (NG_MPI_Request requ) : request{requ} { }
method NgMPI_Request (line 80) | NgMPI_Request (const NgMPI_Request&) = delete;
method NgMPI_Request (line 81) | NgMPI_Request (NgMPI_Request&&) = default;
method Wait (line 83) | void Wait() { NG_MPI_Wait (&request, NG_MPI_STATUS_IGNORE); }
method NgMPI_Request (line 542) | NgMPI_Request() = default;
method NgMPI_Request (line 543) | NgMPI_Request(NgMPI_Request &&) { ; }
method NgMPI_Request (line 544) | NgMPI_Request(NG_MPI_Request &&) { ; }
class NgMPI_Requests (line 92) | class NgMPI_Requests
method NgMPI_Requests (line 96) | NgMPI_Requests() = default;
method Reset (line 99) | void Reset() { requests.SetSize0(); }
method NgMPI_Requests (line 101) | NgMPI_Requests & operator+= (NgMPI_Request && r)
method NgMPI_Requests (line 107) | NgMPI_Requests & operator+= (NG_MPI_Request r)
method WaitAll (line 113) | void WaitAll()
method WaitAny (line 120) | int WaitAny ()
method NgMPI_Requests (line 549) | NgMPI_Requests & operator+= (NgMPI_Request &&) { return *this; }
method NgMPI_Requests (line 550) | NgMPI_Requests & operator+= (NG_MPI_Request r) { return *this; }
method Reset (line 551) | void Reset() { ; }
method WaitAll (line 552) | void WaitAll() { ; }
method WaitAny (line 553) | int WaitAny() { return 0; }
function MyMPI_WaitAll (line 128) | [[deprecated("use requests.WaitAll instread")]]
function MyMPI_WaitAny (line 136) | [[deprecated("use requests.WaitAny instread")]]
class NgMPI_Comm (line 146) | class NgMPI_Comm
method NgMPI_Comm (line 154) | NgMPI_Comm ()
method NgMPI_Comm (line 158) | NgMPI_Comm (NG_MPI_Comm _comm, bool owns = false)
method NgMPI_Comm (line 181) | NgMPI_Comm (const NgMPI_Comm & c)
method NgMPI_Comm (line 188) | NgMPI_Comm (NgMPI_Comm && c)
method ValidCommunicator (line 202) | bool ValidCommunicator() const
method NgMPI_Comm (line 207) | NgMPI_Comm & operator= (const NgMPI_Comm & c)
class InvalidCommException (line 222) | class InvalidCommException : public Exception {
method InvalidCommException (line 224) | InvalidCommException() : Exception("Do not have a valid communicat...
method Rank (line 232) | int Rank() const { return rank; }
method Size (line 233) | int Size() const { return size; }
method Barrier (line 234) | void Barrier() const {
method Send (line 243) | void Send (T & val, int dest, int tag) const {
method Send (line 247) | void Send (const std::string & s, int dest, int tag) const {
method Send (line 252) | void Send(FlatArray<T,TI> s, int dest, int tag) const {
method Recv (line 257) | void Recv (T & val, int src, int tag) const {
method Recv (line 261) | void Recv (std::string & s, int src, int tag) const {
method Recv (line 273) | void Recv (FlatArray <T,TI> s, int src, int tag) const {
method Recv (line 278) | void Recv (Array <T,TI> & s, int src, int tag) const
method NG_MPI_Request (line 292) | [[nodiscard]] NG_MPI_Request ISend (T & val, int dest, int tag) const
method NG_MPI_Request (line 300) | [[nodiscard]] NG_MPI_Request ISend (FlatArray<T> s, int dest, int ta...
method NG_MPI_Request (line 308) | [[nodiscard]] NG_MPI_Request IRecv (T & val, int dest, int tag) const
method NG_MPI_Request (line 316) | [[nodiscard]] NG_MPI_Request IRecv (FlatArray<T> s, int src, int tag...
method T (line 327) | T Reduce (T d, const NG_MPI_Op & op, int root = 0) const
method T (line 338) | T AllReduce (T d, const NG_MPI_Op & op) const
method AllReduce (line 349) | void AllReduce (FlatArray<T> d, const NG_MPI_Op & op) const
method Bcast (line 358) | void Bcast (T & s, int root = 0) const {
method Bcast (line 366) | void Bcast (std::array<T,S> & d, int root = 0) const
method Bcast (line 375) | void Bcast (Array<T> & d, int root = 0) const
method Bcast (line 387) | void Bcast (std::string & s, int root = 0) const
method NgMPI_Request (line 399) | [[nodiscard]] NgMPI_Request IBcast (std::array<T,S> & d, int root = ...
method NgMPI_Request (line 407) | [[nodiscard]] NgMPI_Request IBcast (FlatArray<T> d, int root = 0) const
method AllToAll (line 417) | void AllToAll (FlatArray<T> send, FlatArray<T> recv) const
method ScatterRoot (line 425) | void ScatterRoot (FlatArray<T> send) const
method Scatter (line 433) | void Scatter (T & recv) const
method GatherRoot (line 441) | void GatherRoot (FlatArray<T> recv) const
method Gather (line 450) | void Gather (T send) const
method AllGather (line 459) | void AllGather (T val, FlatArray<T> recv) const
method ExchangeTable (line 474) | void ExchangeTable (DynamicTable<T> & send_data,
method NgMPI_Comm (line 503) | NgMPI_Comm SubCommunicator (FlatArray<int> procs) const
method NgMPI_Comm (line 560) | NgMPI_Comm () { ; }
method NgMPI_Comm (line 561) | NgMPI_Comm (NG_MPI_Comm _comm, bool owns = false) { ; }
method Rank (line 563) | size_t Rank() const { return 0; }
method Size (line 564) | size_t Size() const { return 1; }
method ValidCommunicator (line 565) | bool ValidCommunicator() const { return false; }
method Barrier (line 566) | void Barrier() const { ; }
method Send (line 570) | void Send( T & val, int dest, int tag) const { ; }
method Send (line 573) | void Send(FlatArray<T> s, int dest, int tag) const { ; }
method Recv (line 576) | void Recv (T & val, int src, int tag) const { ; }
method Recv (line 579) | void Recv (FlatArray <T> s, int src, int tag) const { ; }
method Recv (line 582) | void Recv (Array <T> & s, int src, int tag) const { ; }
method NG_MPI_Request (line 585) | NG_MPI_Request ISend (T & val, int dest, int tag) const { return 0; }
method NG_MPI_Request (line 588) | NG_MPI_Request ISend (FlatArray<T> s, int dest, int tag) const { ret...
method NG_MPI_Request (line 591) | NG_MPI_Request IRecv (T & val, int dest, int tag) const { return 0; }
method NG_MPI_Request (line 594) | NG_MPI_Request IRecv (FlatArray<T> s, int src, int tag) const { retu...
method T (line 597) | T Reduce (T d, const NG_MPI_Op & op, int root = 0) const { return d; }
method T (line 600) | T AllReduce (T d, const NG_MPI_Op & op) const { return d; }
method AllReduce (line 603) | void AllReduce (FlatArray<T> d, const NG_MPI_Op & op) const { ; }
method Bcast (line 606) | void Bcast (T & s, int root = 0) const { ; }
method Bcast (line 609) | void Bcast (std::array<T,S> & d, int root = 0) const {}
method Bcast (line 612) | void Bcast (Array<T> & d, int root = 0) const { ; }
method NG_MPI_Request (line 615) | NG_MPI_Request IBcast (std::array<T,S> & d, int root = 0) const { re...
method NG_MPI_Request (line 618) | NG_MPI_Request IBcast (FlatArray<T> d, int root = 0) const { return ...
method AllGather (line 621) | void AllGather (T val, FlatArray<T> recv) const
method ExchangeTable (line 627) | void ExchangeTable (DynamicTable<T> & send_data,
method NgMPI_Comm (line 631) | NgMPI_Comm SubCommunicator (FlatArray<int> procs) const
class NG_MPI_Comm (line 516) | class NG_MPI_Comm {
method NG_MPI_Comm (line 519) | NG_MPI_Comm (int _nr = 0) : nr(_nr) { ; }
function NG_MPI_Type_contiguous (line 531) | inline void NG_MPI_Type_contiguous ( int, NG_MPI_Datatype, NG_MPI_Data...
function NG_MPI_Type_commit (line 532) | inline void NG_MPI_Type_commit ( NG_MPI_Datatype * ) { ; }
type MPI_typetrait (line 534) | struct MPI_typetrait {
method NG_MPI_Datatype (line 535) | static NG_MPI_Datatype MPIType () { return -1; }
function NG_MPI_Datatype (line 538) | inline NG_MPI_Datatype GetMPIType () { return -1; }
class NgMPI_Request (line 540) | class NgMPI_Request {
method NgMPI_Request (line 79) | NgMPI_Request (NG_MPI_Request requ) : request{requ} { }
method NgMPI_Request (line 80) | NgMPI_Request (const NgMPI_Request&) = delete;
method NgMPI_Request (line 81) | NgMPI_Request (NgMPI_Request&&) = default;
method Wait (line 83) | void Wait() { NG_MPI_Wait (&request, NG_MPI_STATUS_IGNORE); }
method NgMPI_Request (line 542) | NgMPI_Request() = default;
method NgMPI_Request (line 543) | NgMPI_Request(NgMPI_Request &&) { ; }
method NgMPI_Request (line 544) | NgMPI_Request(NG_MPI_Request &&) { ; }
class NgMPI_Requests (line 546) | class NgMPI_Requests
method NgMPI_Requests (line 96) | NgMPI_Requests() = default;
method Reset (line 99) | void Reset() { requests.SetSize0(); }
method NgMPI_Requests (line 101) | NgMPI_Requests & operator+= (NgMPI_Request && r)
method NgMPI_Requests (line 107) | NgMPI_Requests & operator+= (NG_MPI_Request r)
method WaitAll (line 113) | void WaitAll()
method WaitAny (line 120) | int WaitAny ()
method NgMPI_Requests (line 549) | NgMPI_Requests & operator+= (NgMPI_Request &&) { return *this; }
method NgMPI_Requests (line 550) | NgMPI_Requests & operator+= (NG_MPI_Request r) { return *this; }
method Reset (line 551) | void Reset() { ; }
method WaitAll (line 552) | void WaitAll() { ; }
method WaitAny (line 553) | int WaitAny() { return 0; }
class NgMPI_Comm (line 556) | class NgMPI_Comm
method NgMPI_Comm (line 154) | NgMPI_Comm ()
method NgMPI_Comm (line 158) | NgMPI_Comm (NG_MPI_Comm _comm, bool owns = false)
method NgMPI_Comm (line 181) | NgMPI_Comm (const NgMPI_Comm & c)
method NgMPI_Comm (line 188) | NgMPI_Comm (NgMPI_Comm && c)
method ValidCommunicator (line 202) | bool ValidCommunicator() const
method NgMPI_Comm (line 207) | NgMPI_Comm & operator= (const NgMPI_Comm & c)
class InvalidCommException (line 222) | class InvalidCommException : public Exception {
method InvalidCommException (line 224) | InvalidCommException() : Exception("Do not have a valid communicat...
method Rank (line 232) | int Rank() const { return rank; }
method Size (line 233) | int Size() const { return size; }
method Barrier (line 234) | void Barrier() const {
method Send (line 243) | void Send (T & val, int dest, int tag) const {
method Send (line 247) | void Send (const std::string & s, int dest, int tag) const {
method Send (line 252) | void Send(FlatArray<T,TI> s, int dest, int tag) const {
method Recv (line 257) | void Recv (T & val, int src, int tag) const {
method Recv (line 261) | void Recv (std::string & s, int src, int tag) const {
method Recv (line 273) | void Recv (FlatArray <T,TI> s, int src, int tag) const {
method Recv (line 278) | void Recv (Array <T,TI> & s, int src, int tag) const
method NG_MPI_Request (line 292) | [[nodiscard]] NG_MPI_Request ISend (T & val, int dest, int tag) const
method NG_MPI_Request (line 300) | [[nodiscard]] NG_MPI_Request ISend (FlatArray<T> s, int dest, int ta...
method NG_MPI_Request (line 308) | [[nodiscard]] NG_MPI_Request IRecv (T & val, int dest, int tag) const
method NG_MPI_Request (line 316) | [[nodiscard]] NG_MPI_Request IRecv (FlatArray<T> s, int src, int tag...
method T (line 327) | T Reduce (T d, const NG_MPI_Op & op, int root = 0) const
method T (line 338) | T AllReduce (T d, const NG_MPI_Op & op) const
method AllReduce (line 349) | void AllReduce (FlatArray<T> d, const NG_MPI_Op & op) const
method Bcast (line 358) | void Bcast (T & s, int root = 0) const {
method Bcast (line 366) | void Bcast (std::array<T,S> & d, int root = 0) const
method Bcast (line 375) | void Bcast (Array<T> & d, int root = 0) const
method Bcast (line 387) | void Bcast (std::string & s, int root = 0) const
method NgMPI_Request (line 399) | [[nodiscard]] NgMPI_Request IBcast (std::array<T,S> & d, int root = ...
method NgMPI_Request (line 407) | [[nodiscard]] NgMPI_Request IBcast (FlatArray<T> d, int root = 0) const
method AllToAll (line 417) | void AllToAll (FlatArray<T> send, FlatArray<T> recv) const
method ScatterRoot (line 425) | void ScatterRoot (FlatArray<T> send) const
method Scatter (line 433) | void Scatter (T & recv) const
method GatherRoot (line 441) | void GatherRoot (FlatArray<T> recv) const
method Gather (line 450) | void Gather (T send) const
method AllGather (line 459) | void AllGather (T val, FlatArray<T> recv) const
method ExchangeTable (line 474) | void ExchangeTable (DynamicTable<T> & send_data,
method NgMPI_Comm (line 503) | NgMPI_Comm SubCommunicator (FlatArray<int> procs) const
method NgMPI_Comm (line 560) | NgMPI_Comm () { ; }
method NgMPI_Comm (line 561) | NgMPI_Comm (NG_MPI_Comm _comm, bool owns = false) { ; }
method Rank (line 563) | size_t Rank() const { return 0; }
method Size (line 564) | size_t Size() const { return 1; }
method ValidCommunicator (line 565) | bool ValidCommunicator() const { return false; }
method Barrier (line 566) | void Barrier() const { ; }
method Send (line 570) | void Send( T & val, int dest, int tag) const { ; }
method Send (line 573) | void Send(FlatArray<T> s, int dest, int tag) const { ; }
method Recv (line 576) | void Recv (T & val, int src, int tag) const { ; }
method Recv (line 579) | void Recv (FlatArray <T> s, int src, int tag) const { ; }
method Recv (line 582) | void Recv (Array <T> & s, int src, int tag) const { ; }
method NG_MPI_Request (line 585) | NG_MPI_Request ISend (T & val, int dest, int tag) const { return 0; }
method NG_MPI_Request (line 588) | NG_MPI_Request ISend (FlatArray<T> s, int dest, int tag) const { ret...
method NG_MPI_Request (line 591) | NG_MPI_Request IRecv (T & val, int dest, int tag) const { return 0; }
method NG_MPI_Request (line 594) | NG_MPI_Request IRecv (FlatArray<T> s, int src, int tag) const { retu...
method T (line 597) | T Reduce (T d, const NG_MPI_Op & op, int root = 0) const { return d; }
method T (line 600) | T AllReduce (T d, const NG_MPI_Op & op) const { return d; }
method AllReduce (line 603) | void AllReduce (FlatArray<T> d, const NG_MPI_Op & op) const { ; }
method Bcast (line 606) | void Bcast (T & s, int root = 0) const { ; }
method Bcast (line 609) | void Bcast (std::array<T,S> & d, int root = 0) const {}
method Bcast (line 612) | void Bcast (Array<T> & d, int root = 0) const { ; }
method NG_MPI_Request (line 615) | NG_MPI_Request IBcast (std::array<T,S> & d, int root = 0) const { re...
method NG_MPI_Request (line 618) | NG_MPI_Request IBcast (FlatArray<T> d, int root = 0) const { return ...
method AllGather (line 621) | void AllGather (T val, FlatArray<T> recv) const
method ExchangeTable (line 627) | void ExchangeTable (DynamicTable<T> & send_data,
method NgMPI_Comm (line 631) | NgMPI_Comm SubCommunicator (FlatArray<int> procs) const
function MyMPI_WaitAll (line 635) | inline void MyMPI_WaitAll (FlatArray<NG_MPI_Request> requests) { ; }
function MyMPI_WaitAny (line 636) | inline int MyMPI_WaitAny (FlatArray<NG_MPI_Request> requests) { return...
FILE: libsrc/core/ng_mpi.cpp
function MPI_Comm_create_group (line 22) | int MPI_Comm_create_group(MPI_Comm arg0, MPI_Group arg1, int arg2,
type ngcore (line 30) | namespace ngcore {
function mpi2ng (line 35) | int mpi2ng(int value) { return value; }
function NG_MPI_Status (line 38) | NG_MPI_Status* mpi2ng(MPI_Status* status) {
function NG_MPI_Comm (line 43) | NG_MPI_Comm mpi2ng(MPI_Comm comm) { return reinterpret_cast<uintptr_t>...
function gather_strided_array (line 47) | void gather_strided_array(size_t count, char* data) {
function T (line 61) | T cast_ng2mpi(uintptr_t obj) {
function T (line 69) | T cast_ng2mpi(uintptr_t* ptr) {
function T (line 77) | T* cast_ng2mpi(TSrc* ptr, int count) {
function MPI_Comm (line 83) | MPI_Comm ng2mpi(NG_MPI_Comm comm) {
function MPI_Group (line 89) | MPI_Group ng2mpi(NG_MPI_Group group) {
function MPI_Comm (line 95) | MPI_Comm* ng2mpi(NG_MPI_Comm* comm) {
function MPI_Group (line 98) | MPI_Group* ng2mpi(NG_MPI_Group* group) {
function MPI_Datatype (line 101) | MPI_Datatype* ng2mpi(NG_MPI_Datatype* type) {
function MPI_Datatype (line 104) | MPI_Datatype* ng2mpi(NG_MPI_Datatype* type, int count) {
function MPI_Request (line 107) | MPI_Request* ng2mpi(NG_MPI_Request* request) {
function MPI_Request (line 110) | MPI_Request* ng2mpi(NG_MPI_Request* request, int count) {
function MPI_Status (line 113) | MPI_Status* ng2mpi(NG_MPI_Status* status) {
function MPI_Aint (line 116) | MPI_Aint* ng2mpi(NG_MPI_Aint* aint) {
function MPI_Aint (line 119) | MPI_Aint* ng2mpi(NG_MPI_Aint* aint, int count) {
function MPI_Datatype (line 123) | MPI_Datatype ng2mpi(NG_MPI_Datatype type) {
function MPI_Request (line 128) | MPI_Request ng2mpi(NG_MPI_Request request) {
function MPI_Op (line 133) | MPI_Op ng2mpi(NG_MPI_Op op) {
function MPI_Aint (line 138) | MPI_Aint ng2mpi(NG_MPI_Aint aint) {
function ng2mpi (line 147) | int ng2mpi(int value) { return value; }
function ng_init_mpi (line 159) | void ng_init_mpi() {
FILE: libsrc/core/ng_mpi.hpp
type ngcore (line 17) | namespace ngcore {
function not_implemented (line 24) | inline void not_implemented() { throw std::runtime_error("Not implemen...
type NG_MPI_Status (line 26) | struct NG_MPI_Status {
type NG_MPI_Comm (line 30) | struct NG_MPI_Comm {
method NG_MPI_Comm (line 32) | NG_MPI_Comm() { value = 0; }
method NG_MPI_Comm (line 33) | NG_MPI_Comm(uintptr_t value_) : value(value_) {}
method NG_MPI_Comm (line 34) | NG_MPI_Comm(const NG_MPI_Comm &comm) : value(comm.value) {}
type NG_MPI_Datatype (line 42) | struct NG_MPI_Datatype {
method NG_MPI_Datatype (line 44) | NG_MPI_Datatype() = default;
method NG_MPI_Datatype (line 45) | NG_MPI_Datatype(uintptr_t value_) : value(value_) {}
type NG_MPI_Request (line 52) | struct NG_MPI_Request {
method NG_MPI_Request (line 54) | NG_MPI_Request() = default;
method NG_MPI_Request (line 55) | NG_MPI_Request(uintptr_t value_) : value(value_) {}
type NG_MPI_Op (line 60) | struct NG_MPI_Op {
method NG_MPI_Op (line 62) | NG_MPI_Op(uintptr_t value_) : value(value_) {}
type NG_MPI_Group (line 67) | struct NG_MPI_Group {
method NG_MPI_Group (line 69) | NG_MPI_Group(uintptr_t value_) : value(value_) {}
method NG_MPI_Group (line 70) | NG_MPI_Group() = default;
type NG_MPI_Aint (line 73) | struct NG_MPI_Aint {
method NG_MPI_Aint (line 75) | NG_MPI_Aint(intptr_t value_) : value(value_) {}
method NG_MPI_Aint (line 76) | NG_MPI_Aint() = default;
FILE: libsrc/core/ng_mpi_native.hpp
type ngcore (line 9) | namespace ngcore {
function MPI_Comm (line 11) | MPI_Comm NG_MPI_Native(NG_MPI_Comm comm) {
function MPI_Comm (line 15) | MPI_Comm NG_MPI_Native(NgMPI_Comm comm) {
function NG_MPI_Comm (line 19) | NG_MPI_Comm NG_MPI_From_Native (MPI_Comm comm) {
FILE: libsrc/core/ng_mpi_wrapper.cpp
type ngcore (line 27) | namespace ngcore {
type MPIFinalizer (line 33) | struct MPIFinalizer {
function MPI_Loaded (line 42) | bool MPI_Loaded() { return ng_mpi_lib != nullptr; }
function InitMPI (line 44) | void InitMPI(std::optional<std::filesystem::path> mpi_lib_path) {
function no_mpi (line 138) | static std::runtime_error no_mpi() {
function MPI_Loaded (line 199) | bool MPI_Loaded() { return true; }
function InitMPI (line 200) | void InitMPI(std::optional<std::filesystem::path>) {}
FILE: libsrc/core/ngstream.hpp
type ngcore (line 12) | namespace ngcore
class IM (line 18) | class IM
method IM (line 22) | IM (int val) : value(val) { ; }
method Value (line 23) | int Value () const { return value; }
class trunc (line 26) | class trunc
method trunc (line 30) | trunc (double aeps) : eps(aeps) { ; }
method Eps (line 31) | double Eps() const { return eps; }
class NGSOStream (line 34) | class NGSOStream
method NGSOStream (line 41) | NGSOStream (std::ostream & aost, bool aactive)
method NGSOStream (line 43) | NGSOStream & SetTrunc (double atrunc) { trunc = atrunc; return *this; }
method GetTrunc (line 44) | double GetTrunc () const { return trunc; }
method Active (line 45) | bool Active () const { return active && glob_active; }
method SetGlobalActive (line 47) | static void SetGlobalActive (bool b) { glob_active = b; }
function NGSOStream (line 50) | inline NGSOStream operator<< (std::ostream & ost, const IM & im)
method NGSOStream (line 41) | NGSOStream (std::ostream & aost, bool aactive)
method NGSOStream (line 43) | NGSOStream & SetTrunc (double atrunc) { trunc = atrunc; return *this; }
method GetTrunc (line 44) | double GetTrunc () const { return trunc; }
method Active (line 45) | bool Active () const { return active && glob_active; }
method SetGlobalActive (line 47) | static void SetGlobalActive (bool b) { glob_active = b; }
function NGSOStream (line 67) | inline NGSOStream operator<< (NGSOStream ngsost, const T & data)
method NGSOStream (line 41) | NGSOStream (std::ostream & aost, bool aactive)
method NGSOStream (line 43) | NGSOStream & SetTrunc (double atrunc) { trunc = atrunc; return *this; }
method GetTrunc (line 44) | double GetTrunc () const { return trunc; }
method Active (line 45) | bool Active () const { return active && glob_active; }
method SetGlobalActive (line 47) | static void SetGlobalActive (bool b) { glob_active = b; }
function NGSOStream (line 88) | inline NGSOStream operator<< (NGSOStream ngsost, std::ostream& ( *pf )...
method NGSOStream (line 41) | NGSOStream (std::ostream & aost, bool aactive)
method NGSOStream (line 43) | NGSOStream & SetTrunc (double atrunc) { trunc = atrunc; return *this; }
method GetTrunc (line 44) | double GetTrunc () const { return trunc; }
method Active (line 45) | bool Active () const { return active && glob_active; }
method SetGlobalActive (line 47) | static void SetGlobalActive (bool b) { glob_active = b; }
function NGSOStream (line 96) | inline NGSOStream operator<< (NGSOStream ngsost, std::ios& ( *pf )(std...
method NGSOStream (line 41) | NGSOStream (std::ostream & aost, bool aactive)
method NGSOStream (line 43) | NGSOStream & SetTrunc (double atrunc) { trunc = atrunc; return *this; }
method GetTrunc (line 44) | double GetTrunc () const { return trunc; }
method Active (line 45) | bool Active () const { return active && glob_active; }
method SetGlobalActive (line 47) | static void SetGlobalActive (bool b) { glob_active = b; }
function NGSOStream (line 104) | inline NGSOStream operator<< (NGSOStream ngsost, std::ios_base& ( *pf ...
method NGSOStream (line 41) | NGSOStream (std::ostream & aost, bool aactive)
method NGSOStream (line 43) | NGSOStream & SetTrunc (double atrunc) { trunc = atrunc; return *this; }
method GetTrunc (line 44) | double GetTrunc () const { return trunc; }
method Active (line 45) | bool Active () const { return active && glob_active; }
method SetGlobalActive (line 47) | static void SetGlobalActive (bool b) { glob_active = b; }
FILE: libsrc/core/paje_trace.cpp
type ngcore (line 19) | namespace ngcore
function GetTimerName (line 21) | static std::string GetTimerName( int id )
class PajeFile (line 156) | class PajeFile
method Hue2RGB (line 159) | static void Hue2RGB ( double x, double &r, double &g, double &b )
method ConvertTime (line 182) | double ConvertTime(TTimePoint t) {
type PType (line 189) | enum PType
type PajeEvent (line 200) | struct PajeEvent
method PajeEvent (line 202) | PajeEvent( int aevent_type, double atime, int atype, int acontaine...
method PajeEvent (line 206) | PajeEvent( int aevent_type, double atime, int atype, int acontaine...
method PajeEvent (line 210) | PajeEvent( int aevent_type, double atime, int atype, int acontaine...
method PajeEvent (line 214) | PajeEvent( int aevent_type, double atime, int atype, int acontaine...
method write (line 243) | int write(FILE *stream)
method PajeFile (line 276) | PajeFile() = delete;
method PajeFile (line 277) | PajeFile(const PajeFile &) = delete;
method PajeFile (line 278) | PajeFile(PajeFile &&) = delete;
method PajeFile (line 282) | PajeFile( const std::string & filename)
method DefineContainerType (line 295) | int DefineContainerType ( int parent_type, const std::string & name )
method DefineVariableType (line 305) | int DefineVariableType ( int container_type, const std::string & name )
method DefineStateType (line 312) | int DefineStateType ( int type, const std::string & name )
method DefineLinkType (line 324) | int DefineLinkType (int parent_container_type, int start_container_t...
method DefineEntityValue (line 331) | int DefineEntityValue (int type, const std::string & name, double hu...
method CreateContainer (line 351) | int CreateContainer ( int type, int parent, const std::string & name )
method DestroyContainer (line 360) | void DestroyContainer ()
method SetVariable (line 363) | void SetVariable (TTimePoint time, int type, int container, double v...
method AddVariable (line 368) | void AddVariable (TTimePoint time, int type, int container, double v...
method SubVariable (line 373) | void SubVariable (TTimePoint time, int type, int container, double v...
method SetState (line 378) | void SetState ()
method PushState (line 381) | void PushState ( TTimePoint time, int type, int container, int value...
method PushState (line 386) | void PushState ( TTimePoint time, int type, int container, std::stri...
method PopState (line 391) | void PopState ( TTimePoint time, int type, int container )
method ResetState (line 396) | void ResetState ()
method StartLink (line 399) | void StartLink ( TTimePoint time, int type, int container, int value...
method EndLink (line 404) | void EndLink ( TTimePoint time, int type, int container, int value, ...
method NewEvent (line 409) | void NewEvent ()
method WriteEvents (line 412) | void WriteEvents()
type TreeNode (line 930) | struct TreeNode
function PrintNode (line 944) | void PrintNode (const TreeNode &n, std::ofstream & f)
function WriteSunburstHTML (line 970) | void WriteSunburstHTML( TreeNode & root, std::string filename, bool ti...
FILE: libsrc/core/paje_trace.hpp
type ngcore (line 12) | namespace ngcore
class PajeTrace (line 16) | class PajeTrace
method SetTraceMemory (line 47) | static void SetTraceMemory( bool trace_memory )
method SetTraceThreads (line 52) | static void SetTraceThreads( bool atrace_threads )
method SetTraceThreadCounter (line 57) | static void SetTraceThreadCounter( bool trace_threads )
method SetMaxTracefileSize (line 62) | static void SetMaxTracefileSize( size_t max_size )
method SetWritePajeFile (line 67) | static void SetWritePajeFile( bool write )
type Job (line 74) | struct Job
type Task (line 82) | struct Task
type TimerEvent (line 99) | struct TimerEvent
type UserEvent (line 110) | struct UserEvent
type ThreadLink (line 120) | struct ThreadLink
type MemoryEvent (line 129) | struct MemoryEvent
method PajeTrace (line 151) | PajeTrace() = delete;
method PajeTrace (line 152) | PajeTrace(const PajeTrace &) = delete;
method PajeTrace (line 153) | PajeTrace(PajeTrace &&) = delete;
method AddUserContainer (line 160) | int AddUserContainer(std::string name, int parent=-1)
method AddUserEvent (line 169) | void AddUserEvent(UserEvent ue)
method StartGPU (line 174) | void StartGPU(int timer_id = 0, int user_value = -1)
method StopGPU (line 182) | void StopGPU(int timer_id)
method StartTimer (line 190) | void StartTimer(int timer_id, int user_value = -1)
method StopTimer (line 198) | void StopTimer(int timer_id)
method AllocMemory (line 206) | void AllocMemory(int id, size_t size)
method FreeMemory (line 212) | void FreeMemory(int id, size_t size)
method ChangeMemory (line 218) | void ChangeMemory(int id, long long size)
method StartTask (line 227) | int StartTask(int thread_id, int id, int id_type = Task::ID_NONE, in...
method StopTask (line 238) | void StopTask(int thread_id, int id, int id_type = Task::ID_NONE)
method StartJob (line 244) | void StartJob(int job_id, const std::type_info & type)
method StopJob (line 252) | void StopJob()
method StartLink (line 258) | void StartLink(int thread_id, int key)
method StopLink (line 266) | void StopLink(int thread_id, int key)
FILE: libsrc/core/profiler.cpp
type ngcore (line 5) | namespace ngcore
FILE: libsrc/core/profiler.hpp
type ngcore (line 15) | namespace ngcore
class NgProfiler (line 17) | class NgProfiler
type TimerVal (line 23) | struct TimerVal
method TimerVal (line 25) | TimerVal() = default;
method NgProfiler (line 51) | NgProfiler(const NgProfiler &) = delete;
method NgProfiler (line 52) | NgProfiler(NgProfiler &&) = delete;
method SetFileName (line 56) | static void SetFileName (const std::string & afilename) { filename =...
method StartTimer (line 65) | static void StartTimer (int nr)
method StopTimer (line 71) | static void StopTimer (int nr)
method StartThreadTimer (line 76) | static void StartThreadTimer (size_t nr, size_t tid)
method StopThreadTimer (line 81) | static void StopThreadTimer (size_t nr, size_t tid)
method AddThreadFlops (line 86) | static void AddThreadFlops (size_t nr, size_t tid, size_t flops)
method AddFlops (line 92) | static void AddFlops (int nr, double aflops) { timers[nr].flops += a...
method AddLoads (line 93) | static void AddLoads (int nr, double aloads) { timers[nr].loads += a...
method AddStores (line 94) | static void AddStores (int nr, double astores) { timers[nr].stores +...
method GetNr (line 96) | static int GetNr (const std::string & name)
method GetTime (line 104) | static double GetTime (int nr)
method GetTime (line 109) | static double GetTime (const std::string & name)
method GetCounts (line 117) | static long int GetCounts (int nr)
method GetFlops (line 122) | static double GetFlops (int nr)
method SetName (line 128) | static void SetName (int nr, const std::string & name) { timers[nr]....
method GetName (line 129) | static std::string GetName (int nr) { return timers[nr].name; }
class RegionTimer (line 133) | class RegionTimer
method RegionTimer (line 138) | RegionTimer (int anr) : nr(anr) { NgProfiler::StartTimer(nr); }
method RegionTimer (line 142) | RegionTimer() = delete;
method RegionTimer (line 143) | RegionTimer(const RegionTimer &) = delete;
method RegionTimer (line 144) | RegionTimer(RegionTimer &&) = delete;
type TNoTracing (line 151) | struct TNoTracing{ static constexpr bool do_tracing=false; }
type TTracing (line 152) | struct TTracing{ static constexpr bool do_tracing=true; }
type TNoTiming (line 154) | struct TNoTiming{ static constexpr bool do_timing=false; }
type TTiming (line 155) | struct TTiming{ static constexpr bool do_timing=true; }
type detail (line 157) | namespace detail {
class Timer (line 170) | class Timer
method Init (line 173) | int Init( const std::string & name )
method Timer (line 181) | Timer (const std::string & name) : timernr(Init(name)) { }
method Timer (line 184) | Timer( const std::string & name, TTracing ) : timernr(Init(name)) { }
method Timer (line 187) | Timer( const std::string & name, TTiming ) : timernr(Init(name)) { }
method Timer (line 189) | Timer( const std::string & name, TTracing, TTiming ) : timernr(Init(...
method Timer (line 191) | [[deprecated ("Use Timer(name, NoTracing/NoTiming) instead")]] Timer...
method SetName (line 193) | void SetName (const std::string & name)
method Start (line 197) | void Start () const
method Stop (line 201) | void Stop () const
method Start (line 205) | void Start (int tid, int trace_value = -1) const
method Stop (line 222) | void Stop (int tid) const
method AddFlops (line 239) | void AddFlops (double aflops)
method GetTime (line 245) | double GetTime () { return NgProfiler::GetTime(timernr); }
method GetCounts (line 246) | long int GetCounts () { return NgProfiler::GetCounts(timernr); }
method GetMFlops (line 247) | double GetMFlops ()
class RegionTimer (line 259) | class RegionTimer
method RegionTimer (line 265) | RegionTimer (const TTimer & atimer, int trace_value = -1) : timer(at...
method RegionTimer (line 274) | RegionTimer() = delete;
method RegionTimer (line 275) | RegionTimer(const RegionTimer &) = delete;
method RegionTimer (line 276) | RegionTimer(RegionTimer &&) = delete;
class ThreadRegionTimer (line 281) | class [[deprecated("Use RegionTimer instead (now thread safe)")]] Thre...
method ThreadRegionTimer (line 287) | ThreadRegionTimer (size_t _nr, size_t _tid) : nr(_nr), tid(_tid)
method ThreadRegionTimer (line 293) | ThreadRegionTimer() = delete;
method ThreadRegionTimer (line 294) | ThreadRegionTimer(ThreadRegionTimer &&) = delete;
method ThreadRegionTimer (line 295) | ThreadRegionTimer(const ThreadRegionTimer &) = delete;
class RegionTracer (line 300) | class RegionTracer
method RegionTracer (line 310) | RegionTracer() = delete;
method RegionTracer (line 311) | RegionTracer(RegionTracer &&) = delete;
method RegionTracer (line 312) | RegionTracer(const RegionTracer &) = delete;
method RegionTracer (line 317) | RegionTracer (int athread_id, int region_id, int id_type = ID_NONE, ...
method RegionTracer (line 327) | RegionTracer (int athread_id, TTimer & timer, int additional_value =...
function RunTiming (line 349) | double RunTiming( TFunc f, double max_time = 0.5, int min_iterations =...
FILE: libsrc/core/python_ngcore.cpp
type ngcore (line 8) | namespace ngcore
function Archive (line 13) | Archive& Archive::Shallow(std::any& val)
function SetFlag (line 29) | void SetFlag(Flags &flags, string s, py::object value)
function Flags (line 82) | Flags CreateFlagsFromKwArgs(const py::kwargs& kwargs, py::object pycla...
function CreateDictFromFlags (line 134) | py::dict CreateDictFromFlags(const Flags& flags)
FILE: libsrc/core/python_ngcore.hpp
type ngcore (line 20) | namespace ngcore
type detail (line 27) | namespace detail
type HasPyFormat (line 30) | struct HasPyFormat
type mpi4py_comm (line 42) | struct mpi4py_comm {
method mpi4py_comm (line 43) | mpi4py_comm() = default;
method mpi4py_comm (line 44) | mpi4py_comm(NG_MPI_Comm value) : value(value) {}
type PyNameTraits (line 149) | struct PyNameTraits {
function GetPyName (line 158) | std::string GetPyName(const char *prefix = 0) {
type PyNameTraits<int> (line 166) | struct PyNameTraits<int> {
method GetName (line 167) | static std::string GetName() { return "I"; }
type PyNameTraits<unsigned> (line 171) | struct PyNameTraits<unsigned> {
method GetName (line 172) | static std::string GetName() { return "U"; }
type PyNameTraits<float> (line 176) | struct PyNameTraits<float> {
method GetName (line 177) | static std::string GetName() { return "F"; }
type PyNameTraits<double> (line 181) | struct PyNameTraits<double> {
method GetName (line 182) | static std::string GetName() { return "D"; }
type PyNameTraits<size_t> (line 186) | struct PyNameTraits<size_t> {
method GetName (line 187) | static std::string GetName() { return "S"; }
type PyNameTraits<std::shared_ptr<T>> (line 191) | struct PyNameTraits<std::shared_ptr<T>> {
method GetName (line 192) | static std::string GetName()
function PyArchive (line 197) | class NGCORE_API_EXPORT PyArchive : public ARCHIVE
function NGSPickle (line 264) | auto NGSPickle()
function makeCArray (line 284) | Array<T> makeCArray(const py::object& obj)
function makePyTuple (line 300) | py::object makePyTuple (const BaseArrayObject<T> & ar)
function ExportArray (line 309) | void ExportArray (py::module &m)
function ExportTable (line 406) | void ExportTable (py::module &m)
type pybind11 (line 55) | namespace pybind11 {
type detail (line 56) | namespace detail {
type type_caster<ngcore::mpi4py_comm> (line 59) | struct type_caster<ngcore::mpi4py_comm> {
method load (line 64) | bool load(handle src, bool) {
method handle (line 69) | static handle cast(ngcore::mpi4py_comm src,
type ngcore_list_caster (line 79) | struct ngcore_list_caster {
method load (line 82) | bool load(handle src, bool convert) {
method handle (line 99) | static handle cast(T &&src, return_value_policy policy, handle par...
type type_caster<ngcore::Array<Type>, enable_if_t<!ngcore::detail::HasPyFormat<Type>::value>> (line 117) | struct type_caster<ngcore::Array<Type>, enable_if_t<!ngcore::detail:...
type ngcore (line 142) | namespace ngcore
type detail (line 27) | namespace detail
type HasPyFormat (line 30) | struct HasPyFormat
type mpi4py_comm (line 42) | struct mpi4py_comm {
method mpi4py_comm (line 43) | mpi4py_comm() = default;
method mpi4py_comm (line 44) | mpi4py_comm(NG_MPI_Comm value) : value(value) {}
type PyNameTraits (line 149) | struct PyNameTraits {
function GetPyName (line 158) | std::string GetPyName(const char *prefix = 0) {
type PyNameTraits<int> (line 166) | struct PyNameTraits<int> {
method GetName (line 167) | static std::string GetName() { return "I"; }
type PyNameTraits<unsigned> (line 171) | struct PyNameTraits<unsigned> {
method GetName (line 172) | static std::string GetName() { return "U"; }
type PyNameTraits<float> (line 176) | struct PyNameTraits<float> {
method GetName (line 177) | static std::string GetName() { return "F"; }
type PyNameTraits<double> (line 181) | struct PyNameTraits<double> {
method GetName (line 182) | static std::string GetName() { return "D"; }
type PyNameTraits<size_t> (line 186) | struct PyNameTraits<size_t> {
method GetName (line 187) | static std::string GetName() { return "S"; }
type PyNameTraits<std::shared_ptr<T>> (line 191) | struct PyNameTraits<std::shared_ptr<T>> {
method GetName (line 192) | static std::string GetName()
function PyArchive (line 197) | class NGCORE_API_EXPORT PyArchive : public ARCHIVE
function NGSPickle (line 264) | auto NGSPickle()
function makeCArray (line 284) | Array<T> makeCArray(const py::object& obj)
function makePyTuple (line 300) | py::object makePyTuple (const BaseArrayObject<T> & ar)
function ExportArray (line 309) | void ExportArray (py::module &m)
function ExportTable (line 406) | void ExportTable (py::module &m)
FILE: libsrc/core/python_ngcore_export.cpp
type pybind11 (line 11) | namespace pybind11 { namespace detail {
type detail (line 11) | namespace detail {
function PYBIND11_MODULE (line 17) | PYBIND11_MODULE(pyngcore, m) // NOLINT
FILE: libsrc/core/ranges.hpp
type ngcore (line 6) | namespace ngcore
class AdapterRange (line 9) | class AdapterRange
method AdapterRange (line 13) | AdapterRange(Iterator abegin, Iterator aend) : _begin(abegin), _end(...
method Iterator (line 14) | Iterator begin() const { return _begin; }
method Iterator (line 15) | Iterator end() const { return _end; }
class FilterAdapter (line 19) | class FilterAdapter
method FilterAdapter (line 23) | FilterAdapter(FUNC af) : f(af) { ; }
method FUNC (line 24) | FUNC GetFunction() const { return f; }
class FilterIterator (line 28) | class FilterIterator
method FilterIterator (line 34) | FilterIterator(FUNC af, Iterator aiter, Iterator aend)
method FilterIterator (line 40) | inline FilterIterator& operator ++()
function filter (line 65) | FilterAdapter<FUNC> filter(FUNC f) { return {f}; }
class TransformIterator (line 76) | class TransformIterator
method TransformIterator (line 81) | TransformIterator(FUNC af, Iterator aiter) : f(af), iter(aiter) { ; }
method TransformIterator (line 83) | TransformIterator& operator++() { ++iter; }
class TransformAdapter (line 89) | class TransformAdapter
method TransformAdapter (line 93) | TransformAdapter(FUNC af) : f(af) { ; }
method FUNC (line 94) | FUNC GetFunction() const { return f; }
function transform (line 98) | TransformAdapter<FUNC> transform(FUNC f) { return {f}; }
FILE: libsrc/core/register_archive.hpp
type ngcore (line 13) | namespace ngcore {
function Archive (line 18) | Archive& Archive :: Shallow(T& val)
class RegisterClassForArchive (line 52) | class RegisterClassForArchive
method RegisterClassForArchive (line 55) | RegisterClassForArchive()
FILE: libsrc/core/signal.hpp
type ngcore (line 8) | namespace ngcore
class Signal (line 11) | class Signal
method Signal (line 17) | Signal() : is_emitting(true) {}
method Connect (line 20) | void Connect(Cls* self, FUNC f)
method Emit (line 33) | inline void Emit(ParameterTypes ...args)
method SetEmitting (line 39) | inline bool SetEmitting(bool emitting)
method GetEmitting (line 45) | inline bool GetEmitting() const { return is_emitting; }
class SimpleSignal (line 51) | class SimpleSignal
method SimpleSignal (line 57) | SimpleSignal() = default;
method Connect (line 60) | void Connect(void* var, FUNC f)
method Remove (line 66) | void Remove(void* var)
method Emit (line 72) | inline void Emit()
FILE: libsrc/core/simd.hpp
type ngcore (line 39) | namespace ngcore
function GetMaskFromBits (line 52) | NETGEN_INLINE auto GetMaskFromBits( unsigned int i )
function NETGEN_INLINE (line 59) | NETGEN_INLINE void SIMDTranspose (SIMD<double,4> a1, SIMD<double,4> a2...
function HSum (line 81) | NETGEN_INLINE auto HSum (SIMD<double,N> s1, SIMD<double,N> s2)
function HSum (line 87) | NETGEN_INLINE auto HSum (SIMD<double,N> s1, SIMD<double,N> s2, SIMD<do...
class MakeSimdCl (line 95) | class MakeSimdCl
method MakeSimdCl (line 106) | MakeSimdCl (std::array<T,S> aa) : a(aa) { ; }
method Get (line 107) | auto Get() const
function MakeSimd (line 98) | auto MakeSimd (std::array<T,S> aa) { return MakeSimdCl(aa).Get(); }
class MakeSimdCl (line 102) | class MakeSimdCl
method MakeSimdCl (line 106) | MakeSimdCl (std::array<T,S> aa) : a(aa) { ; }
method Get (line 107) | auto Get() const
class MakeSimdCl<std::tuple<Tfirst,Trest...>,S> (line 118) | class MakeSimdCl<std::tuple<Tfirst,Trest...>,S>
method MakeSimdCl (line 122) | MakeSimdCl (std::array<std::tuple<Tfirst,Trest...>,S> aa) : a(aa) { ; }
method Get (line 123) | auto Get() const
method skip_first (line 144) | static auto skip_first(const std::tuple<Ts...>& t) {
FILE: libsrc/core/simd_arm64.hpp
type ngcore (line 3) | namespace ngcore
class SIMD<mask64,2> (line 7) | class SIMD<mask64,2>
method SIMD (line 11) | SIMD (int i)
method SIMD (line 17) | SIMD (bool i0, bool i1) { mask[0] = i0 ? -1 : 0; mask[1] = i1 ? -1 :...
method SIMD (line 18) | SIMD (SIMD<mask64,1> i0, SIMD<mask64,1> i1) { mask[0] = i0[0]; mask[...
method SIMD (line 20) | SIMD (int64x2_t _data) : mask{_data} { }
method Data (line 21) | auto Data() const { return mask; }
method Size (line 22) | static constexpr int Size() { return 2; }
method Get (line 27) | int64_t Get() const { return mask[I]; }
method Lo (line 29) | auto Lo() const { return mask[0]; }
method Hi (line 30) | auto Hi() const { return mask[1]; }
class SIMD<int32_t,2> (line 39) | class SIMD<int32_t,2>
method Size (line 43) | static constexpr int Size() { return 2; }
method SIMD (line 44) | SIMD() {}
method SIMD (line 45) | SIMD (int32_t val) : data{val,val} {}
method SIMD (line 46) | SIMD (int32_t v0, int32_t v1) : data{v0,v1} { }
method SIMD (line 47) | SIMD (SIMD<int32_t,1> lo, SIMD<int32_t,1> hi) : data{lo[0], hi[0] } { }
method SIMD (line 48) | SIMD (std::array<int32_t, 2> arr) : data{arr[0], arr[1]} { }
method SIMD (line 50) | SIMD (int32x2_t _data) { data = _data; }
method Data (line 52) | NETGEN_INLINE auto Data() const { return data; }
method Lo (line 55) | SIMD<int32_t,1> Lo() const { return Get<0>(); }
method Hi (line 56) | SIMD<int32_t,1> Hi() const { return Get<1>(); }
method Get (line 62) | int32_t Get() const { return data[I]; }
method SIMD (line 63) | static SIMD FirstInt(int n0=0) { return { n0+0, n0+1 }; }
class SIMD<int32_t,4> (line 68) | class SIMD<int32_t,4>
method Size (line 72) | static constexpr int Size() { return 4; }
method SIMD (line 73) | SIMD() {}
method SIMD (line 74) | SIMD (int32_t val) : data{val,val,val,val} {}
method SIMD (line 75) | SIMD (int32_t v0, int32_t v1, int32_t v2, int32_t v3) : data{v0,v1,v...
method SIMD (line 76) | SIMD (std::array<int32_t, 4> arr) : data{arr[0], arr[1], arr[2], arr...
method SIMD (line 78) | SIMD (int32x4_t _data) { data = _data; }
method SIMD (line 79) | SIMD (SIMD<int32_t,2> lo, SIMD<int32_t,2> hi) : data{vcombine_s32(lo...
method SIMD (line 80) | SIMD (int32_t * p) : data{vld1q_s32(p)} { }
method Data (line 82) | NETGEN_INLINE auto Data() const { return data; }
method Lo (line 85) | SIMD<int32_t,2> Lo() const { return vget_low_s32(data); }
method Hi (line 86) | SIMD<int32_t,2> Hi() const { return vget_high_s32(data); }
method Store (line 91) | void Store (int32_t * p) { vst1q_s32(p, data); }
method Get (line 94) | int32_t Get() const { return data[I]; }
method SIMD (line 95) | static SIMD FirstInt(int n0=0) { return { n0+0, n0+1, n0+2, n0+3 }; }
function Min (line 100) | NETGEN_INLINE auto Min (SIMD<int32_t,2> a, SIMD<int32_t,2> b) {
function Max (line 104) | NETGEN_INLINE auto Max (SIMD<int32_t,2> a, SIMD<int32_t,2> b) {
function Min (line 109) | NETGEN_INLINE auto Min (SIMD<int32_t,4> a, SIMD<int32_t,4> b) {
function Max (line 113) | NETGEN_INLINE auto Max (SIMD<int32_t,4> a, SIMD<int32_t,4> b) {
class SIMD<int64_t,2> (line 123) | class SIMD<int64_t,2>
method Size (line 127) | static constexpr int Size() { return 2; }
method SIMD (line 128) | SIMD() {}
method SIMD (line 129) | SIMD (int64_t val) : data{val,val} {}
method SIMD (line 130) | SIMD (int64_t v0, int64_t v1) : data{vcombine_s64(int64x1_t{v0}, int...
method SIMD (line 131) | SIMD (std::array<int64_t, 2> arr) : data{arr[0], arr[1]} { }
method SIMD (line 133) | SIMD (int64x2_t _data) { data = _data; }
method Data (line 135) | NETGEN_INLINE auto Data() const { return data; }
method Lo (line 138) | int64_t Lo() const { return Get<0>(); }
method Hi (line 139) | int64_t Hi() const { return Get<1>(); }
method Get (line 145) | int64_t Get() const { return data[I]; }
method SIMD (line 146) | static SIMD FirstInt(int n0=0) { return { n0+0, n0+1 }; }
function NETGEN_INLINE (line 149) | NETGEN_INLINE SIMD<int64_t,2> operator& (SIMD<int64_t,2> a, SIMD<int64...
function NETGEN_INLINE (line 154) | NETGEN_INLINE SIMD<int64_t,2> operator+ (SIMD<int64_t,2> a, SIMD<int64...
function NETGEN_INLINE (line 159) | NETGEN_INLINE SIMD<mask64,2> operator== (SIMD<int64_t> a, SIMD<int64_t...
function NETGEN_INLINE (line 164) | NETGEN_INLINE SIMD<mask64,2> operator> (SIMD<int64_t> a, SIMD<int64_t> b)
class SIMD<double,2> (line 181) | class SIMD<double,2>
method Size (line 186) | static constexpr int Size() { return 2; }
method SIMD (line 187) | SIMD () {}
method SIMD (line 188) | SIMD (const SIMD &) = default;
method SIMD (line 190) | SIMD (double v0, double v1) : data{vcombine_f64(float64x1_t{v0}, flo...
method SIMD (line 191) | SIMD (SIMD<double,1> v0, SIMD<double,1> v1) : data{vcombine_f64(floa...
method SIMD (line 192) | SIMD (std::array<double, 2> arr) : data{arr[0], arr[1]} { }
method SIMD (line 194) | SIMD & operator= (const SIMD &) = default;
method SIMD (line 196) | SIMD (double val) : data{val,val} { }
method SIMD (line 197) | SIMD (int val) : data{double(val),double(val)} { }
method SIMD (line 198) | SIMD (size_t val) : data{double(val),double(val)} { }
method SIMD (line 200) | SIMD (double const * p)
method SIMD (line 207) | SIMD (double const * p, SIMD<mask64,2> mask)
method SIMD (line 212) | SIMD (float64x2_t _data) { data = _data; }
method SIMD (line 215) | SIMD (const T & func)
method Store (line 221) | void Store (double * p)
method Store (line 230) | void Store (double * p, SIMD<mask64,2> mask)
method NETGEN_INLINE (line 237) | NETGEN_INLINE double operator[] (int i) const { return data[i]; }
method NETGEN_INLINE (line 238) | NETGEN_INLINE double & operator[] (int i) { return ((double*)&data)...
method Get (line 241) | double Get() const { return data[I]; }
method Data (line 243) | NETGEN_INLINE auto Data() const { return data; }
method Lo (line 252) | double Lo() const { return Get<0>(); }
method Hi (line 253) | double Hi() const { return Get<1>(); }
function NETGEN_INLINE (line 259) | NETGEN_INLINE double HSum (SIMD<double,2> sd)
function NETGEN_INLINE (line 264) | NETGEN_INLINE SIMD<double,2> HSum (SIMD<double,2> a, SIMD<double,2> b)
function NETGEN_INLINE (line 270) | NETGEN_INLINE SIMD<double,4> HSum(SIMD<double,2> a, SIMD<double,2> b, ...
function NETGEN_INLINE (line 276) | NETGEN_INLINE SIMD<double,2> SwapPairs (SIMD<double,2> a)
function NETGEN_INLINE (line 284) | NETGEN_INLINE SIMD<double,2> FMA (SIMD<double,2> a, SIMD<double,2> b, ...
function NETGEN_INLINE (line 288) | NETGEN_INLINE SIMD<double,2> FMA (const double & a, SIMD<double,2> b, ...
function NETGEN_INLINE (line 293) | NETGEN_INLINE SIMD<double,2> FNMA (SIMD<double,2> a, SIMD<double,2> b,...
function NETGEN_INLINE (line 298) | NETGEN_INLINE SIMD<double,2> FNMA (const double & a, SIMD<double,2> b,...
function NETGEN_INLINE (line 306) | NETGEN_INLINE void FMAComplex (SIMD<double,2> a, SIMD<double,2> b, SIM...
function NETGEN_INLINE (line 312) | NETGEN_INLINE void FMAComplex (SIMD<double,4> a, SIMD<double,4> b, SIM...
function NETGEN_INLINE (line 323) | NETGEN_INLINE SIMD<double,2> operator+ (SIMD<double,2> a, SIMD<double,...
function NETGEN_INLINE (line 326) | NETGEN_INLINE SIMD<double,2> operator- (SIMD<double,2> a, SIMD<double,...
function NETGEN_INLINE (line 328) | NETGEN_INLINE SIMD<double,2> operator- (SIMD<double,2> a)
function NETGEN_INLINE (line 331) | NETGEN_INLINE SIMD<double,2> operator* (SIMD<double,2> a, SIMD<double,...
function NETGEN_INLINE (line 334) | NETGEN_INLINE SIMD<double,2> operator/ (SIMD<double,2> a, SIMD<double,...
function NETGEN_INLINE (line 337) | NETGEN_INLINE SIMD<double,2> sqrt (SIMD<double,2> x)
function NETGEN_INLINE (line 341) | NETGEN_INLINE SIMD<double,2> round (SIMD<double,2> x)
function NETGEN_INLINE (line 346) | NETGEN_INLINE SIMD<int64_t,2> lround (SIMD<double,2> x)
function NETGEN_INLINE (line 353) | NETGEN_INLINE SIMD<double,2> rsqrt (SIMD<double,2> x)
function NETGEN_INLINE (line 379) | NETGEN_INLINE SIMD<double,2> Reinterpret (SIMD<int64_t,2> a)
function NETGEN_INLINE (line 385) | NETGEN_INLINE SIMD<double,2> If (SIMD<mask64,2> a, SIMD<double,2> b, S...
function NETGEN_INLINE (line 391) | NETGEN_INLINE SIMD<int64_t,2> If (SIMD<mask64,2> a, SIMD<int64_t,2> b,...
function NETGEN_INLINE (line 398) | NETGEN_INLINE SIMD<mask64,2> operator&& (SIMD<mask64,2> a, SIMD<mask64...
FILE: libsrc/core/simd_avx.hpp
type ngcore (line 12) | namespace ngcore
function _mm256_set_m128i (line 18) | NETGEN_INLINE auto _mm256_set_m128i(__m128i v0, __m128i v1) {
function NETGEN_INLINE (line 24) | NETGEN_INLINE __m256i my_mm256_cmpeq_epi64 (__m256i a, __m256i b)
function NETGEN_INLINE (line 29) | NETGEN_INLINE __m256i my_mm256_cmpgt_epi64 (__m256i a, __m256i b)
function NETGEN_INLINE (line 34) | NETGEN_INLINE __m256i my_mm256_cvtepi32_epi64 (__m128i a)
function NETGEN_INLINE (line 40) | NETGEN_INLINE __m256i my_mm256_cmpeq_epi64 (__m256i a, __m256i b)
function NETGEN_INLINE (line 49) | NETGEN_INLINE __m256i my_mm256_cmpgt_epi64 (__m256i a, __m256i b)
function NETGEN_INLINE (line 58) | NETGEN_INLINE __m256i my_mm256_cvtepi32_epi64 (__m128i a)
class SIMD<mask64,4> (line 68) | class SIMD<mask64,4>
method SIMD (line 72) | SIMD (int64_t i)
method SIMD (line 76) | SIMD (__m256i _mask) : mask(_mask) { ; }
method SIMD (line 77) | SIMD (__m256d _mask) : mask(_mm256_castpd_si256(_mask)) { ; }
method __m256i (line 78) | __m256i Data() const { return mask; }
method Size (line 79) | static constexpr int Size() { return 4; }
function NETGEN_INLINE (line 94) | NETGEN_INLINE SIMD<mask64, 4> SIMD<mask64, 4> :: GetMaskFromBits (unsi...
class SIMD<int64_t,4> (line 100) | class alignas(32) SIMD<int64_t,4>
method Size (line 105) | static constexpr int Size() { return 4; }
method SIMD (line 106) | SIMD () {}
method SIMD (line 107) | SIMD (const SIMD &) = default;
method SIMD (line 108) | SIMD & operator= (const SIMD &) = default;
method SIMD (line 110) | SIMD (int64_t val) { data = _mm256_set1_epi64x(val); }
method SIMD (line 111) | SIMD (int64_t v0, int64_t v1, int64_t v2, int64_t v3) { data = _mm25...
method SIMD (line 112) | SIMD (std::array<int64_t,4> a)
method SIMD (line 115) | SIMD (SIMD<int64_t,2> v0, SIMD<int64_t,2> v1)
method SIMD (line 118) | SIMD (__m256i _data) { data = _data; }
method NETGEN_INLINE (line 121) | NETGEN_INLINE __m256i Data() const { return data; }
method NETGEN_INLINE (line 122) | NETGEN_INLINE __m256i & Data() { return data; }
method Lo (line 124) | SIMD<int64_t,2> Lo() const { return _mm256_extractf128_si256(data, 0...
method Hi (line 125) | SIMD<int64_t,2> Hi() const { return _mm256_extractf128_si256(data, 1...
method SIMD (line 126) | static SIMD FirstInt(int n0=0) { return { n0+0, n0+1, n0+2, n0+3 }; }
method Get (line 129) | double Get() const
function NETGEN_INLINE (line 137) | NETGEN_INLINE SIMD<int64_t,4> operator-(SIMD<int64_t,4> a) { return _m...
function NETGEN_INLINE (line 140) | NETGEN_INLINE SIMD<int64_t,4> operator+ (SIMD<int64_t,4> a, SIMD<int64...
function NETGEN_INLINE (line 141) | NETGEN_INLINE SIMD<int64_t,4> operator- (SIMD<int64_t,4> a, SIMD<int64...
function NETGEN_INLINE (line 142) | NETGEN_INLINE SIMD<int64_t,4> operator& (SIMD<int64_t,4> a, SIMD<int64...
class SIMD<double,4> (line 150) | class alignas(32) SIMD<double,4>
method Size (line 155) | static constexpr int Size() { return 4; }
method SIMD (line 156) | SIMD () {}
method SIMD (line 157) | SIMD (const SIMD &) = default;
method SIMD (line 158) | SIMD & operator= (const SIMD &) = default;
method SIMD (line 160) | SIMD (double val) { data = _mm256_set1_pd(val); }
method SIMD (line 161) | SIMD (int val) { data = _mm256_set1_pd(val); }
method SIMD (line 162) | SIMD (size_t val) { data = _mm256_set1_pd(val); }
method SIMD (line 163) | SIMD (double v0, double v1, double v2, double v3) { data = _mm256_se...
method SIMD (line 164) | SIMD (SIMD<double,2> v0, SIMD<double,2> v1) : SIMD(v0[0], v0[1], v1[...
method SIMD (line 165) | SIMD (double const * p) { data = _mm256_loadu_pd(p); }
method SIMD (line 166) | SIMD (double const * p, SIMD<mask64,4> mask) { data = _mm256_maskloa...
method SIMD (line 167) | SIMD (__m256d _data) { data = _data; }
method SIMD (line 168) | SIMD (std::array<double,4> a)
method Store (line 172) | void Store (double * p) { _mm256_storeu_pd(p, data); }
method Store (line 173) | void Store (double * p, SIMD<mask64,4> mask) { _mm256_maskstore_pd(p...
method SIMD (line 176) | SIMD (const T & func)
method NETGEN_INLINE (line 181) | NETGEN_INLINE double operator[] (int i) const { return ((double*)(&d...
method NETGEN_INLINE (line 182) | NETGEN_INLINE double & operator[] (int i) { return ((double*)(&data)...
method NETGEN_INLINE (line 185) | NETGEN_INLINE __m256d Data() const { return data; }
method NETGEN_INLINE (line 186) | NETGEN_INLINE __m256d & Data() { return data; }
method Lo (line 188) | SIMD<double,2> Lo() const { return _mm256_extractf128_pd(data, 0); }
method Hi (line 189) | SIMD<double,2> Hi() const { return _mm256_extractf128_pd(data, 1); }
method Get (line 195) | double Get() const
function Unpack (line 202) | NETGEN_INLINE auto Unpack (SIMD<double,4> a, SIMD<double,4> b)
function NETGEN_INLINE (line 208) | NETGEN_INLINE SIMD<double,4> operator- (SIMD<double,4> a) { return _mm...
function NETGEN_INLINE (line 209) | NETGEN_INLINE SIMD<double,4> operator+ (SIMD<double,4> a, SIMD<double,...
function NETGEN_INLINE (line 210) | NETGEN_INLINE SIMD<double,4> operator- (SIMD<double,4> a, SIMD<double,...
function NETGEN_INLINE (line 211) | NETGEN_INLINE SIMD<double,4> operator* (SIMD<double,4> a, SIMD<double,...
function NETGEN_INLINE (line 212) | NETGEN_INLINE SIMD<double,4> operator/ (SIMD<double,4> a, SIMD<double,...
function NETGEN_INLINE (line 213) | NETGEN_INLINE SIMD<double,4> operator* (double a, SIMD<double,4> b) { ...
function NETGEN_INLINE (line 214) | NETGEN_INLINE SIMD<double,4> operator* (SIMD<double,4> b, double a) { ...
function NETGEN_INLINE (line 216) | NETGEN_INLINE SIMD<double,4> sqrt (SIMD<double,4> a) { return _mm256_s...
function NETGEN_INLINE (line 217) | NETGEN_INLINE SIMD<double,4> floor (SIMD<double,4> a) { return _mm256_...
function NETGEN_INLINE (line 218) | NETGEN_INLINE SIMD<double,4> ceil (SIMD<double,4> a) { return _mm256_c...
function NETGEN_INLINE (line 219) | NETGEN_INLINE SIMD<double,4> fabs (SIMD<double,4> a) { return _mm256_m...
function NETGEN_INLINE (line 220) | NETGEN_INLINE SIMD<double,4> round(SIMD<double,4> a) { return _mm256_r...
function NETGEN_INLINE (line 221) | NETGEN_INLINE SIMD<int64_t,4> lround (SIMD<double,4> a)
function NETGEN_INLINE (line 227) | NETGEN_INLINE SIMD<double,4> FMA (SIMD<double,4> a, SIMD<double,4> b, ...
function NETGEN_INLINE (line 231) | NETGEN_INLINE SIMD<double,4> FMA (const double & a, SIMD<double,4> b, ...
function NETGEN_INLINE (line 235) | NETGEN_INLINE SIMD<double,4> FNMA (SIMD<double,4> a, SIMD<double,4> b,...
function NETGEN_INLINE (line 239) | NETGEN_INLINE SIMD<double,4> FNMA (const double & a, SIMD<double,4> b,...
function NETGEN_INLINE (line 249) | NETGEN_INLINE void FMAasm (SIMD<double,4> a, SIMD<double,4> b, SIMD<do...
function NETGEN_INLINE (line 257) | NETGEN_INLINE void FNMAasm (SIMD<double,4> a, SIMD<double,4> b, SIMD<d...
function NETGEN_INLINE (line 267) | NETGEN_INLINE SIMD<double,4> FMAddSub (SIMD<double,4> a, SIMD<double,4...
function NETGEN_INLINE (line 273) | NETGEN_INLINE SIMD<double,4> SwapPairs (SIMD<double,4> a)
function NETGEN_INLINE (line 279) | NETGEN_INLINE SIMD<mask64,4> operator<= (SIMD<double,4> a , SIMD<doubl...
function NETGEN_INLINE (line 281) | NETGEN_INLINE SIMD<mask64,4> operator< (SIMD<double,4> a , SIMD<double...
function NETGEN_INLINE (line 283) | NETGEN_INLINE SIMD<mask64,4> operator>= (SIMD<double,4> a , SIMD<doubl...
function NETGEN_INLINE (line 285) | NETGEN_INLINE SIMD<mask64,4> operator> (SIMD<double,4> a , SIMD<double...
function NETGEN_INLINE (line 287) | NETGEN_INLINE SIMD<mask64,4> operator== (SIMD<double,4> a , SIMD<doubl...
function NETGEN_INLINE (line 289) | NETGEN_INLINE SIMD<mask64,4> operator!= (SIMD<double,4> a , SIMD<doubl...
function NETGEN_INLINE (line 292) | NETGEN_INLINE SIMD<mask64,4> operator<= (SIMD<int64_t,4> a , SIMD<int6...
function NETGEN_INLINE (line 294) | NETGEN_INLINE SIMD<mask64,4> operator< (SIMD<int64_t,4> a , SIMD<int64...
function NETGEN_INLINE (line 296) | NETGEN_INLINE SIMD<mask64,4> operator>= (SIMD<int64_t,4> a , SIMD<int6...
function NETGEN_INLINE (line 298) | NETGEN_INLINE SIMD<mask64,4> operator> (SIMD<int64_t,4> a , SIMD<int64...
function NETGEN_INLINE (line 300) | NETGEN_INLINE SIMD<mask64,4> operator== (SIMD<int64_t,4> a , SIMD<int6...
function NETGEN_INLINE (line 302) | NETGEN_INLINE SIMD<mask64,4> operator!= (SIMD<int64_t,4> a , SIMD<int6...
function NETGEN_INLINE (line 306) | NETGEN_INLINE SIMD<mask64,4> operator&& (SIMD<mask64,4> a, SIMD<mask64...
function NETGEN_INLINE (line 308) | NETGEN_INLINE SIMD<mask64,4> operator|| (SIMD<mask64,4> a, SIMD<mask64...
function NETGEN_INLINE (line 310) | NETGEN_INLINE SIMD<mask64,4> operator! (SIMD<mask64,4> a)
function NETGEN_INLINE (line 313) | NETGEN_INLINE SIMD<mask64,4> operator&& (SIMD<mask64,4> a, SIMD<mask64...
function NETGEN_INLINE (line 315) | NETGEN_INLINE SIMD<mask64,4> operator|| (SIMD<mask64,4> a, SIMD<mask64...
function NETGEN_INLINE (line 317) | NETGEN_INLINE SIMD<mask64,4> operator! (SIMD<mask64,4> a)
function NETGEN_INLINE (line 322) | NETGEN_INLINE SIMD<double,4> Reinterpret (SIMD<int64_t,4> a)
function NETGEN_INLINE (line 329) | NETGEN_INLINE SIMD<double,4> If (SIMD<mask64,4> a, SIMD<double,4> b, S...
function NETGEN_INLINE (line 332) | NETGEN_INLINE SIMD<double,4> IfPos (SIMD<double,4> a, SIMD<double,4> b...
function NETGEN_INLINE (line 338) | NETGEN_INLINE SIMD<double,4> IfZero (SIMD<double,4> a, SIMD<double,4> ...
function NETGEN_INLINE (line 344) | NETGEN_INLINE double HSum (SIMD<double,4> sd)
function HSum (line 351) | NETGEN_INLINE auto HSum (SIMD<double,4> sd1, SIMD<double,4> sd2)
function HSum (line 358) | NETGEN_INLINE auto HSum (SIMD<double,4> v1, SIMD<double,4> v2, SIMD<do...
function NETGEN_INLINE (line 385) | NETGEN_INLINE SIMD<int64_t,4> If (SIMD<mask64,4> a, SIMD<int64_t,4> b,...
FILE: libsrc/core/simd_avx512.hpp
type ngcore (line 12) | namespace ngcore
class SIMD<mask64,8> (line 16) | class SIMD<mask64,8>
method SIMD (line 20) | SIMD (size_t i)
method SIMD (line 24) | SIMD (int i)
method SIMD (line 28) | SIMD (int64_t i)
method SIMD (line 32) | SIMD (__mmask8 _mask) : mask(_mask) { ; }
method __mmask8 (line 33) | __mmask8 Data() const { return mask; }
method Size (line 34) | static constexpr int Size() { return 8; }
method GetMaskFromBits (line 35) | GetMaskFromBits (unsigned int i)
class SIMD<int64_t,8> (line 42) | class alignas(64) SIMD<int64_t,8>
method Size (line 47) | static constexpr int Size() { return 8; }
method SIMD (line 48) | SIMD () {}
method SIMD (line 49) | SIMD (const SIMD &) = default;
method SIMD (line 50) | SIMD & operator= (const SIMD &) = default;
method SIMD (line 52) | SIMD (int64_t val) { data = _mm512_set1_epi64(val); }
method SIMD (line 53) | SIMD (int64_t v0, int64_t v1, int64_t v2, int64_t v3, int64_t v4, in...
method SIMD (line 54) | SIMD (__m512i _data) { data = _data; }
method SIMD (line 57) | SIMD (const T & func)
method SIMD (line 62) | SIMD (SIMD<int64_t,4> v0, SIMD<int64_t,4> v1)
method Lo (line 68) | SIMD<int64_t,4> Lo() const { return _mm512_castsi512_si256(data); }
method Hi (line 69) | SIMD<int64_t,4> Hi() const { return _mm512_extracti64x4_epi64(data, ...
method NETGEN_INLINE (line 74) | NETGEN_INLINE __m512i Data() const { return data; }
method NETGEN_INLINE (line 75) | NETGEN_INLINE __m512i & Data() { return data; }
method SIMD (line 76) | static SIMD FirstInt() { return { 0, 1, 2, 3, 4, 5, 6, 7 }; }
function NETGEN_INLINE (line 79) | NETGEN_INLINE SIMD<int64_t,8> operator-(SIMD<int64_t,8> a) { return _m...
function NETGEN_INLINE (line 81) | NETGEN_INLINE SIMD<int64_t,8> operator+ (SIMD<int64_t,8> a, SIMD<int64...
function NETGEN_INLINE (line 82) | NETGEN_INLINE SIMD<int64_t,8> operator- (SIMD<int64_t,8> a, SIMD<int64...
function NETGEN_INLINE (line 84) | NETGEN_INLINE SIMD<int64_t,8> If (SIMD<mask64,8> a, SIMD<int64_t,8> b,...
class SIMD<double,8> (line 89) | class alignas(64) SIMD<double,8>
method Size (line 93) | static constexpr int Size() { return 8; }
method SIMD (line 94) | SIMD () {}
method SIMD (line 95) | SIMD (const SIMD &) = default;
method SIMD (line 96) | SIMD & operator= (const SIMD &) = default;
method SIMD (line 98) | SIMD (double val) { data = _mm512_set1_pd(val); }
method SIMD (line 99) | SIMD (int val) { data = _mm512_set1_pd(val); }
method SIMD (line 100) | SIMD (size_t val) { data = _mm512_set1_pd(val); }
method SIMD (line 101) | SIMD (double const * p) { data = _mm512_loadu_pd(p); }
method SIMD (line 102) | SIMD (double const * p, SIMD<mask64,8> mask)
method SIMD (line 104) | SIMD (__m512d _data) { data = _data; }
method SIMD (line 105) | SIMD (SIMD<double,4> v0, SIMD<double,4> v1)
method SIMD (line 108) | SIMD (SIMD<double,6> v0, SIMD<double,2> v1)
method SIMD (line 113) | SIMD (const T & func)
method Store (line 118) | void Store (double * p) { _mm512_storeu_pd(p, data); }
method Store (line 119) | void Store (double * p, SIMD<mask64,8> mask) { _mm512_mask_storeu_pd...
method SIMD_function (line 122) | void SIMD_function (const Function & func, std::true_type)
method SIMD_function (line 129) | void SIMD_function (double const * p, std::false_type)
method SIMD_function (line 134) | void SIMD_function (double val, std::false_type)
method SIMD_function (line 139) | void SIMD_function (__m512d _data, std::false_type)
method NETGEN_INLINE (line 144) | NETGEN_INLINE double operator[] (int i) const { return ((double*)(&d...
method NETGEN_INLINE (line 145) | NETGEN_INLINE double & operator[] (int i) { return ((double*)(&data)...
method NETGEN_INLINE (line 146) | NETGEN_INLINE __m512d Data() const { return data; }
method NETGEN_INLINE (line 147) | NETGEN_INLINE __m512d & Data() { return data; }
method Lo (line 149) | SIMD<double,4> Lo() const { return _mm512_extractf64x4_pd(data, 0); }
method Hi (line 150) | SIMD<double,4> Hi() const { return _mm512_extractf64x4_pd(data, 1); }
method Get (line 153) | double Get() const
function NETGEN_INLINE (line 160) | NETGEN_INLINE SIMD<double,8> operator- (SIMD<double,8> a) { return _mm...
function NETGEN_INLINE (line 161) | NETGEN_INLINE SIMD<double,8> operator+ (SIMD<double,8> a, SIMD<double,...
function NETGEN_INLINE (line 162) | NETGEN_INLINE SIMD<double,8> operator- (SIMD<double,8> a, SIMD<double,...
function NETGEN_INLINE (line 163) | NETGEN_INLINE SIMD<double,8> operator* (SIMD<double,8> a, SIMD<double,...
function NETGEN_INLINE (line 164) | NETGEN_INLINE SIMD<double,8> operator/ (SIMD<double,8> a, SIMD<double,...
function NETGEN_INLINE (line 165) | NETGEN_INLINE SIMD<double,8> operator* (double a, SIMD<double,8> b) { ...
function NETGEN_INLINE (line 166) | NETGEN_INLINE SIMD<double,8> operator* (SIMD<double,8> b, double a) { ...
function NETGEN_INLINE (line 168) | NETGEN_INLINE SIMD<double,8> sqrt (SIMD<double,8> a) { return _mm512_s...
function NETGEN_INLINE (line 169) | NETGEN_INLINE SIMD<double,8> floor (SIMD<double,8> a) { return _mm512_...
function NETGEN_INLINE (line 170) | NETGEN_INLINE SIMD<double,8> ceil (SIMD<double,8> a) { return _mm512_c...
function NETGEN_INLINE (line 171) | NETGEN_INLINE SIMD<double,8> fabs (SIMD<double,8> a) { return _mm512_m...
function NETGEN_INLINE (line 173) | NETGEN_INLINE SIMD<mask64,8> operator<= (SIMD<double,8> a , SIMD<doubl...
function NETGEN_INLINE (line 175) | NETGEN_INLINE SIMD<mask64,8> operator< (SIMD<double,8> a , SIMD<double...
function NETGEN_INLINE (line 177) | NETGEN_INLINE SIMD<mask64,8> operator>= (SIMD<double,8> a , SIMD<doubl...
function NETGEN_INLINE (line 179) | NETGEN_INLINE SIMD<mask64,8> operator> (SIMD<double,8> a , SIMD<double...
function NETGEN_INLINE (line 181) | NETGEN_INLINE SIMD<mask64,8> operator== (SIMD<double,8> a , SIMD<doubl...
function NETGEN_INLINE (line 183) | NETGEN_INLINE SIMD<mask64,8> operator!= (SIMD<double,8> a , SIMD<doubl...
function NETGEN_INLINE (line 186) | NETGEN_INLINE SIMD<mask64,8> operator<= (SIMD<int64_t,8> a , SIMD<int6...
function NETGEN_INLINE (line 188) | NETGEN_INLINE SIMD<mask64,8> operator< (SIMD<int64_t,8> a , SIMD<int64...
function NETGEN_INLINE (line 190) | NETGEN_INLINE SIMD<mask64,8> operator>= (SIMD<int64_t,8> a , SIMD<int6...
function NETGEN_INLINE (line 192) | NETGEN_INLINE SIMD<mask64,8> operator> (SIMD<int64_t,8> a , SIMD<int64...
function NETGEN_INLINE (line 194) | NETGEN_INLINE SIMD<mask64,8> operator== (SIMD<int64_t,8> a , SIMD<int6...
function NETGEN_INLINE (line 196) | NETGEN_INLINE SIMD<mask64,8> operator!= (SIMD<int64_t,8> a , SIMD<int6...
function NETGEN_INLINE (line 199) | NETGEN_INLINE SIMD<mask64,8> operator&& (SIMD<mask64,8> a, SIMD<mask64...
function NETGEN_INLINE (line 201) | NETGEN_INLINE SIMD<mask64,8> operator|| (SIMD<mask64,8> a, SIMD<mask64...
function NETGEN_INLINE (line 203) | NETGEN_INLINE SIMD<mask64,8> operator! (SIMD<mask64,8> a)
function NETGEN_INLINE (line 206) | NETGEN_INLINE SIMD<double,8> If (SIMD<mask64,8> a, SIMD<double,8> b, S...
function NETGEN_INLINE (line 209) | NETGEN_INLINE SIMD<double,8> IfPos (SIMD<double,8> a, SIMD<double> b, ...
function NETGEN_INLINE (line 214) | NETGEN_INLINE SIMD<double,8> IfZero (SIMD<double,8> a, SIMD<double,8> ...
function Unpack (line 221) | NETGEN_INLINE auto Unpack (SIMD<double,8> a, SIMD<double,8> b)
function NETGEN_INLINE (line 228) | NETGEN_INLINE double HSum (SIMD<double,8> sd)
function HSum (line 235) | NETGEN_INLINE auto HSum (SIMD<double,8> sd1, SIMD<double,8> sd2)
function NETGEN_INLINE (line 240) | NETGEN_INLINE SIMD<double,4> HSum (SIMD<double,8> v1, SIMD<double,8> v...
function NETGEN_INLINE (line 255) | NETGEN_INLINE SIMD<double,8> FMA (SIMD<double,8> a, SIMD<double,8> b, ...
function NETGEN_INLINE (line 259) | NETGEN_INLINE SIMD<double,8> FMA (const double & a, SIMD<double,8> b, ...
function NETGEN_INLINE (line 264) | NETGEN_INLINE SIMD<double,8> FNMA (SIMD<double,8> a, SIMD<double,8> b,...
function NETGEN_INLINE (line 268) | NETGEN_INLINE SIMD<double,8> FNMA (const double & a, SIMD<double,8> b,...
function NETGEN_INLINE (line 273) | NETGEN_INLINE SIMD<double,8> FMAddSub (SIMD<double,8> a, SIMD<double,8...
function NETGEN_INLINE (line 278) | NETGEN_INLINE SIMD<double,8> SwapPairs (SIMD<double,8> a)
FILE: libsrc/core/simd_generic.hpp
type ngcore (line 17) | namespace ngcore
function GetDefaultSIMDSize (line 27) | constexpr int GetDefaultSIMDSize() {
function IsNativeSIMDSize (line 31) | constexpr bool IsNativeSIMDSize(int n) {
function GetLargestNativeSIMDPart (line 44) | constexpr int GetLargestNativeSIMDPart(int n) {
function LargestPowerOfTwo (line 51) | constexpr size_t LargestPowerOfTwo (size_t x)
class SIMD (line 59) | class SIMD
class mask64 (line 61) | class mask64
type detail (line 64) | namespace detail {
function array_range_impl (line 66) | auto array_range_impl(std::array<T, N> const& arr,
function array_range (line 74) | auto array_range(std::array<T, N> const& arr, size_t first) {
class SIMD<mask64,1> (line 84) | class SIMD<mask64,1>
method SIMD (line 88) | SIMD (int64_t i)
method Data (line 90) | bool Data() const { return mask; }
method Size (line 91) | static constexpr int Size() { return 1; }
class SIMD<mask64,N> (line 97) | class alignas(GetLargestNativeSIMDPart(N)*sizeof(int64_t)) SIMD<mask64,N>
method SIMD (line 107) | SIMD (int64_t i) : lo(i), hi(i-N1 ) { ; }
method SIMD (line 108) | SIMD (SIMD<mask64,N1> lo_, SIMD<mask64,N2> hi_) : lo(lo_), hi(hi_) {...
method Lo (line 109) | SIMD<mask64,N1> Lo() const { return lo; }
method Hi (line 110) | SIMD<mask64,N2> Hi() const { return hi; }
method Size (line 111) | static constexpr int Size() { return N; }
function NETGEN_INLINE (line 115) | NETGEN_INLINE SIMD<mask64,N> operator&& (SIMD<mask64,N> a, SIMD<mask64...
class SIMD<int32_t,1> (line 126) | class SIMD<int32_t,1>
method Size (line 131) | static constexpr int Size() { return 1; }
method SIMD (line 132) | SIMD () {}
method SIMD (line 133) | SIMD (const SIMD &) = default;
method SIMD (line 134) | SIMD & operator= (const SIMD &) = default;
method SIMD (line 136) | SIMD (int32_t val) : data{val} {}
method SIMD (line 137) | SIMD (size_t val) : data(val) {}
method SIMD (line 138) | explicit SIMD (std::array<int32_t, 1> arr) : data{arr[0]} {}
method Data (line 143) | auto Data() const { return data; }
method SIMD (line 144) | static SIMD FirstInt(int32_t n0=0) { return {n0}; }
method Get (line 146) | int32_t Get()
class SIMD<int32_t,N> (line 154) | class alignas(GetLargestNativeSIMDPart(N)*sizeof(int64_t)) SIMD<int32_...
method Size (line 164) | static constexpr int Size() { return N; }
method SIMD (line 166) | SIMD () {}
method SIMD (line 167) | SIMD (const SIMD &) = default;
method SIMD (line 168) | SIMD & operator= (const SIMD &) = default;
method SIMD (line 171) | SIMD (int32_t val) : lo{val}, high{val} { ; }
method SIMD (line 172) | SIMD (size_t val) : lo{val}, high{val} { ; }
method SIMD (line 173) | SIMD (int32_t * p) : lo{p}, high{p+N1} { ; }
method SIMD (line 175) | SIMD (SIMD<int32_t,N1> lo_, SIMD<int32_t,N2> high_) : lo(lo_), high(...
method SIMD (line 177) | explicit SIMD( std::array<int32_t, N> arr )
method SIMD (line 184) | explicit SIMD(const T... vals)
method SIMD (line 193) | SIMD (const T & func)
method Lo (line 201) | auto Lo() const { return lo; }
method Hi (line 202) | auto Hi() const { return high; }
method Store (line 206) | void Store (int32_t * p) { lo.Store(p); high.Store(p+N1); }
method SIMD (line 217) | static SIMD FirstInt(int32_t n0=0) { return {SIMD<int32_t,N1>::First...
method Get (line 219) | int32_t Get()
class SIMD<int64_t,1> (line 233) | class SIMD<int64_t,1>
method Size (line 238) | static constexpr int Size() { return 1; }
method SIMD (line 239) | SIMD () {}
method SIMD (line 240) | SIMD (const SIMD &) = default;
method SIMD (line 241) | SIMD & operator= (const SIMD &) = default;
method SIMD (line 242) | SIMD (int val) : data{val} {}
method SIMD (line 243) | SIMD (int64_t val) : data{val} {}
method SIMD (line 244) | SIMD (size_t val) : data(val) {}
method SIMD (line 245) | explicit SIMD (std::array<int64_t, 1> arr)
method Data (line 250) | auto Data() const { return data; }
method SIMD (line 251) | static SIMD FirstInt(int64_t n0=0) { return {n0}; }
method Get (line 253) | int64_t Get()
class SIMD<int64_t,N> (line 261) | class alignas(GetLargestNativeSIMDPart(N)*sizeof(int64_t)) SIMD<int64_...
method Size (line 271) | static constexpr int Size() { return N; }
method SIMD (line 273) | SIMD () {}
method SIMD (line 274) | SIMD (const SIMD &) = default;
method SIMD (line 275) | SIMD & operator= (const SIMD &) = default;
method SIMD (line 277) | SIMD (int val) : lo{val}, high{val} { ; }
method SIMD (line 278) | SIMD (int64_t val) : lo{val}, high{val} { ; }
method SIMD (line 279) | SIMD (size_t val) : lo{val}, high{val} { ; }
method SIMD (line 280) | SIMD (SIMD<int64_t,N1> lo_, SIMD<int64_t,N2> high_) : lo(lo_), high(...
method SIMD (line 282) | explicit SIMD( std::array<int64_t, N> arr )
method SIMD (line 288) | explicit SIMD(const T... vals)
method SIMD (line 297) | SIMD (const T & func)
method Lo (line 305) | auto Lo() const { return lo; }
method Hi (line 306) | auto Hi() const { return high; }
method SIMD (line 318) | static SIMD FirstInt(int64_t n0=0) { return {SIMD<int64_t,N1>::First...
method Get (line 320) | int64_t Get()
class SIMD<double,1> (line 334) | class SIMD<double,1>
method Size (line 339) | static constexpr int Size() { return 1; }
method SIMD (line 340) | SIMD () {}
method SIMD (line 341) | SIMD (const SIMD &) = default;
method SIMD (line 342) | SIMD & operator= (const SIMD &) = default;
method SIMD (line 343) | SIMD (double val) { data = val; }
method SIMD (line 344) | SIMD (int val) { data = val; }
method SIMD (line 345) | SIMD (size_t val) { data = val; }
method SIMD (line 346) | SIMD (double const * p) { data = *p; }
method SIMD (line 347) | SIMD (double const * p, SIMD<mask64,1> mask) { data = mask.Data() ? ...
method SIMD (line 348) | explicit SIMD (std::array<double, 1> arr)
method SIMD (line 353) | SIMD (const T & func)
method SIMD (line 359) | SIMD & operator= (const T & func)
method Store (line 365) | void Store (double * p) { *p = data; }
method Store (line 366) | void Store (double * p, SIMD<mask64,1> mask) { if (mask.Data()) *p =...
method Data (line 369) | double Data() const { return data; }
method Get (line 371) | double Get()
class SIMD<double, N> (line 380) | class alignas(GetLargestNativeSIMDPart(N)*sizeof(double)) SIMD<double, N>
method Size (line 390) | static constexpr int Size() { return N; }
method SIMD (line 391) | SIMD () {}
method SIMD (line 392) | SIMD (const SIMD &) = default;
method SIMD (line 393) | SIMD (SIMD<double,N1> lo_, SIMD<double,N2> hi_) : lo(lo_), high(hi_)...
method SIMD (line 396) | SIMD (const T & func)
method SIMD (line 404) | SIMD & operator= (const T & func)
method SIMD (line 413) | SIMD & operator= (const SIMD &) = default;
method SIMD (line 415) | SIMD (double val) : lo{val}, high{val} { ; }
method SIMD (line 416) | SIMD (int val) : lo{val}, high{val} { ; }
method SIMD (line 417) | SIMD (size_t val) : lo{val}, high{val} { ; }
method SIMD (line 419) | SIMD (double const * p) : lo{p}, high{p+N1} { ; }
method SIMD (line 420) | SIMD (double const * p, SIMD<mask64,N> mask)
method SIMD (line 423) | SIMD (double * p) : lo{p}, high{p+N1} { ; }
method SIMD (line 424) | SIMD (double * p, SIMD<mask64,N> mask)
method SIMD (line 428) | explicit SIMD( std::array<double, N> arr )
method SIMD (line 434) | explicit SIMD(const T... vals)
method Store (line 441) | void Store (double * p) { lo.Store(p); high.Store(p+N1); }
method Store (line 442) | void Store (double * p, SIMD<mask64,N> mask)
method Lo (line 448) | NETGEN_INLINE auto Lo() const { return lo; }
method Hi (line 449) | NETGEN_INLINE auto Hi() const { return high; }
method Get (line 465) | double Get()
method Data (line 471) | auto Data() const { return *this; }
function NETGEN_INLINE (line 477) | NETGEN_INLINE SIMD<T,N> operator+ (SIMD<T,N> a, SIMD<T,N> b) {
function NETGEN_INLINE (line 483) | NETGEN_INLINE SIMD<T,N> operator- (SIMD<T,N> a, SIMD<T,N> b) {
function NETGEN_INLINE (line 488) | NETGEN_INLINE SIMD<T,N> operator- (SIMD<T,N> a) {
function NETGEN_INLINE (line 494) | NETGEN_INLINE SIMD<T,N> operator* (SIMD<T,N> a, SIMD<T,N> b) {
function NETGEN_INLINE (line 500) | NETGEN_INLINE SIMD<T,N> operator/ (SIMD<T,N> a, SIMD<T,N> b) {
function NETGEN_INLINE (line 506) | NETGEN_INLINE SIMD<mask64,N> operator< (SIMD<T,N> a, SIMD<T,N> b)
function NETGEN_INLINE (line 513) | NETGEN_INLINE SIMD<mask64,N> operator<= (SIMD<T,N> a, SIMD<T,N> b)
function NETGEN_INLINE (line 520) | NETGEN_INLINE SIMD<mask64,N> operator> (SIMD<T,N> a, SIMD<T,N> b)
function NETGEN_INLINE (line 527) | NETGEN_INLINE SIMD<mask64,N> operator>= (SIMD<T,N> a, SIMD<T,N> b)
function NETGEN_INLINE (line 534) | NETGEN_INLINE SIMD<mask64,N> operator== (SIMD<T,N> a, SIMD<T,N> b)
function NETGEN_INLINE (line 541) | NETGEN_INLINE SIMD<mask64,N> operator!= (SIMD<T,N> a, SIMD<T,N> b)
function NETGEN_INLINE (line 548) | NETGEN_INLINE SIMD<int64_t,N> operator& (SIMD<int64_t,N> a, SIMD<int64...
function NETGEN_INLINE (line 554) | NETGEN_INLINE SIMD<int64_t,N> operator| (SIMD<int64_t,N> a, SIMD<int64...
function NETGEN_INLINE (line 563) | NETGEN_INLINE SIMD<int64_t,N> operator+ (SIMD<int64_t,N> a, int64_t b)...
function NETGEN_INLINE (line 565) | NETGEN_INLINE SIMD<int64_t,N> operator+ (int64_t a, SIMD<int64_t,N> b)...
function NETGEN_INLINE (line 567) | NETGEN_INLINE SIMD<int64_t,N> operator- (int64_t a, SIMD<int64_t,N> b)...
function NETGEN_INLINE (line 569) | NETGEN_INLINE SIMD<int64_t,N> operator- (SIMD<int64_t,N> a, int64_t b)...
function NETGEN_INLINE (line 571) | NETGEN_INLINE SIMD<int64_t,N> operator* (int64_t a, SIMD<int64_t,N> b)...
function NETGEN_INLINE (line 573) | NETGEN_INLINE SIMD<int64_t,N> operator* (SIMD<int64_t,N> b, int64_t a)...
function NETGEN_INLINE (line 575) | NETGEN_INLINE SIMD<int64_t,N> operator/ (SIMD<int64_t,N> a, int64_t b)...
function NETGEN_INLINE (line 577) | NETGEN_INLINE SIMD<int64_t,N> operator/ (int64_t a, SIMD<int64_t,N> b)...
function NETGEN_INLINE (line 579) | NETGEN_INLINE SIMD<int64_t,N> & operator+= (SIMD<int64_t,N> & a, SIMD<...
function NETGEN_INLINE (line 581) | NETGEN_INLINE SIMD<int64_t,N> & operator+= (SIMD<int64_t,N> & a, int64...
function NETGEN_INLINE (line 583) | NETGEN_INLINE SIMD<int64_t,N> & operator-= (SIMD<int64_t,N> & a, SIMD<...
function NETGEN_INLINE (line 585) | NETGEN_INLINE SIMD<int64_t,N> & operator-= (SIMD<int64_t,N> & a, int64...
function NETGEN_INLINE (line 587) | NETGEN_INLINE SIMD<int64_t,N> & operator*= (SIMD<int64_t,N> & a, SIMD<...
function NETGEN_INLINE (line 589) | NETGEN_INLINE SIMD<int64_t,N> & operator*= (SIMD<int64_t,N> & a, int64...
function NETGEN_INLINE (line 591) | NETGEN_INLINE SIMD<int64_t,N> & operator/= (SIMD<int64_t,N> & a, SIMD<...
function NETGEN_INLINE (line 596) | NETGEN_INLINE SIMD<double,N> operator+ (SIMD<double,N> a, double b) { ...
function NETGEN_INLINE (line 598) | NETGEN_INLINE SIMD<double,N> operator+ (double a, SIMD<double,N> b) { ...
function NETGEN_INLINE (line 600) | NETGEN_INLINE SIMD<double,N> operator- (double a, SIMD<double,N> b) { ...
function NETGEN_INLINE (line 602) | NETGEN_INLINE SIMD<double,N> operator- (SIMD<double,N> a, double b) { ...
function NETGEN_INLINE (line 604) | NETGEN_INLINE SIMD<double,N> operator* (double a, SIMD<double,N> b) { ...
function NETGEN_INLINE (line 606) | NETGEN_INLINE SIMD<double,N> operator* (SIMD<double,N> b, double a) { ...
function NETGEN_INLINE (line 608) | NETGEN_INLINE SIMD<double,N> operator/ (SIMD<double,N> a, double b) { ...
function NETGEN_INLINE (line 610) | NETGEN_INLINE SIMD<double,N> operator/ (double a, SIMD<double,N> b) { ...
function NETGEN_INLINE (line 612) | NETGEN_INLINE SIMD<double,N> & operator+= (SIMD<double,N> & a, SIMD<do...
function NETGEN_INLINE (line 614) | NETGEN_INLINE SIMD<double,N> & operator+= (SIMD<double,N> & a, double ...
function NETGEN_INLINE (line 616) | NETGEN_INLINE SIMD<double,N> & operator-= (SIMD<double,N> & a, SIMD<do...
function NETGEN_INLINE (line 618) | NETGEN_INLINE SIMD<double,N> & operator-= (SIMD<double,N> & a, double ...
function NETGEN_INLINE (line 620) | NETGEN_INLINE SIMD<double,N> & operator*= (SIMD<double,N> & a, SIMD<do...
function NETGEN_INLINE (line 622) | NETGEN_INLINE SIMD<double,N> & operator*= (SIMD<double,N> & a, double ...
function NETGEN_INLINE (line 624) | NETGEN_INLINE SIMD<double,N> & operator/= (SIMD<double,N> & a, SIMD<do...
function NETGEN_INLINE (line 633) | NETGEN_INLINE SIMD<double,N> L2Norm2 (SIMD<double,N> a) { return a*a; }
function NETGEN_INLINE (line 635) | NETGEN_INLINE SIMD<double,N> Trans (SIMD<double,N> a) { return a; }
function NETGEN_INLINE (line 638) | NETGEN_INLINE double HSum (SIMD<double,N> a)
function NETGEN_INLINE (line 648) | NETGEN_INLINE SIMD<T,N> IfPos (SIMD<T,N> a, SIMD<T,N> b, SIMD<T,N> c)
function NETGEN_INLINE (line 656) | NETGEN_INLINE SIMD<T,N> IfZero (SIMD<T,N> a, SIMD<T,N> b, SIMD<T,N> c)
function NETGEN_INLINE (line 664) | NETGEN_INLINE SIMD<T,N> If (SIMD<mask64,N> a, SIMD<T,N> b, SIMD<T,N> c)
function FMA (line 673) | NETGEN_INLINE auto FMA(T1 a, T2 b, T3 c)
function FNMA (line 679) | NETGEN_INLINE auto FNMA(T1 a, T2 b, T3 c)
function FMAasm (line 686) | void FMAasm (SIMD<double,N> a, SIMD<double,N> b, SIMD<double,N> & sum)
function FNMAasm (line 693) | void FNMAasm (SIMD<double,N> a, SIMD<double,N> b, SIMD<double,N> & sum)
function FMAComplex (line 701) | void FMAComplex (SIMD<double,N> a, SIMD<double,N> b, SIMD<double,N> & c)
function T (line 710) | T get(SIMD<T,N> a) { return a.template Get<i>(); }
function NETGEN_INLINE (line 713) | NETGEN_INLINE void Iterate2 (FUNC f)
function T2 (line 721) | T2 BitCast(T1 a)
function Reinterpret (line 730) | SIMD<T, N> Reinterpret (SIMD<T1,N> a)
function round (line 744) | SIMD<double,N> round (SIMD<double,N> x)
function lround (line 753) | SIMD<int64_t,N> lround (SIMD<double,N> x)
function NETGEN_INLINE (line 765) | NETGEN_INLINE double rsqrt (double x) { return 1.0/sqrt(x); }
function rsqrt (line 769) | SIMD<double,N> rsqrt (SIMD<double,N> x)
function Min (line 789) | auto Min (SIMD<T,N> a, SIMD<T,N> b)
function Max (line 798) | auto Max (SIMD<T,N> a, SIMD<T,N> b)
function ostream (line 811) | ostream & operator<< (ostream & ost, SIMD<T,N> simd)
function NETGEN_INLINE (line 827) | NETGEN_INLINE ngcore::SIMD<double,N> sqrt (ngcore::SIMD<double,N> a)
function NETGEN_INLINE (line 836) | NETGEN_INLINE ngcore::SIMD<double,N> fabs (ngcore::SIMD<double,N> a) {
function NETGEN_INLINE (line 842) | NETGEN_INLINE ngcore::SIMD<double,N> floor (ngcore::SIMD<double,N> a) {
function NETGEN_INLINE (line 848) | NETGEN_INLINE ngcore::SIMD<double,N> ceil (ngcore::SIMD<double,N> a) {
function NETGEN_INLINE (line 854) | NETGEN_INLINE ngcore::SIMD<double,N> exp (ngcore::SIMD<double,N> a) {
function NETGEN_INLINE (line 860) | NETGEN_INLINE ngcore::SIMD<double,N> log (ngcore::SIMD<double,N> a) {
function NETGEN_INLINE (line 866) | NETGEN_INLINE ngcore::SIMD<double,N> erf (ngcore::SIMD<double,N> a) {
function NETGEN_INLINE (line 872) | NETGEN_INLINE ngcore::SIMD<double,N> pow (ngcore::SIMD<double,N> a, do...
function NETGEN_INLINE (line 877) | NETGEN_INLINE ngcore::SIMD<double,N> pow (ngcore::SIMD<double,N> a, ng...
function NETGEN_INLINE (line 883) | NETGEN_INLINE ngcore::SIMD<double,N> sin (ngcore::SIMD<double,N> a) {
function NETGEN_INLINE (line 889) | NETGEN_INLINE ngcore::SIMD<double,N> cos (ngcore::SIMD<double,N> a) {
function NETGEN_INLINE (line 895) | NETGEN_INLINE ngcore::SIMD<double,N> tan (ngcore::SIMD<double,N> a) {
function NETGEN_INLINE (line 901) | NETGEN_INLINE ngcore::SIMD<double,N> atan (ngcore::SIMD<double,N> a) {
function NETGEN_INLINE (line 907) | NETGEN_INLINE ngcore::SIMD<double,N> atan2 (ngcore::SIMD<double,N> y, ...
function NETGEN_INLINE (line 913) | NETGEN_INLINE ngcore::SIMD<double,N> acos (ngcore::SIMD<double,N> a) {
function NETGEN_INLINE (line 919) | NETGEN_INLINE ngcore::SIMD<double,N> asin (ngcore::SIMD<double,N> a) {
function NETGEN_INLINE (line 925) | NETGEN_INLINE ngcore::SIMD<double,N> sinh (ngcore::SIMD<double,N> a) {
function NETGEN_INLINE (line 931) | NETGEN_INLINE ngcore::SIMD<double,N> cosh (ngcore::SIMD<double,N> a) {
function NETGEN_INLINE (line 937) | NETGEN_INLINE ngcore::SIMD<double,N> asinh (ngcore::SIMD<double,N> a) {
function NETGEN_INLINE (line 943) | NETGEN_INLINE ngcore::SIMD<double,N> acosh (ngcore::SIMD<double,N> a) {
function Unpack (line 953) | NETGEN_INLINE auto Unpack (SIMD<double,N> a, SIMD<double,N> b)
function SwapPairs (line 975) | NETGEN_INLINE auto SwapPairs (SIMD<double,N> a)
function HSum128 (line 991) | NETGEN_INLINE auto HSum128 (SIMD<double,N> a)
function FMAddSub (line 1009) | NETGEN_INLINE auto FMAddSub (SIMD<double,N> a, SIMD<double,N> b, SIMD<...
function subtuple (line 1029) | auto subtuple (const Tuple& tup, std::index_sequence<Is...>)
function Concat (line 1035) | auto Concat (std::tuple<SIMD<T,M>, Args...> tup)
type std (line 1063) | namespace std
type tuple_size<ngcore::SIMD<T,N>> (line 1067) | struct tuple_size<ngcore::SIMD<T,N>> : std::integral_constant<std::siz...
type tuple_element<N,ngcore::SIMD<T,M>> (line 1068) | struct tuple_element<N,ngcore::SIMD<T,M>> { using type = T; }
FILE: libsrc/core/simd_math.hpp
type ngcore (line 11) | namespace ngcore
function sincos_reduced (line 44) | auto sincos_reduced (SIMD<double,N> x)
function sincos (line 58) | auto sincos (SIMD<double,N> x)
function exp_reduced (line 81) | SIMD<double,N> exp_reduced (SIMD<double,N> x)
function pow2_int64_to_float64 (line 116) | SIMD<double,N> pow2_int64_to_float64(SIMD<int64_t,N> n)
function myexp (line 139) | SIMD<double,N> myexp (SIMD<double,N> x)
FILE: libsrc/core/simd_sse.hpp
type ngcore (line 12) | namespace ngcore
class SIMD<mask64,2> (line 16) | class SIMD<mask64,2>
method SIMD (line 20) | SIMD (int i)
method SIMD (line 25) | SIMD (bool i0, bool i1) { mask = _mm_set_epi64x(i1?-1:0, i0?-1:0); }
method SIMD (line 27) | SIMD (__m128i _mask) : mask(_mask) { ; }
method __m128i (line 28) | __m128i Data() const { return mask; }
method Size (line 29) | static constexpr int Size() { return 2; }
function NETGEN_INLINE (line 38) | NETGEN_INLINE SIMD<mask64, 2> SIMD<mask64, 2> :: GetMaskFromBits (unsi...
class SIMD<int64_t,2> (line 45) | class alignas(16) SIMD<int64_t,2>
method Size (line 50) | static constexpr int Size() { return 2; }
method SIMD (line 51) | SIMD () {}
method SIMD (line 52) | SIMD (const SIMD &) = default;
method SIMD (line 53) | SIMD (int64_t v0, int64_t v1) { data = _mm_set_epi64x(v1,v0); }
method SIMD (line 54) | SIMD (std::array<int64_t, 2> arr)
method SIMD (line 58) | SIMD & operator= (const SIMD &) = default;
method SIMD (line 60) | SIMD (int64_t val) { data = _mm_set1_epi64x(val); }
method SIMD (line 61) | SIMD (__m128i _data) { data = _data; }
method SIMD (line 64) | SIMD (const T & func)
method NETGEN_INLINE (line 70) | NETGEN_INLINE __m128i Data() const { return data; }
method NETGEN_INLINE (line 71) | NETGEN_INLINE __m128i & Data() { return data; }
method NETGEN_INLINE (line 74) | NETGEN_INLINE int64_t Lo() const { return ((int64_t*)(&data))[0]; }
method NETGEN_INLINE (line 75) | NETGEN_INLINE int64_t Hi() const { return ((int64_t*)(&data))[1]; }
method SIMD (line 76) | static SIMD FirstInt(int n0=0) { return { n0, n0+1 }; }
function NETGEN_INLINE (line 81) | NETGEN_INLINE SIMD<int64_t,2> operator-(SIMD<int64_t,2> a) { return _m...
function NETGEN_INLINE (line 82) | NETGEN_INLINE SIMD<int64_t,2> operator+ (SIMD<int64_t,2> a, SIMD<int64...
function NETGEN_INLINE (line 83) | NETGEN_INLINE SIMD<int64_t,2> operator- (SIMD<int64_t,2> a, SIMD<int64...
class SIMD<double,2> (line 87) | class alignas(16) SIMD<double,2>
method Size (line 92) | static constexpr int Size() { return 2; }
method SIMD (line 93) | SIMD () {}
method SIMD (line 94) | SIMD (const SIMD &) = default;
method SIMD (line 95) | SIMD (double v0, double v1) { data = _mm_set_pd(v1,v0); }
method SIMD (line 96) | SIMD (SIMD<double,1> v0, SIMD<double,1> v1)
method SIMD (line 99) | SIMD (std::array<double, 2> arr)
method SIMD (line 103) | SIMD & operator= (const SIMD &) = default;
method SIMD (line 105) | SIMD (double val) { data = _mm_set1_pd(val); }
method SIMD (line 106) | SIMD (int val) { data = _mm_set1_pd(val); }
method SIMD (line 107) | SIMD (size_t val) { data = _mm_set1_pd(val); }
method SIMD (line 109) | SIMD (double const * p) { data = _mm_loadu_pd(p); }
method SIMD (line 110) | SIMD (double const * p, SIMD<mask64,2> mask)
method SIMD (line 122) | SIMD (__m128d _data) { data = _data; }
method Store (line 124) | void Store (double * p) { _mm_storeu_pd(p, data); }
method Store (line 125) | void Store (double * p, SIMD<mask64,2> mask)
method SIMD (line 141) | SIMD (const T & func)
method NETGEN_INLINE (line 146) | NETGEN_INLINE double operator[] (int i) const { return ((double*)(&d...
method NETGEN_INLINE (line 147) | NETGEN_INLINE __m128d Data() const { return data; }
method NETGEN_INLINE (line 148) | NETGEN_INLINE __m128d & Data() { return data; }
method Get (line 151) | double Get() const
method Lo (line 157) | double Lo() const { return Get<0>(); }
method Hi (line 158) | double Hi() const { return Get<1>(); }
function NETGEN_INLINE (line 167) | NETGEN_INLINE SIMD<double,2> operator- (SIMD<double,2> a) { return _mm...
function NETGEN_INLINE (line 168) | NETGEN_INLINE SIMD<double,2> operator+ (SIMD<double,2> a, SIMD<double,...
function NETGEN_INLINE (line 169) | NETGEN_INLINE SIMD<double,2> operator- (SIMD<double,2> a, SIMD<double,...
function NETGEN_INLINE (line 170) | NETGEN_INLINE SIMD<double,2> operator* (SIMD<double,2> a, SIMD<double,...
function NETGEN_INLINE (line 171) | NETGEN_INLINE SIMD<double,2> operator/ (SIMD<double,2> a, SIMD<double,...
function NETGEN_INLINE (line 172) | NETGEN_INLINE SIMD<double,2> operator* (double a, SIMD<double,2> b) { ...
function NETGEN_INLINE (line 173) | NETGEN_INLINE SIMD<double,2> operator* (SIMD<double,2> b, double a) { ...
function Unpack (line 176) | NETGEN_INLINE auto Unpack (SIMD<double,2> a, SIMD<double,2> b)
function NETGEN_INLINE (line 182) | NETGEN_INLINE __m128d my_mm_hadd_pd(__m128d a, __m128d b) {
function NETGEN_INLINE (line 191) | NETGEN_INLINE __m128i my_mm_cmpgt_epi64(__m128i a, __m128i b) {
function NETGEN_INLINE (line 197) | NETGEN_INLINE __m128i my_mm_cmpgt_epi64(__m128i a, __m128i b) {
function NETGEN_INLINE (line 203) | NETGEN_INLINE SIMD<double,2> sqrt (SIMD<double,2> a) { return _mm_sqrt...
function NETGEN_INLINE (line 204) | NETGEN_INLINE SIMD<double,2> fabs (SIMD<double,2> a) { return _mm_max_...
function NETGEN_INLINE (line 206) | NETGEN_INLINE SIMD<double,2> floor (SIMD<double,2> a)
function NETGEN_INLINE (line 209) | NETGEN_INLINE SIMD<double,2> ceil (SIMD<double,2> a)
function NETGEN_INLINE (line 212) | NETGEN_INLINE SIMD<mask64,2> operator<= (SIMD<double,2> a , SIMD<doubl...
function NETGEN_INLINE (line 214) | NETGEN_INLINE SIMD<mask64,2> operator< (SIMD<double,2> a , SIMD<double...
function NETGEN_INLINE (line 216) | NETGEN_INLINE SIMD<mask64,2> operator>= (SIMD<double,2> a , SIMD<doubl...
function NETGEN_INLINE (line 218) | NETGEN_INLINE SIMD<mask64,2> operator> (SIMD<double,2> a , SIMD<double...
function NETGEN_INLINE (line 220) | NETGEN_INLINE SIMD<mask64,2> operator== (SIMD<double,2> a , SIMD<doubl...
function NETGEN_INLINE (line 222) | NETGEN_INLINE SIMD<mask64,2> operator!= (SIMD<double,2> a , SIMD<doubl...
function NETGEN_INLINE (line 226) | NETGEN_INLINE SIMD<mask64,2> operator<= (SIMD<int64_t,2> a , SIMD<int6...
function NETGEN_INLINE (line 228) | NETGEN_INLINE SIMD<mask64,2> operator< (SIMD<int64_t,2> a , SIMD<int64...
function NETGEN_INLINE (line 230) | NETGEN_INLINE SIMD<mask64,2> operator>= (SIMD<int64_t,2> a , SIMD<int6...
function NETGEN_INLINE (line 232) | NETGEN_INLINE SIMD<mask64,2> operator> (SIMD<int64_t,2> a , SIMD<int64...
function NETGEN_INLINE (line 236) | NETGEN_INLINE SIMD<mask64,2> operator== (SIMD<int64_t,2> a , SIMD<int6...
function NETGEN_INLINE (line 238) | NETGEN_INLINE SIMD<mask64,2> operator!= (SIMD<int64_t,2> a , SIMD<int6...
function NETGEN_INLINE (line 243) | NETGEN_INLINE SIMD<mask64,2> operator&& (SIMD<mask64,2> a, SIMD<mask64...
function NETGEN_INLINE (line 245) | NETGEN_INLINE SIMD<mask64,2> operator|| (SIMD<mask64,2> a, SIMD<mask64...
function NETGEN_INLINE (line 247) | NETGEN_INLINE SIMD<mask64,2> operator! (SIMD<mask64,2> a)
function NETGEN_INLINE (line 250) | NETGEN_INLINE SIMD<double,2> If (SIMD<mask64,2> a, SIMD<double,2> b, S...
function NETGEN_INLINE (line 253) | NETGEN_INLINE SIMD<double,2> If (SIMD<mask64,2> a, SIMD<double,2> b, S...
function NETGEN_INLINE (line 261) | NETGEN_INLINE SIMD<double,2> IfPos (SIMD<double,2> a, SIMD<double,2> b...
function NETGEN_INLINE (line 263) | NETGEN_INLINE SIMD<double,2> IfZero (SIMD<double,2> a, SIMD<double,2> ...
function NETGEN_INLINE (line 267) | NETGEN_INLINE double HSum (SIMD<double,2> sd)
function HSum (line 272) | NETGEN_INLINE auto HSum (SIMD<double,2> sd1, SIMD<double,2> sd2)
function NETGEN_INLINE (line 279) | NETGEN_INLINE SIMD<int64_t, 2> If(SIMD<mask64, 2> a, SIMD<int64_t, 2> b,
FILE: libsrc/core/statushandler.cpp
type ngcore (line 5) | namespace ngcore
function ResetStatus (line 29) | void ResetStatus()
function PushStatus (line 42) | void PushStatus(const std::string& s)
function PopStatus (line 50) | void PopStatus()
function SetStatMsg (line 84) | void SetStatMsg(const std::string& s)
function SetThreadPercent (line 90) | void SetThreadPercent(double percent)
function GetStatus (line 98) | void GetStatus(std::string & s, double & percentage)
FILE: libsrc/core/statushandler.hpp
type ngcore (line 7) | namespace ngcore
function multithreadt (line 10) | class NGCORE_API multithreadt
FILE: libsrc/core/symboltable.hpp
type ngcore (line 11) | namespace ngcore
class SymbolTable (line 21) | class SymbolTable
method SymbolTable (line 31) | SymbolTable () = default;
method SymbolTable (line 32) | SymbolTable (const SymbolTable<T> &) = default;
method SymbolTable (line 33) | SymbolTable (SymbolTable<T> &&) noexcept = default;
method SymbolTable (line 37) | SymbolTable& operator=(const SymbolTable<T>&) = default;
method SymbolTable (line 38) | SymbolTable& operator=(SymbolTable<T>&&) = default;
method DoArchive (line 41) | auto DoArchive(ARCHIVE& ar)
method Index (line 48) | size_t Index (std::string_view name) const
method CheckIndex (line 56) | int CheckIndex (std::string_view name) const
method Size (line 64) | size_t Size() const
method reference (line 70) | reference operator[] (std::string_view name)
method const_reference (line 75) | const_reference operator[] (std::string_view name) const
method reference (line 81) | reference operator[] (size_t i)
method const_reference (line 88) | const_reference operator[] (size_t i) const
method Set (line 102) | void Set (std::string_view name, const T & el)
method Used (line 123) | bool Used (std::string_view name) const
method DeleteAll (line 129) | inline void DeleteAll ()
FILE: libsrc/core/table.cpp
type ngcore (line 13) | namespace ngcore
function NGCORE_API (line 65) | NGCORE_API size_t * TablePrefixSum32 (FlatArray<uint32_t> entrysize)
function NGCORE_API (line 67) | NGCORE_API size_t * TablePrefixSum64 (FlatArray<uint64_t> entrysize)
FILE: libsrc/core/table.hpp
type ngcore (line 21) | namespace ngcore
function Size (line 26) | class FlatTable
function NETGEN_INLINE (line 48) | NETGEN_INLINE const FlatArray<T> operator[] (IndexType i) const
function NETGEN_INLINE (line 53) | NETGEN_INLINE T * Data() const { return data; }
function NETGEN_INLINE (line 55) | NETGEN_INLINE FlatArray<T> AsArray() const
function NETGEN_INLINE (line 60) | NETGEN_INLINE FlatArray<size_t> IndexArray() const
function NETGEN_INLINE (line 66) | NETGEN_INLINE FlatTable<T> Range (size_t start, size_t end) const
function NETGEN_INLINE (line 72) | NETGEN_INLINE FlatTable<T> Range (T_Range<size_t> range) const
function NETGEN_INLINE (line 77) | NETGEN_INLINE T_Range<IndexType> Range () const
class Iterator (line 82) | class Iterator
method Iterator (line 87) | Iterator (const FlatTable & _tab, size_t _row) : tab(_tab), row(_row...
method Iterator (line 88) | Iterator & operator++ () { ++row; return *this; }
function Iterator (line 93) | Iterator begin() const { return Iterator(*this, BASE); }
method Iterator (line 87) | Iterator (const FlatTable & _tab, size_t _row) : tab(_tab), row(_row...
method Iterator (line 88) | Iterator & operator++ () { ++row; return *this; }
function Iterator (line 94) | Iterator end() const { return Iterator(*this, BASE+size); }
method Iterator (line 87) | Iterator (const FlatTable & _tab, size_t _row) : tab(_tab), row(_row...
method Iterator (line 88) | Iterator & operator++ () { ++row; return *this; }
function NETGEN_INLINE (line 116) | NETGEN_INLINE size_t * TablePrefixSum (FlatArray<T> entrysize)
class Table (line 131) | class Table : public FlatTable<T, IndexType>
method NETGEN_INLINE (line 141) | NETGEN_INLINE Table () : FlatTable<T,IndexType> (0,nullptr,nullptr) { ; }
method NETGEN_INLINE (line 143) | NETGEN_INLINE Table (size_t asize, size_t entrysize)
function NETGEN_INLINE (line 184) | explicit NETGEN_INLINE Table (const Table & tab2)
function DoArchive (line 212) | auto DoArchive(ARCHIVE& ar)
function NETGEN_INLINE (line 231) | NETGEN_INLINE Table & operator= (Table && tab2)
function NETGEN_INLINE (line 243) | NETGEN_INLINE ~Table ()
function NETGEN_INLINE (line 254) | NETGEN_INLINE size_t NElements() const { return index[size]; }
function NETGEN_INLINE (line 258) | NETGEN_INLINE void StartMemoryTracing (int /* mem_id */)
function MemoryTracer (line 262) | const MemoryTracer& GetMemoryTracer() const { return mt; }
function ostream (line 272) | inline ostream & operator<< (ostream & s, FlatTable<T,IndexType> table)
class TableCreator (line 289) | class TableCreator
method TableCreator (line 297) | TableCreator()
method TableCreator (line 299) | TableCreator (size_t acnt)
method MoveTable (line 302) | Table<T,IndexType> MoveTable()
method Done (line 307) | bool Done () { return mode > 3; }
method GetMode (line 310) | int GetMode () const { return mode; }
method SetMode (line 311) | void SetMode (int amode)
method SetSize (line 329) | void SetSize (size_t _nd)
method Add (line 340) | void Add (IndexType blocknr, const T & data)
method Add (line 364) | void Add (IndexType blocknr, IntRange range)
method Add (line 388) | void Add (IndexType blocknr, const FlatArray<int> & dofs)
function CreateTable (line 414) | Table<TEntry, TIndex> CreateTable( const TRange & range, const TFunc & f...
function CreateSortedTable (line 440) | Table<TEntry, TIndex> CreateSortedTable( const TRange & range, const TFu...
class NGCORE_API (line 456) | class NGCORE_API
function FilteredTableCreator (line 463) | FilteredTableCreator(int acnt, const BitArray* atakedofs)
function SetFilter (line 465) | void SetFilter (const BitArray * atakedofs) { takedofs = atakedofs; }
class DynamicTable (line 482) | class DynamicTable
type linestruct (line 487) | struct linestruct
method DynamicTable (line 499) | DynamicTable (int size = 0)
method DynamicTable (line 512) | DynamicTable (const Array<int, IndexType> & entrysizes, bool setentrys...
method DynamicTable (line 535) | DynamicTable (DynamicTable && tab2)
method DynamicTable (line 550) | DynamicTable & operator= (DynamicTable && tab2)
method SetSize (line 558) | void SetSize (int size)
method ChangeSize (line 572) | void ChangeSize (size_t size)
method IncSize (line 598) | void IncSize (IndexType i)
method DecSize (line 622) | void DecSize (IndexType i)
method Add (line 637) | void Add (IndexType i, const T & acont)
method AddUnique (line 647) | void AddUnique (IndexType i, const T & cont)
method AddEmpty (line 659) | void AddEmpty (IndexType i)
method Set (line 666) | void Set (IndexType i, int nr, const T & acont)
method T (line 674) | const T & Get (IndexType i, int nr) const
method T (line 681) | const T * GetLine (IndexType i) const
method Size (line 687) | size_t Size () const
method Range (line 692) | auto Range () const
method EntrySize (line 698) | int EntrySize (IndexType i) const
method DecEntrySize (line 704) | void DecEntrySize (IndexType i)
function ostream (line 730) | inline ostream & operator<< (ostream & s, const DynamicTable<T> & table)
function ComputeColoring (line 750) | int ComputeColoring( FlatArray<int> colors, size_t ndofs, Tmask const & ...
FILE: libsrc/core/taskmanager.cpp
type ngcore (line 24) | namespace ngcore
function EnterTaskManager (line 63) | int EnterTaskManager ()
function ExitTaskManager (line 96) | void ExitTaskManager (int num_threads)
function RunWithTaskManager (line 106) | void RunWithTaskManager (function<void()> alg)
type TNestedTask (line 239) | struct TNestedTask
method TNestedTask (line 247) | TNestedTask () { ; }
method TNestedTask (line 248) | TNestedTask (const function<void(TaskInfo&)> & _func,
function AddTask (line 263) | void AddTask (const function<void(TaskInfo&)> & afunc,
class StartStop (line 354) | class StartStop
method StartStop (line 357) | StartStop(const function<void(TaskInfo&)> & afunc)
FILE: libsrc/core/taskmanager.hpp
type ngcore (line 27) | namespace ngcore
class TaskInfo (line 32) | class TaskInfo
class TaskManager (line 47) | class TaskManager
class NodeData (line 51) | class alignas(64) NodeData
method IsSleeping (line 97) | bool IsSleeping() const { return sleep; }
method SuspendWorkers (line 99) | int SuspendWorkers(int asleep_usecs = 1000 )
method ResumeWorkers (line 106) | void ResumeWorkers() { sleep = false; }
method GetMaxThreads (line 109) | static int GetMaxThreads() { return max_threads; }
method GetNumThreads (line 111) | static int GetNumThreads() { return num_threads; }
method GetThreadId (line 115) | static int GetThreadId() { return thread_id; }
method GetNumNodes (line 117) | int GetNumNodes() const { return num_nodes; }
method SetPajeTrace (line 119) | static void SetPajeTrace (bool use) { use_paje_trace = use; }
method SetStartupFunction (line 126) | static void SetStartupFunction (const function<void()> & func) { sta...
method SetStartupFunction (line 127) | static void SetStartupFunction () { startup_function = nullptr; }
method SetCleanupFunction (line 128) | static void SetCleanupFunction (const function<void()> & func) { cle...
method SetCleanupFunction (line 129) | static void SetCleanupFunction () { cleanup_function = nullptr; }
method Done (line 131) | void Done() { done = true; }
class RegionTaskManager (line 151) | class RegionTaskManager
method RegionTaskManager (line 158) | RegionTaskManager(int anthreads=TaskManager::GetMaxThreads())
class SuspendTaskManager (line 186) | class SuspendTaskManager
method SuspendTaskManager (line 193) | SuspendTaskManager(int asleep_usecs=1000)
function NETGEN_INLINE (line 215) | NETGEN_INLINE int TasksPerThread (int tpt)
class TotalCosts (line 222) | class TotalCosts
method TotalCosts (line 226) | TotalCosts (size_t _cost) : cost(_cost) { ; }
function NETGEN_INLINE (line 231) | NETGEN_INLINE void ParallelFor (T_Range<TR> r, TFUNC f,
function NETGEN_INLINE (line 260) | NETGEN_INLINE void ParallelFor (size_t n, Args...args)
function NETGEN_INLINE (line 266) | NETGEN_INLINE void ParallelForRange (T_Range<TR> r, TFUNC f,
function NETGEN_INLINE (line 294) | NETGEN_INLINE void ParallelForRange (size_t n, Args...args)
function NETGEN_INLINE (line 300) | NETGEN_INLINE void ParallelJob (TFUNC f,
class SharedLoop (line 319) | class SharedLoop
class SharedIterator (line 325) | class SharedIterator
method SharedIterator (line 331) | SharedIterator (atomic<int> & acnt, int aendval, bool begin_iterator)
method SharedIterator (line 339) | SharedIterator & operator++ ()
method SharedLoop (line 352) | SharedLoop (IntRange ar) : r(ar) { cnt = r.begin(); }
method SharedLoop (line 353) | SharedLoop (size_t s) : SharedLoop (IntRange{s}) { ; }
method SharedIterator (line 354) | SharedIterator begin() { return SharedIterator (cnt, r.end(), true); }
method SharedIterator (line 331) | SharedIterator (atomic<int> & acnt, int aendval, bool begin_iterator)
method SharedIterator (line 339) | SharedIterator & operator++ ()
method SharedIterator (line 355) | SharedIterator end() { return SharedIterator (cnt, r.end(), false); }
method SharedIterator (line 331) | SharedIterator (atomic<int> & acnt, int aendval, bool begin_iterator)
method SharedIterator (line 339) | SharedIterator & operator++ ()
class AtomicRange (line 475) | class alignas(4096) AtomicRange
method Set (line 481) | void Set (IntRange r)
method SetNoLock (line 488) | void SetNoLock (IntRange r)
method PopFirst (line 500) | bool PopFirst (size_t & hfirst)
method PopHalf (line 523) | bool PopHalf (IntRange & r)
class SharedLoop2 (line 569) | class SharedLoop2
class SharedIterator (line 576) | class SharedIterator
method SharedIterator (line 586) | SharedIterator (FlatArray<AtomicRange> _ranges, atomic<size_t> & _...
method SharedIterator (line 604) | SharedIterator & operator++ () { GetNext(); return *this;}
method GetNext (line 606) | void GetNext()
method GetNext2 (line 618) | void GetNext2()
method SharedLoop2 (line 650) | SharedLoop2 ()
method SharedLoop2 (line 654) | SharedLoop2 (IntRange r)
method SharedLoop2 (line 660) | SharedLoop2 (size_t s) : SharedLoop2 (IntRange{s}) { }
method Reset (line 662) | void Reset (IntRange r)
method Reset (line 672) | void Reset (size_t s) { Reset(IntRange{s}); }
method SharedIterator (line 675) | SharedIterator begin()
method SharedIterator (line 586) | SharedIterator (FlatArray<AtomicRange> _ranges, atomic<size_t> & _...
method SharedIterator (line 604) | SharedIterator & operator++ () { GetNext(); return *this;}
method GetNext (line 606) | void GetNext()
method GetNext2 (line 618) | void GetNext2()
method SharedIterator (line 688) | SharedIterator end() { return SharedIterator (ranges, processed, t...
method SharedIterator (line 586) | SharedIterator (FlatArray<AtomicRange> _ranges, atomic<size_t> & _...
method SharedIterator (line 604) | SharedIterator & operator++ () { GetNext(); return *this;}
method GetNext (line 606) | void GetNext()
method GetNext2 (line 618) | void GetNext2()
class Partitioning (line 695) | class Partitioning
method Partitioning (line 700) | Partitioning () { ; }
method Partitioning (line 703) | Partitioning (const Array<T> & apart) { part = apart; }
method Partitioning (line 706) | Partitioning & operator= (const Array<T> & apart) { part = apart; re...
method GetTotalCosts (line 708) | size_t GetTotalCosts() const { return total_costs; }
method Calc (line 711) | void Calc (size_t n, TFUNC costs, int size = task_manager ? task_man...
method Size (line 765) | size_t Size() const { return part.Size()-1; }
method IntRange (line 766) | IntRange operator[] (size_t i) const { return ngcore::Range(part[i],...
method IntRange (line 767) | IntRange Range() const { return ngcore::Range(part[0], part[Size()]); }
method BinSearch (line 774) | int BinSearch(const Tarray & v, size_t i) {
function NETGEN_INLINE (line 804) | NETGEN_INLINE void ParallelFor (const Partitioning & part, TFUNC f, in...
function NETGEN_INLINE (line 835) | NETGEN_INLINE void ParallelForRange (const Partitioning & part, TFUNC f,
function ParallelReduce (line 866) | auto ParallelReduce (size_t n, FUNC f, OP op, T initial1)
class Tasks (line 920) | class Tasks
method Tasks (line 924) | explicit Tasks (size_t _num = TaskManager::GetNumThreads()) : num(_n...
method GetNum (line 925) | auto GetNum() const { return num; }
class NumaInterleavedArray (line 990) | class NumaInterleavedArray : public Array<T>
method NumaInterleavedArray (line 995) | NumaInterleavedArray () { numa_size = 0; numa_ptr = nullptr; }
method NumaInterleavedArray (line 996) | NumaInterleavedArray (size_t s)
method NumaInterleavedArray (line 1008) | NumaInterleavedArray & operator= (T val)
method NumaInterleavedArray (line 1014) | NumaInterleavedArray & operator= (NumaInterleavedArray && a2)
method Swap (line 1022) | void Swap (NumaInterleavedArray & b)
method SetSize (line 1029) | void SetSize (size_t size)
class NumaDistributedArray (line 1037) | class NumaDistributedArray : public Array<T>
method NumaDistributedArray (line 1042) | NumaDistributedArray () { numa_size = 0; numa_ptr = nullptr; }
method NumaDistributedArray (line 1043) | NumaDistributedArray (size_t s)
method NumaDistributedArray (line 1072) | NumaDistributedArray & operator= (NumaDistributedArray && a2)
method Swap (line 1080) | void Swap (NumaDistributedArray & b)
method SetSize (line 1087) | void SetSize (size_t size)
class NumaLocalArray (line 1097) | class NumaLocalArray : public Array<T>
method NumaLocalArray (line 1102) | NumaLocalArray () { numa_size = 0; numa_ptr = nullptr; }
method NumaLocalArray (line 1103) | NumaLocalArray (size_t s)
Copy disabled (too large)
Download .json
Condensed preview — 690 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (11,115K chars).
[
{
"path": ".clang-format",
"chars": 1787,
"preview": "Language: Cpp\nBasedOnStyle: LLVM\nAlignAfterOpenBracket: Align\nAlignConsecutiveAssignments: false\nAlignConsecutiveDeclara"
},
{
"path": ".gitignore",
"chars": 78,
"preview": "*.whl\ndist\nbuild\n*.vol.gz\n*.vol\n*.ini\n__pycache__\n*.json\n*.zip\n.cache\n*.patch\n"
},
{
"path": ".gitlab-ci.yml",
"chars": 9888,
"preview": "stages:\n - build\n - test\n - test_ngsolve\n - deploy\n - cleanup\n\npush_github:\n stage: build\n tags:\n - linux\n "
},
{
"path": ".gitmodules",
"chars": 131,
"preview": "[submodule \"external_dependencies/pybind11\"]\n\tpath = external_dependencies/pybind11\n\turl = https://github.com/ngsolve/py"
},
{
"path": "AUTHORS",
"chars": 51,
"preview": "Joachim Schoeberl <joachim.schoeberl@tuwien.ac.at>\n"
},
{
"path": "CMakeLists.txt",
"chars": 31090,
"preview": "if(NOT CMAKE_BUILD_TYPE)\n set(CMAKE_BUILD_TYPE \"RelWithDebInfo\" CACHE STRING INTERNAL)\nendif(NOT CMAKE_BUILD_TYPE)\n\ns"
},
{
"path": "CONTRIBUTING.md",
"chars": 1085,
"preview": "\n# How to Contribute\n\n## Reporting issues\n\nIf you have a problem using Netgen/NGSolve consider asking a question in our "
},
{
"path": "ChangeLog",
"chars": 0,
"preview": ""
},
{
"path": "INSTALL",
"chars": 6970,
"preview": "Basic Installation\n==================\n\n These are generic installation instructions.\n\n The `configure' shell script "
},
{
"path": "LICENSE",
"chars": 26430,
"preview": "\t\t GNU LESSER GENERAL PUBLIC LICENSE\n\t\t Version 2.1, February 1999\n\n Copyright (C) 1991, 1999 Free Software Found"
},
{
"path": "NEWS",
"chars": 0,
"preview": ""
},
{
"path": "README.md",
"chars": 598,
"preview": "Netgen mesh generator\n\nNETGEN is an automatic 3d tetrahedral mesh generator. It accepts input from constructive solid ge"
},
{
"path": "TODO",
"chars": 0,
"preview": ""
},
{
"path": "cmake/NetgenConfig.cmake.in",
"chars": 3784,
"preview": "set(CMAKE_MSVC_RUNTIME_LIBRARY \"@CMAKE_MSVC_RUNTIME_LIBRARY@\")\nset(NETGEN_VERSION \"@NETGEN_VERSION@\")\nset(NETGEN_VERSION"
},
{
"path": "cmake/SuperBuild.cmake",
"chars": 11631,
"preview": "include (ExternalProject)\n\noption( BUILD_ZLIB \"Build and link static version of zlib (useful for pip binaries)\" OFF )\nop"
},
{
"path": "cmake/check_submodules.cmake",
"chars": 622,
"preview": "execute_process(COMMAND git submodule status --recursive WORKING_DIRECTORY \"${CMAKE_CURRENT_LIST_DIR}/../\" OUTPUT_VARIAB"
},
{
"path": "cmake/cmake_modules/FindFFMPEG.cmake",
"chars": 2714,
"preview": "# - Try to find ffmpeg libraries (libavcodec, libavformat, libavutil and swscale)\n# Once done this will define\n#\n# FFMP"
},
{
"path": "cmake/cmake_modules/FindMETIS.cmake",
"chars": 4295,
"preview": "# -*- mode: cmake -*-\n#\n# METIS Find Module for MSTK\n# Shamelessly stolen from Amanzi open source code https://software."
},
{
"path": "cmake/cmake_uninstall.cmake.in",
"chars": 1035,
"preview": "if(NOT EXISTS \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\")\n message(FATAL_ERROR \"Cannot find install manifest: @C"
},
{
"path": "cmake/external_projects/catch.cmake",
"chars": 590,
"preview": "include (ExternalProject)\nfind_program(GIT_EXECUTABLE git)\nExternalProject_Add(\n project_catch\n PREFIX ${CMAKE_BIN"
},
{
"path": "cmake/external_projects/cgns.cmake",
"chars": 932,
"preview": "if(WIN32)\n\n ExternalProject_Add(project_win_cgns\n URL ${CGNS_DOWNLOAD_URL_WIN}\n UPDATE_COMMAND \"\" # Disable updat"
},
{
"path": "cmake/external_projects/metis.cmake",
"chars": 821,
"preview": "set(METIS_SRC_DIR ${CMAKE_CURRENT_BINARY_DIR}/dependencies/src/project_metis)\nset(METIS_DIR ${CMAKE_CURRENT_BINARY_DIR}/"
},
{
"path": "cmake/external_projects/spdlog.cmake",
"chars": 425,
"preview": "include(ExternalProject)\nfind_program(GIT_EXECUTABLE git)\n\nExternalProject_Add(\n project_spdlog\n PREFIX ${CMAKE_BINARY"
},
{
"path": "cmake/external_projects/tcltk.cmake",
"chars": 9706,
"preview": "if(UNIX AND NOT APPLE)\n set (LINUX TRUE)\nendif()\nif(LINUX)\n find_package(TclStub 8.5 REQUIRED)\nelse(LINUX)\nif(SKBUIL"
},
{
"path": "cmake/external_projects/zlib.cmake",
"chars": 592,
"preview": "if(WIN32)\n\n ExternalProject_Add(project_win_zlib\n URL ${ZLIB_DOWNLOAD_URL_WIN}\n UPDATE_COMMAND \"\" # Disable updat"
},
{
"path": "cmake/generate_version_file.cmake",
"chars": 4855,
"preview": "if(NOT BDIR)\n set(BDIR ${CMAKE_CURRENT_BINARY_DIR})\nendif()\n\nif(NETGEN_VERSION_GIT)\n set(git_version_string ${NETGEN"
},
{
"path": "cmake/mic.cmake",
"chars": 464,
"preview": "set(CMAKE_SYSTEM_NAME Linux)\nset(CMAKE_SYSTEM_PROCESSOR k1om)\nset(CMAKE_SYSTEM_VERSION 1)\n\n# specify the cross compiler\n"
},
{
"path": "cmake/netgen_fixup.cmake",
"chars": 1514,
"preview": "include(BundleUtilities)\nfunction(netgen_fixup_bundle app libs dirs)\n message(STATUS \"fixup_bundle\")\n message(STATUS \""
},
{
"path": "depcomp",
"chars": 12924,
"preview": "#! /bin/sh\n\n# depcomp - compile a program generating dependencies as side-effects\n# Copyright 1999, 2000 Free Software F"
},
{
"path": "doc/CMakeLists.txt",
"chars": 103,
"preview": "INSTALL(FILES ng4.pdf DESTINATION ${NG_INSTALL_DIR_RES}/${NG_INSTALL_SUFFIX}/doc COMPONENT netgen_doc)\n"
},
{
"path": "doc/element_types.tex",
"chars": 7684,
"preview": "\\documentclass[convert=pdf2svg]{standalone}\n% \\documentclass{article}\n\n\\usepackage[T1]{fontenc}\n\\usepackage{lmodern}\n\\re"
},
{
"path": "doc/ng4.tex",
"chars": 36625,
"preview": "%\n% Requires latex and latex2html packages \n%\n% Generate pdf-file with\n% pdflatex ng4.tex\n% \n% Generate html docu with\n%"
},
{
"path": "external_dependencies/.gitignore",
"chars": 9,
"preview": "*.tar.gz\n"
},
{
"path": "libsrc/CMakeLists.txt",
"chars": 517,
"preview": "add_subdirectory(core)\nadd_subdirectory(general)\nadd_subdirectory(gprim)\nadd_subdirectory(linalg)\nadd_subdirectory(inclu"
},
{
"path": "libsrc/core/.clang-tidy",
"chars": 765,
"preview": "Checks: '*,-cppcoreguidelines-avoid-non-const-global-variables,-llvmlibc-restrict-system-libc-headers,-clang-analyzer-al"
},
{
"path": "libsrc/core/CMakeLists.txt",
"chars": 6739,
"preview": "\nadd_library(ngcore ${NGCORE_LIBRARY_TYPE}\n archive.cpp\n bitarray.cpp\n exception.cpp\n localheap.cpp\n logging.cpp\n "
},
{
"path": "libsrc/core/_get_glibcxx_use_cxx11_abi.cpp",
"chars": 245,
"preview": "#include <iostream>\n\nint main() {\n #ifdef _GLIBCXX_USE_CXX11_ABI\n if(_GLIBCXX_USE_CXX11_ABI)\n std::cout << 1;\n els"
},
{
"path": "libsrc/core/_get_gxx_abi.cpp",
"chars": 161,
"preview": "#include <iostream>\n\nint main() {\n if (__GXX_ABI_VERSION >= 2000 || __GXX_ABI_VERSION < 1000) return 1;\n std::cout << "
},
{
"path": "libsrc/core/archive.cpp",
"chars": 1739,
"preview": "\n#include \"archive.hpp\"\n#include \"register_archive.hpp\"\n#include \"version.hpp\"\n\n#ifndef WIN32\n#include <cxxabi.h>\n#endif"
},
{
"path": "libsrc/core/archive.hpp",
"chars": 42614,
"preview": "#ifndef NETGEN_CORE_ARCHIVE_HPP\n#define NETGEN_CORE_ARCHIVE_HPP\n\n#include <algorithm>\n#include <any>\n#include <array> "
},
{
"path": "libsrc/core/array.hpp",
"chars": 46948,
"preview": "#ifndef NETGEN_CORE_ARRAY_HPP\n#define NETGEN_CORE_ARRAY_HPP\n\n/**********************************************************"
},
{
"path": "libsrc/core/autodiff.hpp",
"chars": 30849,
"preview": "#ifndef FILE_AUTODIFF\n#define FILE_AUTODIFF\n\n/**************************************************************************"
},
{
"path": "libsrc/core/autodiffdiff.hpp",
"chars": 19374,
"preview": "#ifndef FILE_AUTODIFFDIFF\n#define FILE_AUTODIFFDIFF\n\n/******************************************************************"
},
{
"path": "libsrc/core/bitarray.cpp",
"chars": 4394,
"preview": "/**************************************************************************/\n/* File: bitarray.cpp "
},
{
"path": "libsrc/core/bitarray.hpp",
"chars": 5319,
"preview": "#ifndef NETGEN_CORE_BITARRAY\n#define NETGEN_CORE_BITARRAY\n\n/************************************************************"
},
{
"path": "libsrc/core/concurrentqueue.h",
"chars": 146859,
"preview": "// Provides a C++11 implementation of a multi-producer, multi-consumer lock-free queue.\n// An overview, including benchm"
},
{
"path": "libsrc/core/exception.cpp",
"chars": 9019,
"preview": "#include \"exception.hpp\"\n#include \"utils.hpp\"\n\n#ifdef EMSCRIPTEN\n#include <iostream>\n#endif // EMSCRIPTEN\n\n// no backtra"
},
{
"path": "libsrc/core/exception.hpp",
"chars": 5356,
"preview": "#ifndef NETGEN_CORE_EXCEPTION_HPP\n#define NETGEN_CORE_EXCEPTION_HPP\n\n#include <cstddef>\n#include <sstream> // fo"
},
{
"path": "libsrc/core/flags.cpp",
"chars": 15982,
"preview": "/**************************************************************************/\n/* File: flags.cpp "
},
{
"path": "libsrc/core/flags.hpp",
"chars": 8054,
"preview": "#ifndef NETGEN_CORE_FLAGS_HPP\n#define NETGEN_CORE_FLAGS_HPP\n\n\n/*********************************************************"
},
{
"path": "libsrc/core/generate_mpi_sources.py",
"chars": 7670,
"preview": "functions = [\n (\"double\", \"MPI_Wtime\"),\n (\"int\", \"MPI_Allgather\", \"void*\", \"int\", \"MPI_Datatype\", \"void*\","
},
{
"path": "libsrc/core/hashtable.hpp",
"chars": 29161,
"preview": "#ifndef FILE_NGSTD_HASHTABLE\n#define FILE_NGSTD_HASHTABLE\n\n/************************************************************"
},
{
"path": "libsrc/core/localheap.cpp",
"chars": 1931,
"preview": "/**************************************************************************/\n/* File: localheap.cpp "
},
{
"path": "libsrc/core/localheap.hpp",
"chars": 6754,
"preview": "#ifndef NETGEN_CORE_LOCALHEAP_HPP\n#define NETGEN_CORE_LOCALHEAP_HPP\n\n/**************************************************"
},
{
"path": "libsrc/core/logging.cpp",
"chars": 1164,
"preview": "#include \"logging.hpp\"\n\n#include <iostream>\n\nnamespace ngcore\n{\n std::ostream* testout = new std::ostream(nullptr); // "
},
{
"path": "libsrc/core/logging.hpp",
"chars": 3291,
"preview": "#ifndef NETGEN_CORE_LOGGING_HPP\n#define NETGEN_CORE_LOGGING_HPP\n\n#include <iostream>\n#include <memory>\n#include <string>"
},
{
"path": "libsrc/core/memtracer.hpp",
"chars": 5654,
"preview": "#ifndef NETGEN_CORE_MEMTRACER_HPP\n#define NETGEN_CORE_MEMTRACER_HPP\n\n#include <array>\n#include <chrono>\n#include <string"
},
{
"path": "libsrc/core/mpi4py_pycapi.h",
"chars": 7144,
"preview": "/* Author: Lisandro Dalcin */\n/* Contact: dalcinl@gmail.com */\n\n#ifndef MPI4PY_PYCAPI_H\n#define MPI4PY_PYCAPI_H\n\n#inc"
},
{
"path": "libsrc/core/mpi_wrapper.hpp",
"chars": 18113,
"preview": "#ifndef NGCORE_MPIWRAPPER_HPP\n#define NGCORE_MPIWRAPPER_HPP\n\n#include <array>\n\n#include <complex>\n\n#include \"array.hpp\"\n"
},
{
"path": "libsrc/core/ng_mpi.cpp",
"chars": 5206,
"preview": "#define OMPI_SKIP_MPICXX\n#include <mpi.h>\n\n#include \"ng_mpi.hpp\"\n\n#include <type_traits>\n\n#include \"array.hpp\"\n#include "
},
{
"path": "libsrc/core/ng_mpi.hpp",
"chars": 2539,
"preview": "#ifndef NG_MPI_HPP_INCLUDED\n#define NG_MPI_HPP_INCLUDED\n\n#ifdef PARALLEL\n\n#include <cstdint>\n#include <filesystem>\n#incl"
},
{
"path": "libsrc/core/ng_mpi_generated_declarations.hpp",
"chars": 8336,
"preview": "#ifdef NG_MPI_WRAPPER\nNGCORE_API extern double (*NG_MPI_Wtime)();\nNGCORE_API extern int (*NG_MPI_Allgather)(void*, int, "
},
{
"path": "libsrc/core/ng_mpi_generated_dummy_init.hpp",
"chars": 6464,
"preview": "decltype(NG_MPI_Wtime) NG_MPI_Wtime = []()->double { throw no_mpi(); };\ndecltype(NG_MPI_Allgather) NG_MPI_Allgather = []"
},
{
"path": "libsrc/core/ng_mpi_generated_init.hpp",
"chars": 8715,
"preview": "NG_MPI_Wtime = []()->double { return MPI_Wtime(); };\nNG_MPI_Allgather = [](void* arg0, int arg1, NG_MPI_Datatype arg2, v"
},
{
"path": "libsrc/core/ng_mpi_native.hpp",
"chars": 507,
"preview": "#ifndef NG_MPI_NATIVE_HPP\n#define NG_MPI_NATIVE_HPP\n\n#include <mpi.h>\n\n#include \"mpi_wrapper.hpp\"\n#include \"ng_mpi.hpp\"\n"
},
{
"path": "libsrc/core/ng_mpi_wrapper.cpp",
"chars": 6194,
"preview": "#ifdef PARALLEL\n\n#include <filesystem>\n#include <iostream>\n#include <stdexcept>\n\n#include \"ng_mpi.hpp\"\n#include \"ngstrea"
},
{
"path": "libsrc/core/ngcore.hpp",
"chars": 651,
"preview": "#ifndef NETGEN_CORE_NGCORE_HPP\n#define NETGEN_CORE_NGCORE_HPP\n\n#include \"archive.hpp\"\n#include \"array.hpp\"\n#include \"bit"
},
{
"path": "libsrc/core/ngcore_api.hpp",
"chars": 4222,
"preview": "#ifndef NETGEN_CORE_NGCORE_API_HPP\n#define NETGEN_CORE_NGCORE_API_HPP\n\n#include \"netgen_config.hpp\"\n\n#ifdef WIN32\n\n// Th"
},
{
"path": "libsrc/core/ngstream.hpp",
"chars": 2767,
"preview": "#ifndef FILE_NGSTREAM\n#define FILE_NGSTREAM\n\n/**************************************************************************"
},
{
"path": "libsrc/core/paje_trace.cpp",
"chars": 45301,
"preview": "#include <algorithm>\n#include <atomic>\n#include <iostream>\n#include <map>\n#include <set>\n#include <thread>\n\n#include \"ar"
},
{
"path": "libsrc/core/paje_trace.hpp",
"chars": 8261,
"preview": "#ifndef NETGEN_CORE_PAJE_TRACE_HPP\n#define NETGEN_CORE_PAJE_TRACE_HPP\n\n#include <algorithm>\n#include <limits>\n#include <"
},
{
"path": "libsrc/core/profiler.cpp",
"chars": 3231,
"preview": "#include <mutex>\n\n#include \"profiler.hpp\"\n\nnamespace ngcore\n{\n std::vector<NgProfiler::TimerVal> NgProfiler::timers(NgP"
},
{
"path": "libsrc/core/profiler.hpp",
"chars": 11002,
"preview": "#ifndef NETGEN_CORE_PROFILER_HPP\n#define NETGEN_CORE_PROFILER_HPP\n\n#include <array>\n#include <chrono>\n#include <function"
},
{
"path": "libsrc/core/python_ngcore.cpp",
"chars": 5586,
"preview": "\n#include \"logging.hpp\"\n#include \"python_ngcore.hpp\"\n\nnamespace py = pybind11;\nusing std::string;\n\nnamespace ngcore\n{\n "
},
{
"path": "libsrc/core/python_ngcore.hpp",
"chars": 15531,
"preview": "#ifndef NETGEN_CORE_PYTHON_NGCORE_HPP\n#define NETGEN_CORE_PYTHON_NGCORE_HPP\n\n#include \"ngcore_api.hpp\" // for operator n"
},
{
"path": "libsrc/core/python_ngcore_export.cpp",
"chars": 18052,
"preview": "#include \"archive.hpp\"\n#include \"python_ngcore.hpp\"\n#include \"bitarray.hpp\"\n#include \"taskmanager.hpp\"\n#include \"mpi_wra"
},
{
"path": "libsrc/core/ranges.hpp",
"chars": 2633,
"preview": "#ifndef NETGEN_CORE_RANGES_HPP\n#define NETGEN_CORE_RANGES_HPP\n\n#include <iterator>\n\nnamespace ngcore\n{\n template<typena"
},
{
"path": "libsrc/core/register_archive.hpp",
"chars": 3208,
"preview": "#ifndef NETGEN_REGISTER_ARCHIVE_HPP\n#define NETGEN_REGISTER_ARCHIVE_HPP\n\n#ifdef NETGEN_PYTHON\n#include <memory>\n#include"
},
{
"path": "libsrc/core/signal.hpp",
"chars": 1632,
"preview": "#ifndef NGCORE_SIGNALS_HPP\n#define NGCORE_SIGNALS_HPP\n\n#include <list>\n#include <map>\n#include <functional>\n\nnamespace n"
},
{
"path": "libsrc/core/simd.hpp",
"chars": 4055,
"preview": "#ifndef NETGEN_CORE_SIMD_HPP\n#define NETGEN_CORE_SIMD_HPP\n\n/************************************************************"
},
{
"path": "libsrc/core/simd_arm64.hpp",
"chars": 11452,
"preview": "#include \"arm_neon.h\"\n\nnamespace ngcore\n{\n\n template <>\n class SIMD<mask64,2>\n {\n int64x2_t mask;\n public:\n SI"
},
{
"path": "libsrc/core/simd_avx.hpp",
"chars": 16641,
"preview": "#ifndef NETGEN_CORE_SIMD_AVX_HPP\n#define NETGEN_CORE_SIMD_AVX_HPP\n\n/****************************************************"
},
{
"path": "libsrc/core/simd_avx512.hpp",
"chars": 12108,
"preview": "#ifndef NETGEN_CORE_SIMD_AVX512_HPP\n#define NETGEN_CORE_SIMD_AVX512_HPP\n\n/**********************************************"
},
{
"path": "libsrc/core/simd_generic.hpp",
"chars": 32866,
"preview": "#ifndef NETGEN_CORE_SIMD_GENERIC_HPP\n#define NETGEN_CORE_SIMD_GENERIC_HPP\n\n/********************************************"
},
{
"path": "libsrc/core/simd_math.hpp",
"chars": 4005,
"preview": "#ifndef NETGEN_CORE_SIMD_MATH_HPP\n#define NETGEN_CORE_SIMD_MATH_HPP\n\n#include <tuple>\n\n#ifndef M_PI\n#define M_PI 3.14159"
},
{
"path": "libsrc/core/simd_sse.hpp",
"chars": 11553,
"preview": "#ifndef NETGEN_CORE_SIMD_SSE_HPP\n#define NETGEN_CORE_SIMD_SSE_HPP\n\n/****************************************************"
},
{
"path": "libsrc/core/statushandler.cpp",
"chars": 2164,
"preview": "#include \"array.hpp\"\n#include \"statushandler.hpp\"\n\n\nnamespace ngcore\n{\n volatile multithreadt multithread;\n \n multith"
},
{
"path": "libsrc/core/statushandler.hpp",
"chars": 880,
"preview": "#ifndef NETGEN_CORE_STATUSHANDLER\n#define NETGEN_CORE_STATUSHANDLER\n\n#include <string>\n#include \"utils.hpp\"\n\nnamespace n"
},
{
"path": "libsrc/core/symboltable.hpp",
"chars": 3771,
"preview": "#ifndef NETGEN_CORE_SYMBOLTABLE_HPP\n#define NETGEN_CORE_SYMBOLTABLE_HPP\n\n#include <ostream>\n#include <string>\n#include <"
},
{
"path": "libsrc/core/table.cpp",
"chars": 4606,
"preview": "/**************************************************************************/\n/* File: table.cpp "
},
{
"path": "libsrc/core/table.hpp",
"chars": 21129,
"preview": "#ifndef NETGEN_CORE_TABLE_HPP\n#define NETGEN_CORE_TABLE_HPP\n\n/**********************************************************"
},
{
"path": "libsrc/core/taskmanager.cpp",
"chars": 22990,
"preview": "/********************************************************************/\n/* File: taskmanager.cpp "
},
{
"path": "libsrc/core/taskmanager.hpp",
"chars": 28630,
"preview": "#ifndef NETGEN_CORE_TASKMANAGER_HPP\n#define NETGEN_CORE_TASKMANAGER_HPP\n\n/**********************************************"
},
{
"path": "libsrc/core/type_traits.hpp",
"chars": 1924,
"preview": "#ifndef NETGEN_CORE_TYPE_TRAITS_HPP\n#define NETGEN_CORE_TYPE_TRAITS_HPP\n\n#include <memory>\n#include <type_traits>\n\nnames"
},
{
"path": "libsrc/core/utils.cpp",
"chars": 6834,
"preview": "#include \"ngcore_api.hpp\"\n#include \"utils.hpp\"\n#include \"logging.hpp\"\n#include \"simd_generic.hpp\"\n\n#ifdef WIN32\n#define "
},
{
"path": "libsrc/core/utils.hpp",
"chars": 9232,
"preview": "#ifndef NETGEN_CORE_UTILS_HPP\n#define NETGEN_CORE_UTILS_HPP\n\n#include <atomic>\n#include <chrono>\n#include <filesystem>\n#"
},
{
"path": "libsrc/core/version.cpp",
"chars": 950,
"preview": "#include <map>\n\n#include <netgen_version.hpp>\n#include \"exception.hpp\"\n#include \"version.hpp\"\n\nnamespace ngcore\n{\n // c"
},
{
"path": "libsrc/core/version.hpp",
"chars": 3476,
"preview": "#ifndef NETGEN_CORE_VERSION_HPP\n#define NETGEN_CORE_VERSION_HPP\n\n#include <ostream>\n#include <string>\n#include <tuple>\n\n"
},
{
"path": "libsrc/core/xbool.hpp",
"chars": 1419,
"preview": "#ifndef NETGEN_CORE_XBOOL_HPP\n#define NETGEN_CORE_XBOOL_HPP\n\n/**********************************************************"
},
{
"path": "libsrc/csg/CMakeLists.txt",
"chars": 914,
"preview": "target_sources(nglib PRIVATE\n algprim.cpp brick.cpp \n bspline2d.cpp csgeom.cpp csgparser.cpp curve2d.cpp"
},
{
"path": "libsrc/csg/algprim.cpp",
"chars": 46581,
"preview": "#include <mystdlib.h>\n#include <core/register_archive.hpp>\n\n\n#include <linalg.hpp>\n#include <csg.hpp>\n\n\nnamespace netgen"
},
{
"path": "libsrc/csg/algprim.hpp",
"chars": 14273,
"preview": "#ifndef FILE_ALGPRIM\n#define FILE_ALGPRIM\n\n\n/**************************************************************************/"
},
{
"path": "libsrc/csg/brick.cpp",
"chars": 10412,
"preview": "#include <mystdlib.h>\n#include <core/register_archive.hpp>\n\n#include <linalg.hpp>\n#include <csg.hpp>\n\nnamespace netgen\n{"
},
{
"path": "libsrc/csg/brick.hpp",
"chars": 3869,
"preview": "#ifndef FILE_BRICK\n#define FILE_BRICK\n\n\n/**************************************************************************/\n/* "
},
{
"path": "libsrc/csg/bspline2d.cpp",
"chars": 5364,
"preview": "#include <mystdlib.h>\n\n#include <csg.hpp>\n\nnamespace netgen\n{\n\nBSplineCurve2d :: BSplineCurve2d ()\n{\n redlevel = 0;\n}\n\n"
},
{
"path": "libsrc/csg/csg.hpp",
"chars": 1115,
"preview": "#ifndef FILE_CSG\n#define FILE_CSG\n\n/* *************************************************************************/\n/* File"
},
{
"path": "libsrc/csg/csgeom.cpp",
"chars": 39551,
"preview": "#include <mystdlib.h>\n#include <myadt.hpp>\n#include <core/register_archive.hpp>\n\n#include <linalg.hpp>\n#include <csg.hpp"
},
{
"path": "libsrc/csg/csgeom.hpp",
"chars": 11617,
"preview": "#ifndef FILE_CSGEOM\n#define FILE_CSGEOM\n\n/**************************************************************************/\n/*"
},
{
"path": "libsrc/csg/csgparser.cpp",
"chars": 30883,
"preview": "#include <mystdlib.h>\n#include <myadt.hpp>\n\n#include <linalg.hpp>\n#include <csg.hpp>\n\n\nnamespace netgen\n{\n static kwstr"
},
{
"path": "libsrc/csg/csgparser.hpp",
"chars": 2237,
"preview": "#ifndef _CSGPARSER_HPP\n#define _CSGPARSER_HPP\n\n\nnamespace netgen\n{\n\n enum TOKEN_TYPE\n { \n TOK_MINUS = '-', TOK_"
},
{
"path": "libsrc/csg/csgpkg.cpp",
"chars": 16625,
"preview": "#include <mystdlib.h>\n#include <myadt.hpp>\n#include <linalg.hpp>\n#include <csg.hpp>\n\n\n#include <inctcl.hpp>\n#include <vi"
},
{
"path": "libsrc/csg/curve2d.cpp",
"chars": 1494,
"preview": "#include <mystdlib.h>\n\n#include <myadt.hpp>\n#include <csg.hpp>\n\nnamespace netgen\n{\nCircleCurve2d :: CircleCurve2d (const"
},
{
"path": "libsrc/csg/curve2d.hpp",
"chars": 1343,
"preview": "#ifndef FILE_CURVE2D\n#define FILE_CURVE2D\n\n/**************************************************************************/\n"
},
{
"path": "libsrc/csg/edgeflw.cpp",
"chars": 50063,
"preview": "#include <mystdlib.h>\n#include <meshing.hpp>\n#include <csg.hpp>\n\n// #undef DEVELOP\n// #define DEVELOP\n\nnamespace netgen\n"
},
{
"path": "libsrc/csg/edgeflw.hpp",
"chars": 2732,
"preview": "#ifndef FILE_EDGEFLW\n#define FILE_EDGEFLW\n\n/**************************************************************************/\n"
},
{
"path": "libsrc/csg/explicitcurve2d.cpp",
"chars": 3165,
"preview": "#include <mystdlib.h>\n#include <csg.hpp>\n\nnamespace netgen\n{\nExplicitCurve2d :: ExplicitCurve2d ()\n {\n ;\n }\n \n \nv"
},
{
"path": "libsrc/csg/explicitcurve2d.hpp",
"chars": 2636,
"preview": "#ifndef FILE_EXPLICITCURVE2D\n#define FILE_EXPLICITCURVE2D\n\n/************************************************************"
},
{
"path": "libsrc/csg/extrusion.cpp",
"chars": 20595,
"preview": "#include <mystdlib.h>\n#include <core/register_archive.hpp>\n\n#include <linalg.hpp>\n#include <csg.hpp>\n\n\nnamespace netgen\n"
},
{
"path": "libsrc/csg/extrusion.hpp",
"chars": 5543,
"preview": "#ifndef _EXTRUSION_HPP\n#define _EXTRUSION_HPP\n\nnamespace netgen\n{\n\n class Extrusion;\n\n class ExtrusionFace : public Su"
},
{
"path": "libsrc/csg/gencyl.cpp",
"chars": 4306,
"preview": "#include <linalg.hpp>\n#include <csg.hpp>\n\n\nnamespace netgen\n{\n\n GeneralizedCylinder :: GeneralizedCylinder (ExplicitCur"
},
{
"path": "libsrc/csg/gencyl.hpp",
"chars": 1626,
"preview": "#ifndef FILE_GENCYL\n#define FILE_GENCYL\n\n/**************************************************************************/\n/*"
},
{
"path": "libsrc/csg/genmesh.cpp",
"chars": 23084,
"preview": "#include <mystdlib.h>\n\n\n#include <myadt.hpp>\n\n#include <linalg.hpp>\n#include <csg.hpp>\n#include <meshing.hpp>\n\n\nnamespac"
},
{
"path": "libsrc/csg/geoml.hpp",
"chars": 566,
"preview": "#ifndef FILE_GEOML\n#define FILE_GEOML\n\n/* *************************************************************************/\n/* "
},
{
"path": "libsrc/csg/identify.cpp",
"chars": 38068,
"preview": "#include <mystdlib.h>\n#include <myadt.hpp>\n\n#include <linalg.hpp>\n#include <csg.hpp>\n#include <meshing.hpp>\n\n\nnamespace "
},
{
"path": "libsrc/csg/identify.hpp",
"chars": 7388,
"preview": "\n#ifndef FILE_IDENTIFY\n#define FILE_IDENTIFY\n\n/*************************************************************************"
},
{
"path": "libsrc/csg/manifold.cpp",
"chars": 109,
"preview": "#include <csg.hpp>\n\nnamespace netgen\n{\nManifold :: Manifold () \n{\n ;\n}\n\nManifold :: ~Manifold () \n{\n ;\n}\n}\n"
},
{
"path": "libsrc/csg/manifold.hpp",
"chars": 614,
"preview": "#ifndef FILE_MANIFOLD\n#define FILE_MANIFOLD\n\n/**************************************************************************"
},
{
"path": "libsrc/csg/meshsurf.cpp",
"chars": 1562,
"preview": "#include <mystdlib.h>\n\n#include <csg.hpp>\n#include <meshing.hpp>\n\n\n\nnamespace netgen\n{\n /*\nMeshing2Surfaces :: Meshing2"
},
{
"path": "libsrc/csg/meshsurf.hpp",
"chars": 1282,
"preview": "#ifndef FILE_MESHSURF\n#define FILE_MESHSURF\n\nnamespace netgen\n{\n\n ///\n class Meshing2Surfaces : public Meshing2\n {\n "
},
{
"path": "libsrc/csg/polyhedra.cpp",
"chars": 30072,
"preview": "#include <mystdlib.h>\n\n#include <linalg.hpp>\n#include <csg.hpp>\n\nnamespace netgen\n{\n\n Polyhedra::Face::Face (int pi1, i"
},
{
"path": "libsrc/csg/polyhedra.hpp",
"chars": 3713,
"preview": "#ifndef FILE_POLYHEDRA\n#define FILE_POLYHEDRA\n\n\n/***********************************************************************"
},
{
"path": "libsrc/csg/python_csg.cpp",
"chars": 33239,
"preview": "#ifdef NG_PYTHON\n\n#include \"../general/ngpython.hpp\"\n#include \"../core/python_ngcore.hpp\"\n#include \"csg.hpp\"\n#include \"."
},
{
"path": "libsrc/csg/revolution.cpp",
"chars": 28918,
"preview": "#include <mystdlib.h>\n#include <core/register_archive.hpp>\n\n#include <linalg.hpp>\n#include <csg.hpp>\n\nnamespace netgen\n{"
},
{
"path": "libsrc/csg/revolution.hpp",
"chars": 4679,
"preview": "#ifndef _REVOLUTION_HPP\n#define _REVOLUTION_HPP\n\nnamespace netgen\n{\n\n class Revolution;\n\n class RevolutionFace : publi"
},
{
"path": "libsrc/csg/singularref.cpp",
"chars": 5175,
"preview": "#include <mystdlib.h>\n#include <myadt.hpp>\n\n#include <linalg.hpp>\n#include <csg.hpp>\n#include <meshing.hpp>\n\nnamespace n"
},
{
"path": "libsrc/csg/singularref.hpp",
"chars": 2021,
"preview": "#ifndef FILE_SINGULARREF\n#define FILE_SINGULARREF\n\n/********************************************************************"
},
{
"path": "libsrc/csg/solid.cpp",
"chars": 43570,
"preview": "#include <mystdlib.h>\n\n#include <linalg.hpp>\n#include <csg.hpp>\n\n\nnamespace netgen\n{\n\n\n // int Solid :: cntnames = 0;\n "
},
{
"path": "libsrc/csg/solid.hpp",
"chars": 9082,
"preview": "#ifndef FILE_SOLID\n#define FILE_SOLID\n\n/**************************************************************************/\n/* F"
},
{
"path": "libsrc/csg/specpoin.cpp",
"chars": 54889,
"preview": "#include <mystdlib.h>\n#include <meshing.hpp>\n#include <csg.hpp>\n\n\n/*\n Special Point calculation uses the global Flags:\n"
},
{
"path": "libsrc/csg/specpoin.hpp",
"chars": 4782,
"preview": "#ifndef FILE_SPECPOIN\n#define FILE_SPECPOIN\n\n\n/*************************************************************************"
},
{
"path": "libsrc/csg/spline3d.cpp",
"chars": 7853,
"preview": "#include <mystdlib.h>\n\n#include <myadt.hpp>\n\n#include <linalg.hpp>\n#include <csg.hpp>\n\n\nnamespace netgen\n{\nsplinesegment"
},
{
"path": "libsrc/csg/spline3d.hpp",
"chars": 2434,
"preview": "namespace netgen\n{\n\n ///\n class splinesegment3d\n {\n ///\n Point<3> p1, p2, p3;\n \n public:\n ///\n splinese"
},
{
"path": "libsrc/csg/splinesurface.cpp",
"chars": 3064,
"preview": "\n#include <csg.hpp>\n#include <core/register_archive.hpp>\n\nnamespace netgen\n{\nvoid SplineSurface :: AppendPoint(const Poi"
},
{
"path": "libsrc/csg/splinesurface.hpp",
"chars": 3308,
"preview": "#ifndef FILE_SPLINESURFACE\n#define FILE_SPLINESURFACE\n\n\nnamespace netgen\n{\n class SplineSurface : public OneSurfacePr"
},
{
"path": "libsrc/csg/surface.cpp",
"chars": 11075,
"preview": "#include <mystdlib.h>\n#include <core/register_archive.hpp>\n\n#include <myadt.hpp>\n#include <csg.hpp>\n\n#include <linalg.hp"
},
{
"path": "libsrc/csg/surface.hpp",
"chars": 10853,
"preview": "#ifndef FILE_SURFACE\n#define FILE_SURFACE\n\n/**************************************************************************/\n"
},
{
"path": "libsrc/csg/triapprox.cpp",
"chars": 1037,
"preview": "#include <mystdlib.h>\n#include <myadt.hpp>\n\n#include <linalg.hpp>\n#include <csg.hpp>\n\n\nnamespace netgen\n{\n\n TriangleApp"
},
{
"path": "libsrc/csg/triapprox.hpp",
"chars": 1706,
"preview": "#ifndef FILE_TRIAPPROX\n#define FILE_TRIAPPROX\n\n/************************************************************************"
},
{
"path": "libsrc/csg/vscsg.cpp",
"chars": 11252,
"preview": "#include <mystdlib.h>\n#include \"incopengl.hpp\"\n\n#include <myadt.hpp>\n#include <meshing.hpp>\n#include <csg.hpp>\n#include "
},
{
"path": "libsrc/csg/vscsg.hpp",
"chars": 884,
"preview": "#ifndef FILE_VSCSG\n#define FILE_VSCSG\n\n/**************************************************************************/\n/* F"
},
{
"path": "libsrc/csg/zrefine.cpp",
"chars": 17543,
"preview": "#include <mystdlib.h>\n#include \"meshing.hpp\"\n\n#include <csg.hpp>\n\nnamespace netgen\n{\n\n // find singular edges\n void Se"
},
{
"path": "libsrc/general/CMakeLists.txt",
"chars": 544,
"preview": "target_sources(nglib PRIVATE\n gzstream.cpp\n hashtabl.cpp\n mystring.cpp\n ngbitarray.cpp\n optmem.cpp\n pa"
},
{
"path": "libsrc/general/autodiff.hpp",
"chars": 7933,
"preview": "#ifndef FILE_AUTODIFF\n#define FILE_AUTODIFF\n\n/**************************************************************************"
},
{
"path": "libsrc/general/autoptr.hpp",
"chars": 985,
"preview": "braucht man nicht mehr\n\n#ifndef FILE_AUTOPTR\n#define FILE_AUTOPTR\n\n/****************************************************"
},
{
"path": "libsrc/general/dynamicmem.cpp",
"chars": 4019,
"preview": "#include <myadt.hpp>\n\nusing namespace std;\n\nnamespace netgen\n{\n\n BaseDynamicMem * BaseDynamicMem::first = 0;\n BaseDyna"
},
{
"path": "libsrc/general/dynamicmem.hpp",
"chars": 1951,
"preview": "not needed anymore ? \n\n\n#ifndef FILE_DYNAMICMEM\n#define FILE_DYNAMICMEM\n\n/**********************************************"
},
{
"path": "libsrc/general/gzstream.cpp",
"chars": 5311,
"preview": "// ============================================================================\n// gzstream, C++ iostream classes wrappi"
},
{
"path": "libsrc/general/gzstream.h",
"chars": 4762,
"preview": "// ============================================================================\n// gzstream, C++ iostream classes wrappi"
},
{
"path": "libsrc/general/hashtabl.cpp",
"chars": 6702,
"preview": "/**************************************************************************/\n/* File: hashtabl.cpp "
},
{
"path": "libsrc/general/hashtabl.hpp",
"chars": 31702,
"preview": "#ifndef FILE_HASHTABL\n#define FILE_HASHTABL\n\n/**************************************************************************"
},
{
"path": "libsrc/general/myadt.hpp",
"chars": 1078,
"preview": "#ifndef FILE_MYADT\n#define FILE_MYADT\n\n/**************************************************************************/\n/* F"
},
{
"path": "libsrc/general/mystring.cpp",
"chars": 8791,
"preview": "\n//**************************************************************\n//\n// filename: mystring.cpp\n//\n// project"
},
{
"path": "libsrc/general/mystring.hpp",
"chars": 4888,
"preview": "\n//**************************************************************\n//\n// filename: mystring.h\n//\n// project: "
},
{
"path": "libsrc/general/netgenout.hpp",
"chars": 3295,
"preview": "#ifndef NETGEN_OUT_STREAM_HPP__\n#define NETGEN_OUT_STREAM_HPP__\n\n// #include <ostream>\n// #include <mystdlib.h>\n// #incl"
},
{
"path": "libsrc/general/ngarray.hpp",
"chars": 17971,
"preview": "#ifndef NGARRAY_HPP_INCLUDED\n#define NGARRAY_HPP_INCLUDED\n\n/************************************************************"
},
{
"path": "libsrc/general/ngbitarray.cpp",
"chars": 1603,
"preview": "/**************************************************************************/\n/* File: bitarray.cc "
},
{
"path": "libsrc/general/ngbitarray.hpp",
"chars": 2629,
"preview": "#ifndef FILE_BitArray\n#define FILE_BitArray\n\n/**************************************************************************"
},
{
"path": "libsrc/general/ngpython.hpp",
"chars": 1676,
"preview": "#ifdef NG_PYTHON\n\n#include <core/python_ngcore.hpp>\n\n#include <pybind11/operators.h>\n#include <pybind11/numpy.h>\n#includ"
},
{
"path": "libsrc/general/optmem.cpp",
"chars": 1943,
"preview": "/**************************************************************************/\n/* File: optmem.cpp "
},
{
"path": "libsrc/general/optmem.hpp",
"chars": 909,
"preview": "#ifndef FILE_OPTMEM\n#define FILE_OPTMEM\n\n/**************************************************************************/\n/*"
},
{
"path": "libsrc/general/parthreads.cpp",
"chars": 725,
"preview": "/**************************************************************************/\r\n/* File: parthreads.cpp "
},
{
"path": "libsrc/general/parthreads.hpp",
"chars": 2702,
"preview": "#ifndef FILE_PARTHREADS\n#define FILE_PARTHREADS\n\n/**********************************************************************"
},
{
"path": "libsrc/general/seti.cpp",
"chars": 995,
"preview": "#include <mystdlib.h>\n#include <myadt.hpp>\n\n\nnamespace netgen\n{\n //using namespace netgen;\n\n IndexSet :: IndexSet (int"
},
{
"path": "libsrc/general/seti.hpp",
"chars": 927,
"preview": "#ifndef FILE_SETI\n#define FILE_SETI\n\n\n/**************************************************************************/\n/* Fi"
},
{
"path": "libsrc/general/sort.cpp",
"chars": 1691,
"preview": "/**************************************************************************/\n/* File: sort.cc "
},
{
"path": "libsrc/general/sort.hpp",
"chars": 1102,
"preview": "#ifndef FILE_SORT\n#define FILE_SORT\n\n/**************************************************************************/\n/* Fil"
},
{
"path": "libsrc/general/spbita2d.cpp",
"chars": 2937,
"preview": "/**************************************************************************/\n/* File: spbita2d.cpp "
},
{
"path": "libsrc/general/spbita2d.hpp",
"chars": 1243,
"preview": "#ifndef FILE_SPBITA2D\n#define FILE_SPBITA2D\n\n/**************************************************************************"
},
{
"path": "libsrc/general/stack.hpp",
"chars": 1662,
"preview": "#ifndef FILE_STACK\n#define FILE_STACK\n\n/*****************************************************************************/\n/"
},
{
"path": "libsrc/general/table.cpp",
"chars": 5261,
"preview": "/**************************************************************************/\n/* File: table.cpp "
},
{
"path": "libsrc/general/table.hpp",
"chars": 6346,
"preview": "#ifndef FILE_TABLE\n#define FILE_TABLE\n\n/**************************************************************************/\n/* F"
},
{
"path": "libsrc/general/template.hpp",
"chars": 9360,
"preview": "#ifndef FILE_TEMPLATE\n#define FILE_TEMPLATE\n\n/**************************************************************************"
},
{
"path": "libsrc/geom2d/CMakeLists.txt",
"chars": 335,
"preview": "target_sources(nglib PRIVATE\n csg2d.cpp\n genmesh2d.cpp\n geometry2d.cpp\n python_geom2d.cpp\n)\n\nif(USE_GUI)\n "
},
{
"path": "libsrc/geom2d/csg2d.cpp",
"chars": 57457,
"preview": "#include <iostream>\n#include <cstdlib>\n#include <cmath>\n#include <string>\n#include <set>\n\n#include \"csg2d.hpp\"\n\n// Polyg"
},
{
"path": "libsrc/geom2d/csg2d.hpp",
"chars": 17817,
"preview": "#ifndef NETGEN_CSG2D_HPP_INCLUDED\n#define NETGEN_CSG2D_HPP_INCLUDED\n\n#include <variant>\n\n#include \"geometry2d.hpp\"\n\nname"
},
{
"path": "libsrc/geom2d/genmesh2d.cpp",
"chars": 20865,
"preview": "#include <meshing.hpp>\n#include <geometry2d.hpp>\n\nnamespace netgen\n{\n // extern DLL_HEADER MeshingParameters mparam;\n\n "
},
{
"path": "libsrc/geom2d/geom2dpkg.cpp",
"chars": 1147,
"preview": "#include <meshing.hpp>\n#include <geometry2d.hpp>\n#include <visual.hpp>\n#include <inctcl.hpp>\n\n#include \"vsgeom2d.hpp\"\n\n/"
},
{
"path": "libsrc/geom2d/geometry2d.cpp",
"chars": 26536,
"preview": "/*\n\n2d Spline curve for Mesh generator\n\n*/\n\n#include <meshing.hpp>\n#include <geometry2d.hpp>\n#include <core/register_arc"
},
{
"path": "libsrc/geom2d/geometry2d.hpp",
"chars": 7237,
"preview": "#ifndef FILE_GEOMETRY2D\n#define FILE_GEOMETRY2D\n\n/* ********************************************************************"
},
{
"path": "libsrc/geom2d/python_geom2d.cpp",
"chars": 20923,
"preview": "#ifdef NG_PYTHON\r\n\r\n#include \"../general/ngpython.hpp\"\r\n#include \"../core/python_ngcore.hpp\"\r\n#include \"../meshing/pytho"
},
{
"path": "libsrc/geom2d/spline2d.hpp",
"chars": 5869,
"preview": "\n\n\n\ndas File sollte nicht mehr verwendet werden ---> spline.hpp\n\n\n\n\n\n\n\n#ifndef FILE_SPLINE2D\n#define FILE_SPLINE2D\n\n/***"
},
{
"path": "libsrc/geom2d/vsgeom2d.cpp",
"chars": 2284,
"preview": "#include <meshing.hpp>\n#include <geometry2d.hpp>\n#include <visual.hpp>\n\n#include \"vsgeom2d.hpp\"\n\nnamespace netgen\n{\n\n\n "
},
{
"path": "libsrc/geom2d/vsgeom2d.hpp",
"chars": 834,
"preview": "#ifndef FILE_VSGEOM2D\n#define FILE_VSGEOM2D\n\n/**************************************************************************"
},
{
"path": "libsrc/gprim/CMakeLists.txt",
"chars": 409,
"preview": "target_sources(nglib PRIVATE\n adtree.cpp\n geom2d.cpp\n geom3d.cpp\n geomfuncs.cpp\n geomtest3d.cpp\n splin"
},
{
"path": "libsrc/gprim/adtree.cpp",
"chars": 44054,
"preview": "#include <mystdlib.h>\n\n\n#include <myadt.hpp>\n// class DenseMatrix;\n#include <gprim.hpp>\n\nnamespace netgen\n{\n\n\n /* *****"
},
{
"path": "libsrc/gprim/adtree.hpp",
"chars": 31671,
"preview": "#ifndef FILE_ADTREE\n#define FILE_ADTREE\n\n/* *************************************************************************/\n/"
},
{
"path": "libsrc/gprim/geom2d.cpp",
"chars": 5422,
"preview": "#include <mystdlib.h>\n\n#include <myadt.hpp>\n#include <gprim.hpp>\n\nnamespace netgen\n{\n\nostream & operator<<(ostream & s,"
},
{
"path": "libsrc/gprim/geom2d.hpp",
"chars": 20972,
"preview": "#ifndef FILE_GEOM2D\n#define FILE_GEOM2D\n\n/* *************************************************************************/\n/"
},
{
"path": "libsrc/gprim/geom3d.cpp",
"chars": 15985,
"preview": "#include <algorithm>\n#include <mystdlib.h>\n\n#include <myadt.hpp>\n#include <gprim.hpp>\n\nnamespace netgen\n{\nostream & oper"
},
{
"path": "libsrc/gprim/geom3d.hpp",
"chars": 18993,
"preview": "#ifndef FILE_GEOM3D\n#define FILE_GEOM3D\n\n/* *************************************************************************/\n/"
}
]
// ... and 490 more files (download for full content)
About this extraction
This page contains the full source code of the NGSolve/netgen GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 690 files (10.1 MB), approximately 2.7M tokens, and a symbol index with 7050 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.