wavepacket 0.1.0__tar.gz → 0.2.0__tar.gz

wavepacket-0.2.0/.github/workflows/ci_testing.yml

@@ -0,0 +1,30 @@
+name: Wavepacket CI
+run-name: Testing ${{ github.ref_name }} with ref ${{ github.ref }}
+
+on:
+  push
+
+jobs:
+  Run-all-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v6
+        id: cp311
+        with:
+          python-version: '3.11'
+      - uses: actions/setup-python@v6
+        id: cp312
+        with:
+          python-version: '3.12'
+      - uses: actions/setup-python@v6
+        id: cp313
+        with:
+          python-version: '3.13'
+      - uses: actions/setup-python@v6
+        id: cp314
+        with:
+          python-version: '3.14'
+      - run: ${{ steps.cp313.outputs.python-path }} -m venv ~/venv
+      - run: ~/venv/bin/python -m pip install tox
+      - run: cd $GITHUB_WORKSPACE && ~/venv/bin/tox

wavepacket-0.2.0/.gitignore

@@ -0,0 +1,67 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+.idea/

wavepacket-0.2.0/.readthedocs.yaml

@@ -0,0 +1,18 @@
+version: 2
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.13"
+  apt_packages:
+    - dvipng
+    - texlive-binaries
+formats:
+  - htmlzip
+sphinx:
+  configuration: doc/conf.py
+python:
+  install:
+    - requirements: doc/requirements.txt
+    - method: pip
+      path: .

wavepacket-0.2.0/CHANGELOG.rst

