automatic import of python-overlap

3 files changed, 593 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index e69de29..a9f40d2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/overlap-0.1.0.tar.gz
diff --git a/python-overlap.spec b/python-overlap.spec
new file mode 100644
index 0000000..7437974
--- /dev/null
+++ b/python-overlap.spec
@@ -0,0 +1,591 @@
+%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<scalar_t, 3, 1, Eigen::DontAlign>`, 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 (&pi;/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<scalar_t, 3, 1, Eigen::DontAlign>`, 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 (&pi;/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<scalar_t, 3, 1, Eigen::DontAlign>`, 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 (&pi;/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 <Python_Bot@openeuler.org> - 0.1.0-1
+- Package Spec generated
diff --git a/sources b/sources
new file mode 100644
index 0000000..eb5740f
--- /dev/null
+++ b/sources
@@ -0,0 +1 @@
+cfff8571401693af39319985f98ac218  overlap-0.1.0.tar.gz