mlhp 0.0.0__tar.gz

mlhp-0.0.0/.git

@@ -0,0 +1 @@
+gitdir: ../.git/modules/mlhp

mlhp-0.0.0/.gitignore

@@ -0,0 +1,9 @@
+*.vscode
+*.swp
+*.vs
+CMakeSettings.json
+out/
+build/
+html/
+latex/
+dist/

mlhp-0.0.0/.gitlab-ci.yml

@@ -0,0 +1,97 @@
+# This file is part of the mlhp project. License: See LICENSE
+
+image: registry.gitlab.com/phmkopp/mlhp/ubuntu21.04
+
+.build_linux:
+
+  stage: build
+
+  script:
+
+  - git submodule update --init --recursive
+
+  - ${CXX_COMPILER} --version
+  - echo "${CellIndexSize}"
+  - echo "${DofIndexSize}"
+  - export CXXFLAGS="-Werror ${CXXFLAGS}"
+  
+  # Configure & generate build project
+  - cmake -H"." 
+      -D MLHP_DEBUG_CHECKS=ON 
+      -D MLHP_ENABLE_EXAMPLES=ON 
+      -D MLHP_ENABLE_EXAMPLES=ON 
+      -D MLHP_ENABLE_CPP_EXAMPLE_FICHERA_CORNER=ON 
+      -D MLHP_ENABLE_CPP_EXAMPLE_WING_ELASTIC_FCM=ON 
+      -D MLHP_ENABLE_CPP_EXAMPLE_TRAVELLING_HEAT_SOURCE=ON 
+      -D MLHP_ENABLE_PYTHONBINDINGS=ON 
+      -D MLHP_ENABLE_OMP=On
+      -D MLHP_INDEX_SIZE_CELLS=${CellIndexSize}
+      -D MLHP_INDEX_SIZE_DOFS=${DofIndexSize}
+      -D CMAKE_CXX_COMPILER=${CXX_COMPILER} 
+      -B "build"
+  
+  # Invoke build in build subdirectory
+  - cmake --build "build" -- -j$(nproc) 
+  
+  artifacts:
+    paths:
+      - build/bin
+      - build/lib
+      - build/testfiles
+      
+  only:
+  - master
+  - merge_requests
+
+.test_linux:
+  stage: test
+
+  script:
+  - cd build
+  - ./bin/mlhpcore_testrunner
+  - ./bin/system_testrunner
+  - python3 ./bin/run_systemtests.py
+
+  only:
+  - master
+  - merge_requests
+
+build_gcc:
+  extends: .build_linux
+    
+  before_script:
+  - CXX_COMPILER=g++-10
+  - CellIndexSize=32
+  - DofIndexSize=64
+  - export CXXFLAGS="-Wno-error=suggest-attribute=pure"
+
+test_gcc:
+  extends: .test_linux
+  needs: 
+    - job: build_gcc
+      artifacts: true
+
+build_clang:
+  extends: .build_linux
+  
+  before_script:
+  - CXX_COMPILER=clang++-13
+  - CellIndexSize=16
+  - DofIndexSize=32
+  
+test_clang:
+  extends: .test_linux
+  needs: 
+    - job: build_clang
+      artifacts: true
+   
+pages:
+  stage: deploy
+  script:
+  - doxygen tools/doxygen/Doxyfile 
+  - mv html/ public/
+  artifacts:
+    paths:
+    - public
+  only:
+  - master

mlhp-0.0.0/.gitmodules

@@ -0,0 +1,6 @@
+[submodule "external/vtu11"]
+	path = external/vtu11
+	url = https://github.com/phmkopp/vtu11.git
+[submodule "required/pybind11"]
+	path = external/pybind11
+	url = https://github.com/pybind/pybind11.git

mlhp-0.0.0/.mailmap

@@ -0,0 +1,4 @@
+Philipp Kopp <phmkopp@gmail.com>
+Philipp Kopp <phmkopp@gmail.com> <philipp.kopp@tum.de>
+Philipp Kopp <phmkopp@gmail.com> <ga49sos2@htcer10c05s09.cos.lrz.de>
+Philipp Kopp <phmkopp@gmail.com> <philipp.kopp@tum.de>