@@ -0,0 +1,41 @@
+=========
+ChangeLog
+=========
+
+0.2
+---
+
+- (#18) added spherical harmonics expansion:
+  degree of freedom, operator, generator
+
+- (#19) added time-dependent functions and laser fields as operators,
+  including helper functions for sin**2 and rectangular pulses with soft turn-on
+
+- (#20) added functionality related to projections
+  - projection operator for projecting onto a state or subspace
+  - population() function to easily calculate populations of target states
+  - Gram-Schmidt orthogonalization and normalization
+
+- (#21) added more initial states
+  random wave functions, zero densities and wave functions, unit density
+- (#21) added function grid.fbr_density() to calculate density in FBR
+
+- (#22) 1D plotting helpers
+  - added plotting classes StackedPlot1D and SimplePlot1D
+  - added a tutorial on plotting
+
+- (#23) Added a notebook with the PendularStates demos converted from the older versions
+
+- (#15) added CI build using tox for different Python versions
+        Wavepacket now supports every Python >= 3.11
+
+
+0.1
+---
+
+Initial release.
+
+Scope is the simulation of a harmonic oscillator with an ordinary ODE solver,
+plus a bit of introductory documentation and a demo.
+
+That is, infrastructure, not so much content.

{wavepacket-0.1.0 → wavepacket-0.2.0}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: wavepacket
-Version: 0.1.0
+Version: 0.2.0
 Summary: A package for the propagation of quantum-mechanical wave functions.
 Author: Ulf Lorenz
-Requires-Python: >=3.12
+Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Development Status :: 3 - Alpha
@@ -13,17 +13,8 @@ Classifier: Topic :: Scientific/Engineering :: Physics
 License-File: LICENSE
 Requires-Dist: numpy >= 2.1.3
 Requires-Dist: scipy >= 1.14.1
-Requires-Dist: matplotlib >= 3.10 ; extra == "demos"
-Requires-Dist: sphinx >= 8.1.3 ; extra == "doc"
-Requires-Dist: sphinx-autoapi >= 3.4.0 ; extra == "doc"
-Requires-Dist: numpydoc >= 1.8.0 ; extra == "doc"
-Requires-Dist: myst-nb >= 1.2 ; extra == "doc"
-Requires-Dist: sphinx-rtd-theme >= 3.0.2 ; extra == "doc"
-Requires-Dist: pytest >= 8.3 ; extra == "test"
+Requires-Dist: matplotlib >= 3.10
 Project-URL: Home, https://github.com/ulflor/wavepacket
-Provides-Extra: demos
-Provides-Extra: doc
-Provides-Extra: test
 
 Description
 -----------

wavepacket-0.2.0/doc/Makefile

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = .
+BUILDDIR      = _build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

wavepacket-0.2.0/doc/architecture.rst

@@ -0,0 +1,67 @@
+Architecture overview
+=====================
+
+Common concepts
+---------------
+
+The focus of Wavepacket is on flexible setups of simple quantum systems.
+To get there, the code ended up with a few common concepts.
+
+* To abstract away the difference between wave functions and density operators,
+  a class :py:class:`wavepacket.grid.State` has been introduced.
+* Most utility functions and classes can operate on wave functions as well as
+  density operators, wherever this is possible and sensible.
+
+  Where the difference can lead to confusion and errors, functionality may not be offered.
+  For example, the wave function norm is the square root of the
+  of the corresponding density operator (trace) norm. This has been extremely confusing
+  when switching between the two objects, so Wavepacket does not offer a `norm()`
+  function, it offers :py:func:`wavepacket.grid.trace` instead,
+* Classes in Wavepacket normally use the Value Pattern, and are immutable after
+  creation. This allows you to recycle objects without side effects; for example,
+  when you have set up a Hamiltonian for the field-free case, you can trivially use it
+  also as a component for a system interacting with a laser field.
+  Also, all classes and packages follow a strict hierarchy as described in the
+  subsequent section.
+
+
+Packages
+--------
+
+Wavepacket is split into several subpackages with hierarchical dependencies.
+From lowest to highest layer, these are:
+
+:py:mod:`wavepacket.grid`
+    Contains all classes that describe the representation of a state (the grid),
+    and all functionality that operates only on this representation. These include
+    degrees of freedom, :py:class:`wavepacket.grid.Grid` itself, the class
+    :py:class:`wavepacket.grid.State`, as well as supporting functions and classes.
+
+:py:mod:`wavepacket.builder`
+    Contains utility functions to create an initial wave function or density operator.
+    These functions require a grid on which to create the state.
+
+:py:mod:`wavepacket.operator`
+    Contains operator classes. Operators are always defined on a specific grid,
+    hence this module requires the grid module. The module also contains some utility
+    functions related to operators, such as :py:func:`wavepacket.operator.expectation_value`
+
+:py:mod:`wavepacket.expression`
+    This module contains classes that wrap an operator for a differential
+    equation. These can be a Schroedinger equation or various Liouvillians.
+    As these entities wrap an operator, this module requires the operator module.
+
+:py:mod:`wavepacket.solver`
+    Here, you can find actual Solvers for the differential equations.
+    Hence, this module requires knowledge of the expression module.
+
+
+Two other modules stand apart from this hierarchy:
+
+* :py:mod:`wavepacket.typing` contains definitions for type hinting.
+* :py:mod:`wavepacket.testing` contains some test helpers,
+  for example :py:func:`wavepacket.testing.assert_close` to compare two states with each other.
+* A few grid-independent utilities are found in the top-level namespace, such as
+  callables, exceptions, logging functions etc.
+
+With these concepts in mind, most functionality should be readily findable.

wavepacket-0.2.0/doc/conf.py

@@ -0,0 +1,53 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# For the full list of built-in configuration values, see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Project information -----------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
+
+project = 'Wavepacket'
+copyright = '2025, Ulf Lorenz'
+author = 'Ulf Lorenz'
+release = '0.2'
+
+# -- General configuration ---------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
+
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.imgmath",
+    "sphinx.ext.inheritance_diagram",
+    "autoapi.extension",
+    "numpydoc",
+    "myst_nb"
+]
+
+templates_path = ['_templates']
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+
+# ------ AutoApi configuration
+autoapi_dirs = ["../src/wavepacket"]
+
+autoapi_options = ['members', 'undoc-members', 'imported-members',
+                   'show-inheritance', 'show-module-summary']
+
+
+# Unless we prefix _every_ module by "_", we get every symbol twice: Once in the
+# exposing package, once in the defining module. This here skips all module docs.
+def skip_modules(app, what, name, obj, skip, options):
+    if what == "module":
+        skip = True
+
+    return skip
+
+
+def setup(sphinx):
+    sphinx.connect("autoapi-skip-member", skip_modules)
+
+
+# -- Options for HTML output -------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
+
+html_theme = 'sphinx_rtd_theme'
+

wavepacket-0.2.0/doc/demos/pendular_states.md

@@ -0,0 +1,170 @@
+---
+file_format: mystnb
+kernelspec:
+    name: python3
+---
+
+(demo-pendular-states)=
+
+# Pendular states
+
+The goal of this demo is the partial reproduction of some results of a paper by Oritgoso et al.[^ref-paper]
+Besides discussing pretty cool physics, it aims to demonstrate
+how to extract non-trivial data with minimal fuss and plot it.
+
+## Alignment of molecules, some theory
+
+If a molecule interacts with a non-resonant laser field, the ground state is shifted in energy.
+We can calculate the shift with standard perturbation theory and cavity-dressed states as
+
+```{math}
+\Delta E \propto - \sum_n \frac{|\langle \Phi_0 | \hat{\vec{\mu}} \vec E |\Phi_n \rangle|^2}{E_n - E_i - \omega}
+    = - \frac{1}{2} \alpha(\omega) E^2 \cos^2 \theta
+```
+
+in terms of the dipole operator {math}`\mu`, the electric field with strength {math}`E` and frequency {math}`\omega`,
+and where the summation includes all excited states {math}`\Phi_n` with energies {math}`E_n`.
+Calculating the energy shift is difficult, but that is not our goal here.
+Instead, we absorb all these calculations in a material-specific dynamic polarizability {math}`\alpha(\omega)`.
+Then only a dependency on the angle {math}`\theta` between the effective dipole moment and the laser
+polarization axis remains.
+
+If we plug this energy shift into the formula of a rigid linear rotor, we arrive at the Hamiltonian
+
+```{math}
+\hat H = \frac{\hat{L}^2}{2I} - \frac{1}{2} \ \alpha E^2 \cos^2\theta.
+```
+
+This Hamiltonian describes a linear rotor (first term) trapped in a cosine-shaped potential that draws the
+rotor towards the laser polarization axis ({math}`\alpha > 0`) or away from it ({math}`\alpha < 0`).
+In the following, we only consider the former case of a positive polarizability.
+As the final step, we introduce three further manipulations:
+
+1. We assume that the electric field changes slowly over time. Effectively, this adds a time-dependent shape function
+   to the second term in the Hamiltonian. We will follow the reference and assume a Gaussian shape.
+2. Because only the product of electric field strength and polarizability matters, we replace it by a
+   single parameter.
+3. To get rid of the moment of inertia, we rescale the time such that we can set {math}`I=1`.
+
+With these manipulations, we arrive at the final formulation of a scaled model Hamiltonian
+
+```{math}
+\hat H = \frac{\hat{L}^2}{2} - \frac{\Delta}{2} \ \cos^2\theta \ \mathrm{e}^{- (t - \delta)^2 / \sigma^2}
+```
+
+In the following, we will follow ref.[^ref-paper] further by studying the dynamics of this Hamiltonian
+in different parameter regimes.
+
+## Non-adiabatic alignment
+
+The natural timescales of the scaled Hamiltonian are determined by the energy levels of the free rotor.
+For low-lying rotational states, these time scales are somewhere on the order of 0.1 ... 1.
+If the laser pulse is shorter than this timescale, the laser effectively "kicks" the rotor,
+after which it starts to tumble.
+
+As alignment measure, we usually employ the expectation value of the squared cosine.
+In the dynamics shown below, we can clearly see the out of equilibrium dynamics after the laser pulse at t = 0.15.
+This plot corresponds to the first graph of figure 1 of ref.[^ref-paper].
+The stronger the laser field the faster the subsequent dynamics of the rotor.
+
+Note that at certain points in time, the rotor exhibits alignment recurrence even after the laser field has passed.
+This field-free alignment is useful because the molecule is aligned, yet undisturbed by external fields.
+
+```{code-cell}
+import math
+import matplotlib.pyplot as plt
+import numpy as np
+
+import wavepacket as wp
+
+def calculate_alignment(Delta, sigma, l0=0, m=0):
+    delay = 3 * sigma
+
+   # tiny optimization: smaller grids are faster
+    thetaDof = wp.grid.SphericalHarmonicsDof(25+l0, m)
+    grid = wp.grid.Grid(thetaDof)
+
+    psi0 = wp.builder.product_wave_function(grid, wp.SphericalHarmonic(l0, m))
+
+    kinetic = wp.operator.RotationalKineticEnergy(grid, 0, 0.5)
+    cos2 = wp.operator.Potential1D(grid, 0, lambda theta: np.cos(theta)**2)
+    laser = wp.operator.TimeDependentOperator(grid,
+                                              lambda t: Delta * math.exp(-(t-delay)**2/sigma**2))
+
+    hamiltonian = kinetic - 0.5 * cos2 * laser
+    equation = wp.expression.SchroedingerEquation(hamiltonian)
+    solver = wp.solver.OdeSolver(equation, dt=sigma / 50)
+
+    results = [(t, wp.operator.expectation_value(cos2, psi))
+               for (t, psi) in solver.propagate(psi0, 0, 500)]
+    times = np.array([t for (t, _) in results])
+    expectation_values = np.array([abs(val) for (_, val) in results])
+    
+    return times, expectation_values
+
+times, expectation_values_100 = calculate_alignment(Delta=100, sigma=0.05)
+_, expectation_values_400 = calculate_alignment(Delta=400, sigma=0.05)
+_, expectation_values_900 = calculate_alignment(Delta=900, sigma=0.05)
+plt.plot(times, expectation_values_100, '-k',
+         times, expectation_values_400, '--k',
+         times, expectation_values_900, ':k');
+```
+
+Note that the actual work is encapsulated in a function with only a few parameters.
+This was a deliberate choice to make the code reusable over this whole demo,
+hence the parameters "l0" (initial angular momentum) and "m" (magnetic quantum number), which will only be
+used further below.
+When changing the laser field parameters, you would otherwise have to retype quite some boilerplate
+code to eventually recreate the solver.
+Encapsulation saves us some noise here, plus it guarantees a homogenous setup.
+
+## Adiabatic alignment
+
+If the laser pulse is much longer than the relevant rotational time scales, we are in the adiabatic limit.
+The rotor aligns with the laser pulse when it is turned on and largely regresses to the field-free rotation
+as the laser is turned off.
+This plot corresponds to the third graph of figure 1 of ref[^ref-paper].
+
+```{code-cell}
+times, expectation_values_100 = calculate_alignment(Delta=100, sigma=5)
+_, expectation_values_400 = calculate_alignment(Delta=400, sigma=5)
+_, expectation_values_900 = calculate_alignment(Delta=900, sigma=5)
+plt.plot(times, expectation_values_100, '-k',
+         times, expectation_values_400, '--k',
+         times, expectation_values_900, ':k');
+```
+
+Stronger laser fields correspond to a higher degree of alignment, although this converges for large field strengths.
+The alignment is much stronger than in the non-adiabatic case, but at the cost of an external alignment field
+that may perturb molecular dynamics.
+
+## Alignment of an excited rotational state
+
+Finally, we can also study the alignment of rotationally excited states.
+A new feature in this case is that the magnetic quantum number "m" no longer needs to be zero.
+Let us reproduce figure 3 of ref.[^ref-paper].
+
+```{code-cell}
+data = [calculate_alignment(Delta=400, sigma=0.05, l0=5, m=m) for m in range(6)]
+
+times = data[0][0]
+results = [vals for (t, vals) in data]
+
+average = results[0]
+for m in range(1,6):
+    average = average + 2 * results[m]
+average /= 11
+
+plt.plot(times, average, '-k',
+         times, results[0], '-.k',
+         times, results[2], '--k',
+         times, results[4], ':k');
+```
+
+The plot shows the average over all magnetic quantum numbers (solid line), and the individual results for
+m = 0, 2, 4 (dot-dashed, dashed, dotted line).
+While an increasing magnetic quantum number results in less field-free alignment, the total alignment is
+similar for all even values of m.
+The averaged alignment, however, is significantly damped, and smaller due to the lower alignment of odd values of m.
+
+[^ref-paper]: Oritgoso et al. https://dx.doi.org/10.1063/1.478241

wavepacket-0.2.0/doc/getting-started.rst

@@ -0,0 +1,55 @@
+Getting started
+===============
+
+To demonstrate the usage of Wavepacket, let us dive right into
+a simulation of a one-dimensional free particle.
+
+.. code-block:: python
+
+    import math
+    import wavepacket as wp
+
+    dof = wp.grid.PlaneWaveDof(-20, 20, 128)
+    grid = wp.grid.Grid(dof)
+
+    hamiltonian = wp.operator.CartesianKineticEnergy(grid, 0, mass=1.0)
+    equation = wp.expression.SchroedingerEquation(hamiltonian)
+
+    psi0 = wp.builder.product_wave_function(grid,
+                                            wp.Gaussian(x=0, p=0, fwhm=1))
+
+    solver = wp.solver.OdeSolver(equation, dt=math.pi/5)
+    for t, psi in solver.propagate(psi0, t0=0, num_steps=20):
+        # do something with the solution psi
+
+This program already highlights the basic structure of a Wavepacket simulation:
+
+1. You first need to set up a grid / basis expansion for your system.
+   For that, you need to define the grid along each degree of freedom,
+   and then form the multidimensional grid as the direct product of the
+   one-dimensional grids. Note that Wavepacket uses exclusively the DVR / pseudo-spectral method,
+   see :doc:`representations` or [#dvr]_.
+2. Given a grid, you can define your equations of motion.
+   Again, this step consists of two parts: First, you define all relevant
+   operators, for example the Hamiltonian, then you wrap these operators
+   into components for your equation of motion. For Wavepacket dynamics,
+   you usually want to setup a Schroedinger equation, but for density operators,
+   you may compose your equation from various commutators, anticommutators,
+   Lindblad Liouvillians etc.
+3. Next you specify your initial state that you want to evolve in time.
+4. Finally, you set up the solver for your equations of motion, and propagate
+   your initial state in time [#solvers]_.
+
+This programmatic approach is rather complex and verbose when compared to more rigid programs.
+For example, Matlab Wavepacket only requires you to set the various parameters, which makes the scripts
+shorter and simpler.
+However, the Python version allows more flexibility when you use more complex setups.
+For example, you can almost seamlessly switch between density operator and wavepacket descriptions,
+see the :ref:`tutorial-schroedinger-cat` demo, or you can propagate an ensemble of random thermal
+wave functions to replicate a thermal system (TODO: translate demo).
+
+
+.. [#dvr] See the explanation of the DVR method in the
+   `Wavepacket wiki <https://sourceforge.net/p/wavepacket/wiki/Numerics.DVR>`_.
+.. [#solvers] See the
+   `discussion of ODE solvers <https://sourceforge.net/p/wavepacket/cpp/blog/2021/04/convergence-2/>`_.

wavepacket-0.2.0/doc/index.rst

@@ -0,0 +1,64 @@
+Wavepacket documentation
+========================
+
+Wavepacket allows you to easily set up and simulate smaller quantum
+systems. It is particularly well suited for small molecule molecular dynamics
+or for teaching.
+
+The current Python package is the offspring of a longer history of
+development, there is also a maintained Matlab implementation and a
+superseded C++ implementation.
+
+Features
+--------
+
+- Uses the DVR approximation, which allows you to define
+  potentials directly as functions in real space.
+  See :doc:`representations` for more information.
+- Directly solves the differential equations numerically.
+  This is slower than clever methods like MCTDH, but easier to use.
+- Most functions accept wave functions as well as density operators,
+  allowing you to move between closed and open quantum systems with
+  few code changes.
+- You can easily define complex setups: Want to use an ensemble of
+  random thermal wave functions? Can be easily done.
+  Summing over all magnetic quantum numbers m for a given initial
+  angular momentum? No problem.
+
+
+Bugs / Requests
+---------------
+
+If you find a bug, have a feature request, or even need support, feel
+free to use the `issue tracker <https://github.com/ulflor/wavepacket/features>`_.
+
+
+.. toctree::
+    :caption: Introduction
+
+    getting-started
+    architecture
+    representations
+
+.. toctree::
+   :caption: Tutorials for typical usages
+
+   tutorials/schroedinger_cat
+   tutorials/plotting
+
+.. toctree::
+    :caption: Demos
+
+    demos/pendular_states
+
+.. toctree::
+    :caption: Other links
+
+    Project homepage <https://github.com/ulflor/wavepacket>
+    Wavepacket wiki <https://sourceforge.net/p/wavepacket/wiki>
+
+.. toctree::
+   :caption: API
+   :maxdepth: 4
+
+   autoapi/index

wavepacket-0.2.0/doc/make.bat

@@ -0,0 +1,35 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=.
+set BUILDDIR=_build
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.https://www.sphinx-doc.org/
+	exit /b 1
+)
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd