%global _empty_manifest_terminate_build 0 Name: python-overlap Version: 0.1.0 Release: 1 Summary: Exact calculation of the overlap volume and area of spheres and mesh elements License: GPLv3 URL: https://github.com/severinstrobl/overlap Source0: https://mirrors.nju.edu.cn/pypi/web/packages/ba/f4/be3068aaaf11bf295826f7438db2e0fe073dcce679c62c35c4d2d6c65c05/overlap-0.1.0.tar.gz Requires: python3-numpy %description # Exact calculation of the overlap volume and area of spheres and mesh elements ![Build Status](https://img.shields.io/github/workflow/status/severinstrobl/overlap/CI%20build%20Linux) [![codecov](https://codecov.io/gh/severinstrobl/overlap/branch/master/graph/badge.svg?token=GQ2L62OXXK)](https://codecov.io/gh/severinstrobl/overlap) [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](./COPYING) [![DOI](https://img.shields.io/badge/DOI-10.1016/j.jcp.2016.02.003-blue.svg)](https://dx.doi.org/10.1016/j.jcp.2016.02.003) Calculating the intersection or overlapping volume of a sphere and one of the typically used mesh elements such as a tetrahedron or hexahedron is surprisingly challenging. This header-only library implements a numerically robust method to determine this volume. The mathematical expressions and algorithms used in this code are described in [S. Strobl et al.: Exact calculation of the overlap volume of spheres and mesh elements, Journal of Computational Physics, 2016](https://dx.doi.org/10.1016/j.jcp.2016.02.003). So if you use the code in projects resulting in any publications, please cite this paper. Employing the concepts and routines used for the calculation of the overlap volume, the intersection or overlap *area* of a sphere and the facets of a mesh element can also be calculated with this library. # Usage ## Supported primitives The overlap calculation directly supports these element types: - tetrahedra (4 nodes/vertices, data type `Tetrahedron`) - pentahedra/wedges/triangular prisms (5 nodes/vertices, data type `Wedge`) - hexahedra (6 nodes/vertices, data type `Hexahedron`) The elements must be convex and have to be specified as a list of three-dimensional nodes/vertices, while the sphere (data type `Sphere`) requires a center point and the radius. ## Node ordering The element types of the overlap library follow the node numbering conventions of the [CFD General Notation System (CGNS)](https://cgns.github.io/) project. Please refer to the CGNS documentation for the order of the nodes of [hexahedral](https://cgns.github.io/CGNS_docs_current/sids/conv.html#unst_hexa), [tetrahedral](https://cgns.github.io/CGNS_docs_current/sids/conv.html#unst_tetra), and [pentahedral/wedge-shaped](https://cgns.github.io/CGNS_docs_current/sids/conv.html#unst_penta) elements of linear order, respectively. Also the ordering of the faces uses the conventions of CGNS. This should make interfacing this library with existing codes rather easy, often even without the need to reorder nodes. ## Dependencies The compile-time dependencies of this code are: - [Eigen3](http://eigen.tuxfamily.org), tested with versions 3.3.4 and above - [compiler supporting C++11](https://en.cppreference.com/w/cpp/compiler_support#cpp11) The software is currently continuously compiled and tested with the following compilers: | Compiler | Versions | |------------|----------| | GNU G++ | 10.2.0, 9.3.0, 8.4.0, 7.5.0 | | Clang/LLVM | 10.0.0, 9.0.1, 8.0.1 | Additionally, the Intel C++ compiler starting with version 15.0 should work, albeit this configuration is not part of the CI process. ## C++ The library is implemented as a pure header-only library written in plain C++11. To use it in your code, simply include the header file `overlap.hpp` and make sure the **Eigen3** headers can be found by your compiler or build system. The library creates two relevant type aliases, namely `scalar_t` for `double` and `vector_t` for `Eigen::Matrix`, which are used in the public interface for scalar and vectorial quantities, respectively. In principle, these types can be adjusted to specific needs, yet reducing the numerical precision of the scalar floating point type will have a significant impact on the precision and stability of the calculations. A minimal example calculating the overlap of a hexahedron with a side length of 2 centered at the origin and a sphere with radius 1 centered at a corner of the hexahedron could look something like this: ```cpp vector_t v0{-1, -1, -1}; vector_t v1{ 1, -1, -1}; vector_t v2{ 1, 1, -1}; vector_t v3{-1, 1, -1}; vector_t v4{-1, -1, 1}; vector_t v5{ 1, -1, 1}; vector_t v6{ 1, 1, 1}; vector_t v7{-1, 1, 1}; Hexahedron hex{v0, v1, v2, v3, v4, v5, v6, v7}; Sphere s{vector_t::Constant(1), 1}; scalar_t result = overlap(s, hex); ``` This code snippet calculates the correct result (π/6) for this simple configuration. To obtain the overlap area of a sphere and the facets of a tetrahedron, the function `overlapArea()` can be employed as such: ```cpp vector_t v0{-std::sqrt(3) / 6.0, -1.0 / 2.0, 0}; vector_t v1{std::sqrt(3) / 3.0, 0, 0}; vector_t v2{-std::sqrt(3) / 6.0, +1.0 / 2.0, 0}; vector_t v3{0, 0, std::sqrt(6) / 3.0}; Tetrahedron tet{v0, v1, v2, v3}; Sphere s{{0, 0, 1.5}, 1.25}; auto result = overlapArea(s, tet); std::cout << "surface area of sphere intersecting tetrahedron: " << result[0] << std::endl; std::cout << "overlap areas per face:" << std::endl; // The indices of the faces are NOT zero-based here! for(size_t f = 1; f < result.size() - 1; ++f) std::cout << " face #" << (f - 1) << ": " << result[f] << std::endl; std::cout << "total surface area of tetrahedron intersecting sphere: " << result.back() << std::endl; ``` ## Python The Python version of the `overlap` library is available via the [Python Package Index (PyPI)](https://pypi.org/project/overlap/), so for most environments installation should be possible simply via `pip install overlap`. In case no pre-built package or *wheel* is available for your system, compilation of the wrapper code is required which in turn requires the requirements listed above for the C++ version to be fulfilled. The interface of Python version closely resembles the interface of the C++ version: ```python import numpy as np import overlap vertices = np.array(( (-1, -np.sqrt(1./3.), -np.sqrt(1./6.)), (1, -np.sqrt(1./3.), -np.sqrt(1./6.)), (0, np.sqrt(4./3.), -np.sqrt(1./6.)), (0, 0, np.sqrt(3./2.)) )) tet = overlap.Tetrahedron(vertices) sphere = overlap.Sphere((0, 0, 0.5), 1) result = overlap.overlap(sphere, tet) ``` Calculation of the overlap area instead of the overlap volume is possible via the function `overlap_area()` of the package. # License The `overlap` library is distributed under the GNU General Public License v3, please refer to the [LICENSE](LICENSE) file for the full license text. This distribution bundles external third-party software covered by separate license terms. For details please consult the corresponding license terms included with each package in the respective subdirectory. | Package | License | |-------------|----------| | [Eigen](http://eigen.tuxfamily.org) | MPL2 | | [Google Test](https://github.com/google/googletest) | 3-clause BSD | | [pybind11](https://github.com/pybind/pybind11) | 3-clause BSD | %package -n python3-overlap Summary: Exact calculation of the overlap volume and area of spheres and mesh elements Provides: python-overlap BuildRequires: python3-devel BuildRequires: python3-setuptools BuildRequires: python3-pip BuildRequires: python3-cffi BuildRequires: gcc BuildRequires: gdb %description -n python3-overlap # Exact calculation of the overlap volume and area of spheres and mesh elements ![Build Status](https://img.shields.io/github/workflow/status/severinstrobl/overlap/CI%20build%20Linux) [![codecov](https://codecov.io/gh/severinstrobl/overlap/branch/master/graph/badge.svg?token=GQ2L62OXXK)](https://codecov.io/gh/severinstrobl/overlap) [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](./COPYING) [![DOI](https://img.shields.io/badge/DOI-10.1016/j.jcp.2016.02.003-blue.svg)](https://dx.doi.org/10.1016/j.jcp.2016.02.003) Calculating the intersection or overlapping volume of a sphere and one of the typically used mesh elements such as a tetrahedron or hexahedron is surprisingly challenging. This header-only library implements a numerically robust method to determine this volume. The mathematical expressions and algorithms used in this code are described in [S. Strobl et al.: Exact calculation of the overlap volume of spheres and mesh elements, Journal of Computational Physics, 2016](https://dx.doi.org/10.1016/j.jcp.2016.02.003). So if you use the code in projects resulting in any publications, please cite this paper. Employing the concepts and routines used for the calculation of the overlap volume, the intersection or overlap *area* of a sphere and the facets of a mesh element can also be calculated with this library. # Usage ## Supported primitives The overlap calculation directly supports these element types: - tetrahedra (4 nodes/vertices, data type `Tetrahedron`) - pentahedra/wedges/triangular prisms (5 nodes/vertices, data type `Wedge`) - hexahedra (6 nodes/vertices, data type `Hexahedron`) The elements must be convex and have to be specified as a list of three-dimensional nodes/vertices, while the sphere (data type `Sphere`) requires a center point and the radius. ## Node ordering The element types of the overlap library follow the node numbering conventions of the [CFD General Notation System (CGNS)](https://cgns.github.io/) project. Please refer to the CGNS documentation for the order of the nodes of [hexahedral](https://cgns.github.io/CGNS_docs_current/sids/conv.html#unst_hexa), [tetrahedral](https://cgns.github.io/CGNS_docs_current/sids/conv.html#unst_tetra), and [pentahedral/wedge-shaped](https://cgns.github.io/CGNS_docs_current/sids/conv.html#unst_penta) elements of linear order, respectively. Also the ordering of the faces uses the conventions of CGNS. This should make interfacing this library with existing codes rather easy, often even without the need to reorder nodes. ## Dependencies The compile-time dependencies of this code are: - [Eigen3](http://eigen.tuxfamily.org), tested with versions 3.3.4 and above - [compiler supporting C++11](https://en.cppreference.com/w/cpp/compiler_support#cpp11) The software is currently continuously compiled and tested with the following compilers: | Compiler | Versions | |------------|----------| | GNU G++ | 10.2.0, 9.3.0, 8.4.0, 7.5.0 | | Clang/LLVM | 10.0.0, 9.0.1, 8.0.1 | Additionally, the Intel C++ compiler starting with version 15.0 should work, albeit this configuration is not part of the CI process. ## C++ The library is implemented as a pure header-only library written in plain C++11. To use it in your code, simply include the header file `overlap.hpp` and make sure the **Eigen3** headers can be found by your compiler or build system. The library creates two relevant type aliases, namely `scalar_t` for `double` and `vector_t` for `Eigen::Matrix`, which are used in the public interface for scalar and vectorial quantities, respectively. In principle, these types can be adjusted to specific needs, yet reducing the numerical precision of the scalar floating point type will have a significant impact on the precision and stability of the calculations. A minimal example calculating the overlap of a hexahedron with a side length of 2 centered at the origin and a sphere with radius 1 centered at a corner of the hexahedron could look something like this: ```cpp vector_t v0{-1, -1, -1}; vector_t v1{ 1, -1, -1}; vector_t v2{ 1, 1, -1}; vector_t v3{-1, 1, -1}; vector_t v4{-1, -1, 1}; vector_t v5{ 1, -1, 1}; vector_t v6{ 1, 1, 1}; vector_t v7{-1, 1, 1}; Hexahedron hex{v0, v1, v2, v3, v4, v5, v6, v7}; Sphere s{vector_t::Constant(1), 1}; scalar_t result = overlap(s, hex); ``` This code snippet calculates the correct result (π/6) for this simple configuration. To obtain the overlap area of a sphere and the facets of a tetrahedron, the function `overlapArea()` can be employed as such: ```cpp vector_t v0{-std::sqrt(3) / 6.0, -1.0 / 2.0, 0}; vector_t v1{std::sqrt(3) / 3.0, 0, 0}; vector_t v2{-std::sqrt(3) / 6.0, +1.0 / 2.0, 0}; vector_t v3{0, 0, std::sqrt(6) / 3.0}; Tetrahedron tet{v0, v1, v2, v3}; Sphere s{{0, 0, 1.5}, 1.25}; auto result = overlapArea(s, tet); std::cout << "surface area of sphere intersecting tetrahedron: " << result[0] << std::endl; std::cout << "overlap areas per face:" << std::endl; // The indices of the faces are NOT zero-based here! for(size_t f = 1; f < result.size() - 1; ++f) std::cout << " face #" << (f - 1) << ": " << result[f] << std::endl; std::cout << "total surface area of tetrahedron intersecting sphere: " << result.back() << std::endl; ``` ## Python The Python version of the `overlap` library is available via the [Python Package Index (PyPI)](https://pypi.org/project/overlap/), so for most environments installation should be possible simply via `pip install overlap`. In case no pre-built package or *wheel* is available for your system, compilation of the wrapper code is required which in turn requires the requirements listed above for the C++ version to be fulfilled. The interface of Python version closely resembles the interface of the C++ version: ```python import numpy as np import overlap vertices = np.array(( (-1, -np.sqrt(1./3.), -np.sqrt(1./6.)), (1, -np.sqrt(1./3.), -np.sqrt(1./6.)), (0, np.sqrt(4./3.), -np.sqrt(1./6.)), (0, 0, np.sqrt(3./2.)) )) tet = overlap.Tetrahedron(vertices) sphere = overlap.Sphere((0, 0, 0.5), 1) result = overlap.overlap(sphere, tet) ``` Calculation of the overlap area instead of the overlap volume is possible via the function `overlap_area()` of the package. # License The `overlap` library is distributed under the GNU General Public License v3, please refer to the [LICENSE](LICENSE) file for the full license text. This distribution bundles external third-party software covered by separate license terms. For details please consult the corresponding license terms included with each package in the respective subdirectory. | Package | License | |-------------|----------| | [Eigen](http://eigen.tuxfamily.org) | MPL2 | | [Google Test](https://github.com/google/googletest) | 3-clause BSD | | [pybind11](https://github.com/pybind/pybind11) | 3-clause BSD | %package help Summary: Development documents and examples for overlap Provides: python3-overlap-doc %description help # Exact calculation of the overlap volume and area of spheres and mesh elements ![Build Status](https://img.shields.io/github/workflow/status/severinstrobl/overlap/CI%20build%20Linux) [![codecov](https://codecov.io/gh/severinstrobl/overlap/branch/master/graph/badge.svg?token=GQ2L62OXXK)](https://codecov.io/gh/severinstrobl/overlap) [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](./COPYING) [![DOI](https://img.shields.io/badge/DOI-10.1016/j.jcp.2016.02.003-blue.svg)](https://dx.doi.org/10.1016/j.jcp.2016.02.003) Calculating the intersection or overlapping volume of a sphere and one of the typically used mesh elements such as a tetrahedron or hexahedron is surprisingly challenging. This header-only library implements a numerically robust method to determine this volume. The mathematical expressions and algorithms used in this code are described in [S. Strobl et al.: Exact calculation of the overlap volume of spheres and mesh elements, Journal of Computational Physics, 2016](https://dx.doi.org/10.1016/j.jcp.2016.02.003). So if you use the code in projects resulting in any publications, please cite this paper. Employing the concepts and routines used for the calculation of the overlap volume, the intersection or overlap *area* of a sphere and the facets of a mesh element can also be calculated with this library. # Usage ## Supported primitives The overlap calculation directly supports these element types: - tetrahedra (4 nodes/vertices, data type `Tetrahedron`) - pentahedra/wedges/triangular prisms (5 nodes/vertices, data type `Wedge`) - hexahedra (6 nodes/vertices, data type `Hexahedron`) The elements must be convex and have to be specified as a list of three-dimensional nodes/vertices, while the sphere (data type `Sphere`) requires a center point and the radius. ## Node ordering The element types of the overlap library follow the node numbering conventions of the [CFD General Notation System (CGNS)](https://cgns.github.io/) project. Please refer to the CGNS documentation for the order of the nodes of [hexahedral](https://cgns.github.io/CGNS_docs_current/sids/conv.html#unst_hexa), [tetrahedral](https://cgns.github.io/CGNS_docs_current/sids/conv.html#unst_tetra), and [pentahedral/wedge-shaped](https://cgns.github.io/CGNS_docs_current/sids/conv.html#unst_penta) elements of linear order, respectively. Also the ordering of the faces uses the conventions of CGNS. This should make interfacing this library with existing codes rather easy, often even without the need to reorder nodes. ## Dependencies The compile-time dependencies of this code are: - [Eigen3](http://eigen.tuxfamily.org), tested with versions 3.3.4 and above - [compiler supporting C++11](https://en.cppreference.com/w/cpp/compiler_support#cpp11) The software is currently continuously compiled and tested with the following compilers: | Compiler | Versions | |------------|----------| | GNU G++ | 10.2.0, 9.3.0, 8.4.0, 7.5.0 | | Clang/LLVM | 10.0.0, 9.0.1, 8.0.1 | Additionally, the Intel C++ compiler starting with version 15.0 should work, albeit this configuration is not part of the CI process. ## C++ The library is implemented as a pure header-only library written in plain C++11. To use it in your code, simply include the header file `overlap.hpp` and make sure the **Eigen3** headers can be found by your compiler or build system. The library creates two relevant type aliases, namely `scalar_t` for `double` and `vector_t` for `Eigen::Matrix`, which are used in the public interface for scalar and vectorial quantities, respectively. In principle, these types can be adjusted to specific needs, yet reducing the numerical precision of the scalar floating point type will have a significant impact on the precision and stability of the calculations. A minimal example calculating the overlap of a hexahedron with a side length of 2 centered at the origin and a sphere with radius 1 centered at a corner of the hexahedron could look something like this: ```cpp vector_t v0{-1, -1, -1}; vector_t v1{ 1, -1, -1}; vector_t v2{ 1, 1, -1}; vector_t v3{-1, 1, -1}; vector_t v4{-1, -1, 1}; vector_t v5{ 1, -1, 1}; vector_t v6{ 1, 1, 1}; vector_t v7{-1, 1, 1}; Hexahedron hex{v0, v1, v2, v3, v4, v5, v6, v7}; Sphere s{vector_t::Constant(1), 1}; scalar_t result = overlap(s, hex); ``` This code snippet calculates the correct result (π/6) for this simple configuration. To obtain the overlap area of a sphere and the facets of a tetrahedron, the function `overlapArea()` can be employed as such: ```cpp vector_t v0{-std::sqrt(3) / 6.0, -1.0 / 2.0, 0}; vector_t v1{std::sqrt(3) / 3.0, 0, 0}; vector_t v2{-std::sqrt(3) / 6.0, +1.0 / 2.0, 0}; vector_t v3{0, 0, std::sqrt(6) / 3.0}; Tetrahedron tet{v0, v1, v2, v3}; Sphere s{{0, 0, 1.5}, 1.25}; auto result = overlapArea(s, tet); std::cout << "surface area of sphere intersecting tetrahedron: " << result[0] << std::endl; std::cout << "overlap areas per face:" << std::endl; // The indices of the faces are NOT zero-based here! for(size_t f = 1; f < result.size() - 1; ++f) std::cout << " face #" << (f - 1) << ": " << result[f] << std::endl; std::cout << "total surface area of tetrahedron intersecting sphere: " << result.back() << std::endl; ``` ## Python The Python version of the `overlap` library is available via the [Python Package Index (PyPI)](https://pypi.org/project/overlap/), so for most environments installation should be possible simply via `pip install overlap`. In case no pre-built package or *wheel* is available for your system, compilation of the wrapper code is required which in turn requires the requirements listed above for the C++ version to be fulfilled. The interface of Python version closely resembles the interface of the C++ version: ```python import numpy as np import overlap vertices = np.array(( (-1, -np.sqrt(1./3.), -np.sqrt(1./6.)), (1, -np.sqrt(1./3.), -np.sqrt(1./6.)), (0, np.sqrt(4./3.), -np.sqrt(1./6.)), (0, 0, np.sqrt(3./2.)) )) tet = overlap.Tetrahedron(vertices) sphere = overlap.Sphere((0, 0, 0.5), 1) result = overlap.overlap(sphere, tet) ``` Calculation of the overlap area instead of the overlap volume is possible via the function `overlap_area()` of the package. # License The `overlap` library is distributed under the GNU General Public License v3, please refer to the [LICENSE](LICENSE) file for the full license text. This distribution bundles external third-party software covered by separate license terms. For details please consult the corresponding license terms included with each package in the respective subdirectory. | Package | License | |-------------|----------| | [Eigen](http://eigen.tuxfamily.org) | MPL2 | | [Google Test](https://github.com/google/googletest) | 3-clause BSD | | [pybind11](https://github.com/pybind/pybind11) | 3-clause BSD | %prep %autosetup -n overlap-0.1.0 %build %py3_build %install %py3_install install -d -m755 %{buildroot}/%{_pkgdocdir} if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi pushd %{buildroot} if [ -d usr/lib ]; then find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst fi if [ -d usr/lib64 ]; then find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst fi if [ -d usr/bin ]; then find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst fi if [ -d usr/sbin ]; then find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst fi touch doclist.lst if [ -d usr/share/man ]; then find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst fi popd mv %{buildroot}/filelist.lst . mv %{buildroot}/doclist.lst . %files -n python3-overlap -f filelist.lst %dir %{python3_sitearch}/* %files help -f doclist.lst %{_docdir}/* %changelog * Mon May 29 2023 Python_Bot - 0.1.0-1 - Package Spec generated