mlhp-0.0.0/CMakeLists.txt

@@ -0,0 +1,193 @@
+# This file is part of the mlhp project. License: See LICENSE
+
+cmake_minimum_required( VERSION 3.12 )
+
+project( mlhp LANGUAGES CXX )
+
+# Find out if mlhp is the root CMake project or not
+get_directory_property( hasParent PARENT_DIRECTORY)
+string( COMPARE EQUAL "${hasParent}" "" MLHP_IS_ROOT )
+
+# ------------------- set project variables -----------------------
+
+option( BUILD_SHARED_LIBS "Build shared library" ON )
+option( MLHP_DEBUG_CHECKS "Enable debug checks with (hopefully) minor performance penalty." ON )
+option( MLHP_ALL_OPTIMIZATIONS "Compile with all optimizations, including platform specific ones" ON )
+
+option( MLHP_ENABLE_PYTHONBINDINGS "Enable pybind11 based python interface" OFF )
+option( MLHP_ENABLE_TESTS "Enable unit-tests and system tests if also python bindings are ON." ${MLHP_IS_ROOT} )
+option( MLHP_ENABLE_EXAMPLES "Enable example drivers." OFF )
+option( MLHP_ENABLE_OMP "Compile with shared memory parallelism." ON )
+
+set( MLHP_DIMENSIONS_TO_INSTANTIATE "1, 2, 3, 4" CACHE STRING "List of spatial dimensions to compile." )
+
+set( MLHP_BUILD_ARCHIVE_DIR ${CMAKE_BINARY_DIR}/lib CACHE PATH "Build directory for static libs." )
+set( MLHP_BUILD_LIBRARY_DIR ${CMAKE_BINARY_DIR}/lib CACHE PATH "Build directory for dynamic libs." )
+set( MLHP_BUILD_BINARY_DIR ${CMAKE_BINARY_DIR}/bin CACHE PATH "Build directory for binaries." )
+
+set( MLHP_SIMD_ALIGNMENT 32 CACHE STRING "Simd over-alignment 32 or 64, depending on cache line size of the CPU." )
+set( MLHP_INDEX_SIZE_CELLS 32 CACHE STRING "Unsigned integer size used to index mesh cells." )
+set( MLHP_INDEX_SIZE_DOFS 32 CACHE STRING "Unsigned integer size used to index degrees of freedom and sparse indices." )
+
+mark_as_advanced( MLHP_BUILD_ARCHIVE_DIR MLHP_BUILD_LIBRARY_DIR MLHP_BUILD_BINARY_DIR
+                  MLHP_INDEX_SIZE_CELLS MLHP_INDEX_SIZE_DOFS )
+
+set( MLHP_OUTPUT_DIRS ARCHIVE_OUTPUT_DIRECTORY ${MLHP_BUILD_ARCHIVE_DIR}
+                      LIBRARY_OUTPUT_DIRECTORY ${MLHP_BUILD_LIBRARY_DIR}
+                      RUNTIME_OUTPUT_DIRECTORY ${MLHP_BUILD_BINARY_DIR} )
+       
+# Changes the default install path to build/install, assuming build is the project directory
+if ( CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT )
+    set ( CMAKE_INSTALL_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/install" CACHE PATH "default install path" FORCE )
+endif( )
+
+# Set up build types with Release as default
+include(tools/cmake/ConfigureBuildType.cmake)
+
+# ---------------------------- Core -------------------------------
+
+# Provides interface target vtu11::vtu11
+add_subdirectory(external/vtu11)
+
+# Create mlhp_public_compile_flags and mlhp_private_compile_flags interface targets
+include(tools/cmake/ConfigureCompiler.cmake)
+
+# Configure the explicit template instantiation of space dimensions
+include(tools/cmake/ConfigureInstantiation.cmake)
+
+# To automatically configure a library export header into build tree
+include(GenerateExportHeader)
+
+# Sets MLHP_CORE_SOURCES and MLHP_CORE_INCLUDES
+include( src/core/files.cmake )
+
+list( TRANSFORM MLHP_CORE_SOURCES PREPEND src/core/ )
+list( TRANSFORM MLHP_CORE_INCLUDES PREPEND include/mlhp/core/ )
+
+add_library( mlhpcore ${MLHP_CORE_SOURCES} ${MLHP_CORE_INCLUDES} include/mlhp/core.hpp )
+add_library( mlhp::core ALIAS mlhpcore )
+
+target_link_libraries( mlhpcore PRIVATE mlhp_private_compile_flags vtu11::vtu11
+                                PUBLIC mlhp_public_compile_flags )
+
+target_include_directories( mlhpcore PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include 
+                                            ${CMAKE_CURRENT_BINARY_DIR}/include )   
+# Not sure what this does: $<INSTALL_INTERFACE:include>
+
+generate_export_header( mlhpcore EXPORT_MACRO_NAME MLHP_EXPORT EXPORT_FILE_NAME 
+                        ${CMAKE_CURRENT_BINARY_DIR}/include/mlhp/core/coreexport.hpp )
+
+# Set output directories
+set_target_properties( mlhpcore PROPERTIES ${MLHP_OUTPUT_DIRS} )
+
+install( TARGETS mlhpcore
+         EXPORT mlhpcore-targets
+         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+         INCLUDES DESTINATION ${LIBLEGACY_INCLUDE_DIRS} )
+
+# install( DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/mlhp
+#          DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/ )
+#         
+# install( DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/include/mlhp
+#          DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/ )
+
+# ----------------------- Core testrunner -------------------------
+
+if( ${MLHP_ENABLE_TESTS} )
+
+    # Creates MLHP_CORE_TEST_SOURCES variable
+    include( tests/core/files.cmake )
+    include( tests/system/files.cmake )
+
+    list( TRANSFORM MLHP_CORE_TEST_SOURCES PREPEND tests/core/ )
+    list( TRANSFORM MLHP_SYSTEM_TEST_SOURCES PREPEND tests/system/ )
+
+    add_executable( mlhpcore_testrunner ${MLHP_CORE_TEST_SOURCES} )
+
+    target_link_libraries( mlhpcore_testrunner PRIVATE mlhp::core mlhp_private_compile_flags )
+
+    target_include_directories( mlhpcore_testrunner PRIVATE . )   
+
+    file( GLOB MLHP_CORE_TESTFILES tests/core/testfiles/* )
+    file( COPY ${MLHP_CORE_TESTFILES} DESTINATION testfiles/core )
+
+    # Set output directories
+    set_target_properties( mlhpcore_testrunner PROPERTIES ${MLHP_OUTPUT_DIRS} )
+  
+    # Setup system tests
+    add_executable( system_testrunner ${MLHP_SYSTEM_TEST_SOURCES} )
+                    
+    target_link_libraries( system_testrunner PRIVATE mlhp::core mlhp_private_compile_flags )
+    
+    target_include_directories( system_testrunner PRIVATE . )   
+    
+    set_target_properties( system_testrunner PROPERTIES ${MLHP_OUTPUT_DIRS} )
+  
+endif( ${MLHP_ENABLE_TESTS} )
+
+# --------------------------- Examples ----------------------------
+
+include( tools/cmake/CreateExampleDriver.cmake )
+
+CreateExampleCppDriver( fichera_corner "Poisson equation fichera corner benchmark." )
+CreateExampleCppDriver( travelling_heat_source "Linear heat equation with moving point-like source." )
+CreateExampleCppDriver( wing_elastic_fcm "FCM example with linear elasticity." )
+
+CreateExamplePythonDriver( example_fcm "Placeholder fcm example." )
+CreateExamplePythonDriver( example_gmsh "Compute with unstructured grid from gmsh file." )
+
+# ----------------------- Python bindings -------------------------
+
+if( ${MLHP_ENABLE_PYTHONBINDINGS} )
+
+    add_subdirectory( external/pybind11 )
+
+    # Creates MLHP_PYTHON_BINDING_SOURCES variable
+    include( src/python/files.cmake )
+
+    list( TRANSFORM MLHP_PYTHON_BINDING_SOURCES PREPEND src/python/ )
+
+    pybind11_add_module( pymlhpcore ${MLHP_PYTHON_BINDING_SOURCES} )
+
+    target_link_libraries( pymlhpcore PRIVATE mlhpcore mlhp_private_compile_flags )
+    
+    target_include_directories( pymlhpcore PRIVATE . )
+
+    # Set output directories
+    set_target_properties( pymlhpcore PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${MLHP_BUILD_BINARY_DIR} )
+
+    # After building pymlhpcore write file bin/mlhpPath.py containing directory of python module
+    add_custom_command( TARGET pymlhpcore POST_BUILD COMMAND ${CMAKE_COMMAND} -E echo 
+      "$<TARGET_FILE_DIR:pymlhpcore>" > ${MLHP_BUILD_BINARY_DIR}/mlhpPythonPath )
+
+    # Copy python sources
+    file( COPY src/python/mlhp.py DESTINATION ${MLHP_BUILD_BINARY_DIR} )
+
+    #install( TARGETS pymlhpcore
+    #         EXPORT pymlhpcore-targets
+    #         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    #         LIBRARY DESTINATION ${CMAKE_INSTALL_BINDIR}
+    #         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} )
+
+	# This install works for building with scikit-build-core
+	install( TARGETS pymlhpcore LIBRARY DESTINATION . )
+	install( FILES src/python/mlhp.py DESTINATION . )
+ 
+endif( ${MLHP_ENABLE_PYTHONBINDINGS} )
+
+if( ${MLHP_ENABLE_PYTHONBINDINGS} AND ${MLHP_ENABLE_TESTS} )
+
+    # Creates MLHP_PYTHON_TESTS variable
+    include( tests/system/files.cmake )
+
+    list( TRANSFORM MLHP_PYTHON_TESTS PREPEND tests/system/ )
+            
+    file( COPY ${MLHP_PYTHON_TESTS} DESTINATION ${MLHP_BUILD_BINARY_DIR}/systemtests )
+    file( COPY tests/system/run_systemtests.py DESTINATION ${MLHP_BUILD_BINARY_DIR} )
+        
+endif( ${MLHP_ENABLE_PYTHONBINDINGS} AND ${MLHP_ENABLE_TESTS} )
+
+# Configure configuration header to build tree
+configure_file( src/core/config.hpp.in include/mlhp/core/config.hpp )

mlhp-0.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Philipp Kopp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mlhp-0.0.0/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.1
+Name: mlhp
+Version: 0.0.0
+Summary: A work-in-progress finite element library.
+Author: Philipp Kopp
+Classifier: License :: OSI Approved :: MIT License
+Project-URL: Homepage, https://gitlab.com/phmkopp/mlhp
+Project-URL: Issues, https://github.com/phmkopp/mlhp/issues
+Description-Content-Type: text/markdown
+
+## About
+
+Mlhp is a C++ library with python bindings that implements multi-level _hp_- and other finite element methods efficiently also for dimensions > 3. The project is still very much work in progress and therefore does not have an extensive documentation.
+
+## Submodules
+
+The header-only libraries [pybind11](https://pybind11.readthedocs.io/en/stable/), [Catch2](https://github.com/catchorg/Catch2), and [vtu11](https://github.com/phmkopp/vtu11) are included as git submodules. To clone them resursively, use: 
+```
+git clone --recursive https://gitlab.com/phmkopp/mlhp.git
+```
+
+## Getting started
+- [Compiler and platform support](https://gitlab.com/phmkopp/mlhp/-/wikis/Compiler%20and%20platform%20support) 
+- [Setting up an executable that uses mlhp](https://gitlab.com/phmkopp/mlhp/-/wikis/Setting%20up%20an%20executable%20that%20uses%20mlhp).
+- [Core class structure](https://gitlab.com/phmkopp/mlhp/-/wikis/Core%20class%20structure)
+- [Doxygen documentation](https://phmkopp.gitlab.io/mlhp)
+
+## References and publications
+
+If you use our code for your scientific research, please acknowledge this by referring to the following publication:
+
+P. Kopp, E. Rank, V. M. Calo, S. Kollmannsberger, 2022: Efficient multi-level hp-finite elements in arbitrary dimensions, Computer Methods in Applied Mechanics and Engineering, Volume 401, Part B, 115575, DOI: [10.1016/j.cma.2022.115575](https://doi.org/10.1016/j.cma.2022.115575)
+
+Here are some of the publications using this project:
+
+- V. Holla, P. Kopp, J. Grünewald; P. Praegla, C. Meier, K. Wudy, S. Kollmannsberger, 2023: Laser beam shape optimization: Exploring alternative profiles to Gaussian-shaped laser beams in powder bed fusion of metals, 2023 International Solid Freeform Fabrication Symposium, 
+DOI: [10.26153/TSW/50986](https://doi.org/10.26153/TSW/50986)
+- V. Holla, P. Kopp, J. Grünewald, K. Wudy, S. Kollmannsberger, 2023: Laser beam shape optimization in powder bed fusion of metals, Additive Manufacturing, Volume 72, 103609, DOI: [10.1016/j.addma.2023.103609](https://doi.org/10.1016/j.addma.2023.103609)
+- P. Kopp, V. M. Calo, E. Rank, S. Kollmannsberger, 2022: Space-time hp-finite elements for heat evolution in laser powder bed fusion additive manufacturing, Engineering with Computers, Volume 38, pages 4879–4893, DOI: [10.1007/s00366-022-01719-1](https://doi.org/10.1007/s00366-022-01719-1)
+- S. Kollmannsberger; P. Kopp, 2021: On accurate time integration for temperature evolutions in additive manufacturing, GAMM-Mitteilungen, Volume 44, Issue 4, DOI: [10.1002/gamm.202100019](https://doi.org/10.1002/gamm.202100019)

mlhp-0.0.0/README.md

@@ -0,0 +1,30 @@
+## About
+
+Mlhp is a C++ library with python bindings that implements multi-level _hp_- and other finite element methods efficiently also for dimensions > 3. The project is still very much work in progress and therefore does not have an extensive documentation.
+
+## Submodules
+
+The header-only libraries [pybind11](https://pybind11.readthedocs.io/en/stable/), [Catch2](https://github.com/catchorg/Catch2), and [vtu11](https://github.com/phmkopp/vtu11) are included as git submodules. To clone them resursively, use: 
+```
+git clone --recursive https://gitlab.com/phmkopp/mlhp.git
+```
+
+## Getting started
+- [Compiler and platform support](https://gitlab.com/phmkopp/mlhp/-/wikis/Compiler%20and%20platform%20support) 
+- [Setting up an executable that uses mlhp](https://gitlab.com/phmkopp/mlhp/-/wikis/Setting%20up%20an%20executable%20that%20uses%20mlhp).
+- [Core class structure](https://gitlab.com/phmkopp/mlhp/-/wikis/Core%20class%20structure)
+- [Doxygen documentation](https://phmkopp.gitlab.io/mlhp)
+
+## References and publications
+
+If you use our code for your scientific research, please acknowledge this by referring to the following publication:
+
+P. Kopp, E. Rank, V. M. Calo, S. Kollmannsberger, 2022: Efficient multi-level hp-finite elements in arbitrary dimensions, Computer Methods in Applied Mechanics and Engineering, Volume 401, Part B, 115575, DOI: [10.1016/j.cma.2022.115575](https://doi.org/10.1016/j.cma.2022.115575)
+
+Here are some of the publications using this project:
+
+- V. Holla, P. Kopp, J. Grünewald; P. Praegla, C. Meier, K. Wudy, S. Kollmannsberger, 2023: Laser beam shape optimization: Exploring alternative profiles to Gaussian-shaped laser beams in powder bed fusion of metals, 2023 International Solid Freeform Fabrication Symposium, 
+DOI: [10.26153/TSW/50986](https://doi.org/10.26153/TSW/50986)
+- V. Holla, P. Kopp, J. Grünewald, K. Wudy, S. Kollmannsberger, 2023: Laser beam shape optimization in powder bed fusion of metals, Additive Manufacturing, Volume 72, 103609, DOI: [10.1016/j.addma.2023.103609](https://doi.org/10.1016/j.addma.2023.103609)
+- P. Kopp, V. M. Calo, E. Rank, S. Kollmannsberger, 2022: Space-time hp-finite elements for heat evolution in laser powder bed fusion additive manufacturing, Engineering with Computers, Volume 38, pages 4879–4893, DOI: [10.1007/s00366-022-01719-1](https://doi.org/10.1007/s00366-022-01719-1)
+- S. Kollmannsberger; P. Kopp, 2021: On accurate time integration for temperature evolutions in additive manufacturing, GAMM-Mitteilungen, Volume 44, Issue 4, DOI: [10.1002/gamm.202100019](https://doi.org/10.1002/gamm.202100019)

mlhp-0.0.0/examples/example_fcm.py

@@ -0,0 +1,69 @@
+import mlhp
+
+D = 3
+
+print( "1. Setting up mesh and basis", flush=True )
+
+refinementDepth = 0
+polynomialDegree = 2
+nelements = [10] * D
+lengths = [1.0] * D
+
+alphaFCM = 1e-3 # needs better preconditioning
+
+domain = mlhp.invert( mlhp.makeImplicitCube( [0.0,0.101,0.101], [1.0, 0.899, 0.899] ) )
+
+strategy = mlhp.refineTowardsBoundary( domain, refinementDepth )
+
+grid = mlhp.makeRefinedGrid( nelements, lengths )
+grid.refine( strategy )
+
+basis = mlhp.makeHpTensorSpace( grid, polynomialDegree, nfields=D )
+
+print( "2. Computing dirichlet boundary conditions", flush=True )
+
+dirichletFunction = mlhp.makeConstantFunction( D, 0.0 )
+
+dirichlet = mlhp.integrateDirichletDofs( [dirichletFunction]*3, basis, [0] )
+
+print( "3. Setting up physics", flush=True )
+
+E = mlhp.makeConstantFunction( D, 200 * 1e9 )
+nu = mlhp.makeConstantFunction( D, 0.3 )
+rhs = mlhp.makeConstantFunction( D, [0.0, 0.0, 78.5 * 1e3] )
+
+kinematics = mlhp.makeSmallStrainKinematics( D ) 
+constitutive = mlhp.makeIsotropicElasticMaterial( E, nu )
+integrand = mlhp.makeIntegrand( kinematics, constitutive, rhs )
+
+print( "4. Allocating linear system", flush=True )
+
+matrix = mlhp.allocateUnsymmetricSparseMatrix( basis, dirichlet[0] )
+vector = mlhp.allocateVectorWithSameSize( matrix )
+
+print( "5. Integrating linear system", flush=True )
+
+quadrature = mlhp.makeMomentFittingQuadrature( domain, 
+    depth=polynomialDegree + 1, epsilon=alphaFCM )
+
+mlhp.integrateOnDomain( basis, integrand, [matrix, vector], 
+    dirichletDofs=dirichlet, quadrature=quadrature )
+
+print( "6. Solving linear system", flush=True )
+
+P = mlhp.makeAdditiveSchwarzPreconditioner( matrix, basis, dirichlet[0] )
+#P = mlhp.makeDiagonalPreconditioner( matrix )
+
+interiorDofs, norms = mlhp.cg( matrix, vector, preconditioner=P, maxit=1000, residualNorms=True )
+
+allDofs = mlhp.inflateDofs( interiorDofs, dirichlet )
+
+print( "7. Postprocessing solution", flush=True )
+
+processors = [mlhp.makeSolutionProcessor( D, allDofs, "Displacement" ),
+              mlhp.makeFunctionProcessor( domain )]
+
+postmesh = mlhp.createGridOnCells( [polynomialDegree + 3] * D )
+writer = mlhp.PVtuOutput( filename="outputs/linear_elasticity" )
+            
+mlhp.writeBasisOutput( basis, postmesh, writer, processors )

mlhp-0.0.0/examples/example_gmsh.py

@@ -0,0 +1,93 @@
+import mlhp 
+import sys 
+import numpy 
+import gmshparser
+
+assert( len( sys.argv ) == 2 )
+
+print( "1. Reading mesh", flush=True )
+
+mesh = gmshparser.parse( sys.argv[1] )
+
+vertices = numpy.array( [node.get_coordinates( ) for entity in mesh.get_node_entities( ) for node in entity.get_nodes( )] )
+cells = [element.get_connectivity( ) for entity in mesh.get_element_entities( ) for element in entity.get_elements( )]
+types = numpy.array([entity.get_element_type( ) for entity in mesh.get_element_entities( ) for element in entity.get_elements( )])
+
+# Mesh is 3D
+if numpy.any(types == 4) or numpy.any(types == 5):
+    vertices = [vertex[:3] for vertex in vertices]
+    # https://gmsh.info/dev/doc/texinfo/gmsh.pdf page 362/372
+    hexes = [[cell[0], cell[1], cell[3], cell[2], cell[4], cell[5], cell[7], cell[6]]\
+        for type, cell in zip(types, cells) if type == 5]
+    cells = hexes + [cell for type, cell in zip(types, cells) if type == 4]
+    
+# Mesh is 2D
+elif numpy.any(types == 2) or numpy.any(types == 3):
+    vertices = [vertex[:2] for vertex in vertices]
+    quads = [[cell[0], cell[1], cell[3], cell[2]] for type, cell in zip(types, cells) if type == 3]
+    cells = quads + [cell for type, cell in zip(types, cells) if type == 2]
+else:
+    RuntimeError("Did not find 2- or 3D cubic or simplex elements")
+    
+offsets = numpy.cumsum( [0] + [len(cell) for cell in cells] )
+cells = numpy.array( [id for cell in cells for id in cell] ) - 1
+
+print( "2. Setting up mesh and basis", flush=True )
+
+mesh = mlhp.makeUnstructuredMesh( vertices, cells, offsets )
+
+ndim = mesh.ndim( )
+nfields = ndim
+
+basis = mlhp.makeUnstructuredBasis( mesh, nfields )
+
+print( mesh )
+print( basis )
+
+print( "3. Computing dirichlet boundary conditions", flush=True )
+
+dirichletFunction = mlhp.makeConstantFunction( ndim, 0.0 )
+
+dirichlet = mlhp.integrateDirichletDofs( [dirichletFunction] * nfields, basis, [0] )
+
+print( "4. Setting up physics", flush=True )
+
+E = mlhp.makeConstantFunction( ndim, 200 * 1e9 )
+nu = mlhp.makeConstantFunction( ndim, 0.3 )
+rhs = mlhp.makeConstantFunction( ndim, [0.0] * (ndim - 1) + [-1.0] )
+
+if ndim == 3:
+    constitutive = mlhp.makeIsotropicElasticMaterial( E, nu )
+if ndim == 2:
+    constitutive = mlhp.makePlaneStressMaterial( E, nu )
+    
+kinematics = mlhp.makeSmallStrainKinematics( ndim ) 
+integrand = mlhp.makeIntegrand( kinematics, constitutive, rhs )
+
+print( "5. Allocating linear system", flush=True )
+
+matrix = mlhp.allocateUnsymmetricSparseMatrix( basis, dirichlet[0] )
+vector = mlhp.allocateVectorWithSameSize( matrix )
+
+print( "6. Integrating linear system", flush=True )
+
+mlhp.integrateOnDomain( basis, integrand, [matrix, vector], 
+    dirichletDofs=dirichlet )
+
+print( "7. Solving linear system", flush=True )
+
+P = mlhp.makeDiagonalPreconditioner( matrix )
+
+interiorDofs, norms = mlhp.cg( matrix, vector, preconditioner=P, maxit=5000, residualNorms=True )
+
+allDofs = mlhp.inflateDofs( interiorDofs, dirichlet )
+
+print( "8. Postprocessing solution", flush=True )
+
+processors = [mlhp.makeSolutionProcessor( ndim, allDofs, "Displacement" ),
+              mlhp.makeVonMisesProcessor( allDofs, kinematics, constitutive )]
+
+postmesh = mlhp.createGridOnCells( [1] * ndim )
+writer = mlhp.PVtuOutput( filename="outputs/example_gmsh" )
+            
+mlhp.writeBasisOutput( basis, postmesh, writer, processors )

mlhp-0.0.0/examples/fichera_corner.cpp

@@ -0,0 +1,98 @@
+// This file is part of the mlhp project. License: See LICENSE
+
+#include "mlhp/core.hpp"
+
+int main( )
+{
+    using namespace mlhp;
+
+    static constexpr size_t D = 2;
+
+    // Analytical solution
+    auto solution = solution::singularSolution<D>( );
+    auto solutionDerivatives = solution::singularSolutionDerivatives<D>( );
+    auto source = solution::singularSolutionSource<D>( );
+
+    // Create and refine grid
+    auto nelements = array::makeSizes<D>( 2 );
+    auto lengths = array::make<D>( 1.0 );
+
+    auto grid = makeRefinedGrid( nelements, lengths );
+
+    size_t nlevels = 20;
+
+    auto collapsedCircle = implicit::sphere<D>( array::make<D>( 0.0 ), 1e-10 );
+    auto refinementStrategy = refineTowardsDomainBoundary( collapsedCircle, nlevels );
+
+    grid->refine( refinementStrategy );
+
+    print( *grid, std::cout );
+
+    // Create multi-level hp basis on refined grid
+    auto grading = UniformGrading { nlevels }; // fekernel::LinearGrading { 1 }
+
+    using AnsatzSpace = TrunkSpace; // TensorSpace
+
+    auto basis = makeHpBasis<AnsatzSpace>( grid, grading );
+
+    print( *basis, std::cout );
+
+    // Boundary conditions
+    std::vector<size_t> faces;
+
+    for( size_t axis = 0; axis < D; ++axis )
+    {
+        faces.push_back( boundary::face( axis, 1 ) );
+    }
+
+    auto boundaryDofs = boundary::boundaryDofs<D>( solution, *basis, faces );
+
+    // Allocate sparse linear system
+    auto matrix = allocateMatrix<linalg::UnsymmetricSparseMatrix>( *basis, boundaryDofs.first );
+    
+    std::vector<double> F( matrix.size1( ), 0.0 );
+    
+    linalg::print( matrix, std::cout );
+
+    // Integrate system
+    auto conductivity = spatial::constantFunction<D>( 1.0 );
+
+    auto integrand = makePoissonIntegrand( conductivity, source );
+
+    integrateOnDomain( *basis, integrand, { matrix, F }, boundaryDofs );
+
+    // Solve equation system
+    auto interiorSolution = linalg::makeCGSolver( 1e-10 )( matrix, F );
+
+    auto fullSolution = boundary::inflate( interiorSolution, boundaryDofs );
+
+    // Write .vtu output
+    if constexpr( D <= 3 )
+    {
+        auto nsamples = array::makeSizes<D>( 10 );
+
+        auto numerical = makeSolutionProcessor<D>( fullSolution );
+        auto analytical = makeFunctionProcessor<D>( solution, "AnalyticalSolution" );
+        auto rhs = makeFunctionProcessor<D>( source, "Source" );
+            
+        auto path = "outputs/singular_" + std::to_string( D ) + "D_" + std::to_string( nlevels ) + ".vtu";
+        auto postmesh = createGridOnCells( nsamples );
+
+        writeOutput( *basis, postmesh, std::tuple { numerical, analytical, rhs }, VtuOutput { path } );
+    }
+    
+    // Integrate errors with p + 3 points
+    //auto l2ErrorIntegrand = makeL2ErrorIntegrand( fullSolution, solution );
+    auto energyErrorIntegrand = makeEnergyErrorIntegrand( fullSolution, solutionDerivatives );
+
+    //auto l2Integrals = ErrorIntegrals { };
+    auto energyIntegrals = ErrorIntegrals { };
+
+    integrateOnDomain( *basis, energyErrorIntegrand, energyIntegrals, makeIntegrationOrderDeterminor<D>( 3 ) );
+
+    double percent = energyIntegrals.relativeDifference( ) * 100.0;
+
+    std::cout << "Number of internal dofs : " << interiorSolution.size( ) << std::endl;
+    std::cout << "Energy error || u - u^h || / || u || * 100% : " << percent << std::endl;
+}
+