automatic import of python-pyrevolveopeneuler20.03

3 files changed, 302 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index e69de29..aa68c91 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/pyrevolve-2.2.2.tar.gz
diff --git a/python-pyrevolve.spec b/python-pyrevolve.spec
new file mode 100644
index 0000000..3b584a3
--- /dev/null
+++ b/python-pyrevolve.spec
@@ -0,0 +1,300 @@
+%global _empty_manifest_terminate_build 0
+Name:		python-pyrevolve
+Version:	2.2.2
+Release:	1
+Summary:	Python wrapper for Revolve checkpointing
+License:	MIT
+URL:		https://github.com/opesci/pyrevolve/
+Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/72/4e/d0926921a4fedd0fdf786e4ce5450e5a1eeebb5a2225110fc72bf17dd0a1/pyrevolve-2.2.2.tar.gz
+BuildArch:	noarch
+
+
+%description
+# Checkpointing
+
+The adjoint computation of an unsteady nonlinear primal function requires the
+full primal trajectory in reverse temporal order. Storing this can exceed the
+available memory. In that case, Checkpointing can be used to store the state
+only at carefully selected points in time. From there, the forward computation
+can be restarted to recompute lost sections of the trajectory when they are
+needed during the adjoint computation. This is always a tradeoff between memory
+and runtime. The classic and provably optimal way to do this for a known number
+of time steps is [Revolve](https://doi.org/10.1145/347837.347846), and there are other algorithms for optimal online
+checkpointing if the number of steps is unknown a priori, or for multistage
+checkpointing if there are multiple layers of storage, e.g. memory and hard
+drive.
+![Visual demo of checkpointing](https://raw.githubusercontent.com/opesci/pyrevolve/master/examples/checkpointing_demo.gif)
+
+# PyRevolve
+
+The pyrevolve library contains two parts: crevolve, which is a thin Python
+wrapper around a previously published [C++ implementation](https://www.mathematik.hu-berlin.de/de/forschung/forschungsgebiete/mathematische-optimierung/andrea-walther/walther-software), and pyrevolve
+itself, which sits on top of crevolve and manages data and computation
+management for the user.
+
+The C++ files in this package are slightly modified to play more nicely with
+Python, but the original is available from the link below. In addition, there
+is a C wrapper around the C++ library, to simplify the interface with Python.
+This C wrapper is taken from [libadjoint](https://bitbucket.org/dolfin-adjoint/libadjoint).
+
+
+
+# Installation
+Since PyRevolve is distributed as source, you must have a functional C/C++
+compiler in your environment before trying to install PyRevolve. The
+installation procedure respects the standard environment variables
+like CC/CXX.
+
+The simplest installation is through pip by simply doing:
+
+    pip install pyrevolve
+
+If you would like to have a local development copy that you can edit,
+clone the repo and call the following command in the home directory:
+
+    pip install -e .
+
+If you face any installation issues, first check that you really do
+have a functional C++ compiler, either available as `g++` in the path
+or pointed to by the environment variable `CXX`. If this is not the
+reason, please raise a issue here or on
+[this](https://opesci-slackin.now.sh) Slack channel. 
+# Usage
+
+There are two wrappers: a _classic_ wrapper that follows the behaviour of Revolve
+as described in the papers, and leaves the data mangement, the actual copying
+of data, and the calling of operators to the user. An example of how to use it
+can be executed by calling
+
+    python examples/use_classic.py
+    
+The other, _modernised_ wrapper, takes care of all this. The user creates a
+Revolver object, and passes a forward operator, reverse operator, and
+checkpoint operator to it. The Revolver provides two important methods:
+`apply_forward`, and `apply_reverse`. A call to `apply_forward` executes the
+forward computation, while creating the necessary checkpoints for the reverse
+computation. After this, a user may also call the `apply_reverse` method to
+compute the adjoints.
+
+For this to work, the user is responsible that the operators have an `apply()`
+method that takes arguments `t_start` and `t_end`, and that the checkpoint
+object has a property `size` to report the size of one checkpoint, and methods
+`load(ptr)` and `save(ptr)` that deep-copy all time-dependent live data into
+a location given in `ptr`.
+
+An example of this can be found here:
+
+    python examples/use_modernised.py
+    
+
+
+%package -n python3-pyrevolve
+Summary:	Python wrapper for Revolve checkpointing
+Provides:	python-pyrevolve
+BuildRequires:	python3-devel
+BuildRequires:	python3-setuptools
+BuildRequires:	python3-pip
+%description -n python3-pyrevolve
+# Checkpointing
+
+The adjoint computation of an unsteady nonlinear primal function requires the
+full primal trajectory in reverse temporal order. Storing this can exceed the
+available memory. In that case, Checkpointing can be used to store the state
+only at carefully selected points in time. From there, the forward computation
+can be restarted to recompute lost sections of the trajectory when they are
+needed during the adjoint computation. This is always a tradeoff between memory
+and runtime. The classic and provably optimal way to do this for a known number
+of time steps is [Revolve](https://doi.org/10.1145/347837.347846), and there are other algorithms for optimal online
+checkpointing if the number of steps is unknown a priori, or for multistage
+checkpointing if there are multiple layers of storage, e.g. memory and hard
+drive.
+![Visual demo of checkpointing](https://raw.githubusercontent.com/opesci/pyrevolve/master/examples/checkpointing_demo.gif)
+
+# PyRevolve
+
+The pyrevolve library contains two parts: crevolve, which is a thin Python
+wrapper around a previously published [C++ implementation](https://www.mathematik.hu-berlin.de/de/forschung/forschungsgebiete/mathematische-optimierung/andrea-walther/walther-software), and pyrevolve
+itself, which sits on top of crevolve and manages data and computation
+management for the user.
+
+The C++ files in this package are slightly modified to play more nicely with
+Python, but the original is available from the link below. In addition, there
+is a C wrapper around the C++ library, to simplify the interface with Python.
+This C wrapper is taken from [libadjoint](https://bitbucket.org/dolfin-adjoint/libadjoint).
+
+
+
+# Installation
+Since PyRevolve is distributed as source, you must have a functional C/C++
+compiler in your environment before trying to install PyRevolve. The
+installation procedure respects the standard environment variables
+like CC/CXX.
+
+The simplest installation is through pip by simply doing:
+
+    pip install pyrevolve
+
+If you would like to have a local development copy that you can edit,
+clone the repo and call the following command in the home directory:
+
+    pip install -e .
+
+If you face any installation issues, first check that you really do
+have a functional C++ compiler, either available as `g++` in the path
+or pointed to by the environment variable `CXX`. If this is not the
+reason, please raise a issue here or on
+[this](https://opesci-slackin.now.sh) Slack channel. 
+# Usage
+
+There are two wrappers: a _classic_ wrapper that follows the behaviour of Revolve
+as described in the papers, and leaves the data mangement, the actual copying
+of data, and the calling of operators to the user. An example of how to use it
+can be executed by calling
+
+    python examples/use_classic.py
+    
+The other, _modernised_ wrapper, takes care of all this. The user creates a
+Revolver object, and passes a forward operator, reverse operator, and
+checkpoint operator to it. The Revolver provides two important methods:
+`apply_forward`, and `apply_reverse`. A call to `apply_forward` executes the
+forward computation, while creating the necessary checkpoints for the reverse
+computation. After this, a user may also call the `apply_reverse` method to
+compute the adjoints.
+
+For this to work, the user is responsible that the operators have an `apply()`
+method that takes arguments `t_start` and `t_end`, and that the checkpoint
+object has a property `size` to report the size of one checkpoint, and methods
+`load(ptr)` and `save(ptr)` that deep-copy all time-dependent live data into
+a location given in `ptr`.
+
+An example of this can be found here:
+
+    python examples/use_modernised.py
+    
+
+
+%package help
+Summary:	Development documents and examples for pyrevolve
+Provides:	python3-pyrevolve-doc
+%description help
+# Checkpointing
+
+The adjoint computation of an unsteady nonlinear primal function requires the
+full primal trajectory in reverse temporal order. Storing this can exceed the
+available memory. In that case, Checkpointing can be used to store the state
+only at carefully selected points in time. From there, the forward computation
+can be restarted to recompute lost sections of the trajectory when they are
+needed during the adjoint computation. This is always a tradeoff between memory
+and runtime. The classic and provably optimal way to do this for a known number
+of time steps is [Revolve](https://doi.org/10.1145/347837.347846), and there are other algorithms for optimal online
+checkpointing if the number of steps is unknown a priori, or for multistage
+checkpointing if there are multiple layers of storage, e.g. memory and hard
+drive.
+![Visual demo of checkpointing](https://raw.githubusercontent.com/opesci/pyrevolve/master/examples/checkpointing_demo.gif)
+
+# PyRevolve
+
+The pyrevolve library contains two parts: crevolve, which is a thin Python
+wrapper around a previously published [C++ implementation](https://www.mathematik.hu-berlin.de/de/forschung/forschungsgebiete/mathematische-optimierung/andrea-walther/walther-software), and pyrevolve
+itself, which sits on top of crevolve and manages data and computation
+management for the user.
+
+The C++ files in this package are slightly modified to play more nicely with
+Python, but the original is available from the link below. In addition, there
+is a C wrapper around the C++ library, to simplify the interface with Python.
+This C wrapper is taken from [libadjoint](https://bitbucket.org/dolfin-adjoint/libadjoint).
+
+
+
+# Installation
+Since PyRevolve is distributed as source, you must have a functional C/C++
+compiler in your environment before trying to install PyRevolve. The
+installation procedure respects the standard environment variables
+like CC/CXX.
+
+The simplest installation is through pip by simply doing:
+
+    pip install pyrevolve
+
+If you would like to have a local development copy that you can edit,
+clone the repo and call the following command in the home directory:
+
+    pip install -e .
+
+If you face any installation issues, first check that you really do
+have a functional C++ compiler, either available as `g++` in the path
+or pointed to by the environment variable `CXX`. If this is not the
+reason, please raise a issue here or on
+[this](https://opesci-slackin.now.sh) Slack channel. 
+# Usage
+
+There are two wrappers: a _classic_ wrapper that follows the behaviour of Revolve
+as described in the papers, and leaves the data mangement, the actual copying
+of data, and the calling of operators to the user. An example of how to use it
+can be executed by calling
+
+    python examples/use_classic.py
+    
+The other, _modernised_ wrapper, takes care of all this. The user creates a
+Revolver object, and passes a forward operator, reverse operator, and
+checkpoint operator to it. The Revolver provides two important methods:
+`apply_forward`, and `apply_reverse`. A call to `apply_forward` executes the
+forward computation, while creating the necessary checkpoints for the reverse
+computation. After this, a user may also call the `apply_reverse` method to
+compute the adjoints.
+
+For this to work, the user is responsible that the operators have an `apply()`
+method that takes arguments `t_start` and `t_end`, and that the checkpoint
+object has a property `size` to report the size of one checkpoint, and methods
+`load(ptr)` and `save(ptr)` that deep-copy all time-dependent live data into
+a location given in `ptr`.
+
+An example of this can be found here:
+
+    python examples/use_modernised.py
+    
+
+
+%prep
+%autosetup -n pyrevolve-2.2.2
+
+%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-pyrevolve -f filelist.lst
+%dir %{python3_sitelib}/*
+
+%files help -f doclist.lst
+%{_docdir}/*
+
+%changelog
+* Wed May 10 2023 Python_Bot <Python_Bot@openeuler.org> - 2.2.2-1
+- Package Spec generated
diff --git a/sources b/sources
new file mode 100644
index 0000000..74a30ee
--- /dev/null
+++ b/sources
@@ -0,0 +1 @@
+30f9a996753b7e4b2599f7fb4b59cfd4  pyrevolve-2.2.2.tar.gz