Roadmap
This is not a detailed plan of the releases until the stable version. Instead, there is usually an outline only of the next few releases, and a couple of notes what needs to be finished.
Alpha
The current alpha releases are focused on getting the framework done. That is, implementing code for all important typical use-cases. Specific implementations, e.g., special grids etc. may be skipped, unless they alter the interface.
Arc 0.4: Most of Matlab-version functionality and stable API
The goal of this arc is to implement at least the scaffold for most of the functionality that makes the Matlab version usable. This encompasses a range of issues from plotting to easier handling of electronic states. In particular, the following maor topics should be done:
- add missing convenience operators and functions. These are things like rectangular electric fields, and such.
- Logging output
- Wavefunction saving and loading (so you do not have to propagate again and again)
- Plotting. This is a big issue in general, and the Python version will help a lot here.
- Split operator. This has some prerequisites, for example you need to exponentiate operators (which is tricky in general)
- state transformations. In particular Wigner transformations (for nicer plots) and diabatic/adiabatic representations are an issue here.
- Lots of convenience issues. For example, dealing with multiple electronic states must be easier / less verbose. Compilation should be generally simpler; we should have a Windows version and all such things.
In addition, I slowly get fed up with always changing the layout of classes etc. That is why I would also put a strong focus on rearranging the classes so I will change only little later on. And, to be able to substitute the Matlab version, I also need to be able to compile Wavepacket under Windows. This is a bit of a pain, so some restructuring of the build code is required.
0.3.6 (done, 06-May-2024)
Main changes are an upgrade of the tensor library. This opened up big item #2: Providing a crude but working binary package for Windows, and an improved Vagrantfile that can double as a compilation howto. Plotting for two-dimensional states was added, and also a Faber polynomial propagator. Also, added truncation of operators and some spectrum estimation functions.
0.3.5 (done, 10-Apr-2023)
The main improvement was that the whole workflow of setting up an open systems matrix in the energy eigenstate representation works now. Given a diagonalization scheme and a spectrum, you can rather easily set up a Lindblad Liouvillian.
Apart from that, mostly smaller features. Normalization of names that break a lot of API, an overhaul of the build (not quite done) to cut off outdated things, and a bunch of smaller features (Lorentzian, rectangular pulses with soft turn-on, orthnormalization of a set of states).
0.3.4 (done, 09-Jan-2022)
Roadmap-wise, there were three main improvements. I added a Vagrant VM setup that should make Wavepacket way more comfortable to use. The Python plotting looks a lot better now, with things like customizable x/y-axis etc. And operator exponentiation was introduced, albeit in a rather simple manner; this should slowly pave the way towards NIPs and the split-operator method.
0.3.3 (done, 08-Aug-2021)
There were two major roadmap improvements. On one hand, I added Python code to the Python module in the form of plots. Not very useful yet because the plots only deal with one-dimensional wave functions, but that is a major technology change, and we can go for reasonably-looking plots soon enough. The other major change was a reorganization of the operator hierarchy. Most operators now derive from a handful of base classes, so that in a next step we can reason about them, for example to implement the split-operator scheme.
0.3.2 (done, 26-Jan-2021)
More refactoring. Renamed some basic classes to have a consistent naming scheme w.r.t. the documentation. Introduced a new State class that encapsulates coefficients and a grid to further hide tensor classes and avoid having to pass a grid everywhere. Python interface is now built as part of CMake build (should be helpful for Windows); added a helper function to simplify relaxation of wavefunctions.
0.3.1 (done, 29-Jul-2020)
Lots of refactoring, few new features. Cleaned up the normal build to be more robust, have fewer dependencies etc. And I gutted two crucial classes: Manipulator contained functions to access operations that differ fundamentally between densities and wavefunctions. These are now free functions and were extended a little. Second, grid classes lost almost all their functionality, again to some free functions and newly introduced transformation classes.
Arc 0.3: Advanced usability Python package (done)
There are two main goals here. One are leftovers from the previous arc in terms of usability. For example, it is still too complicated to compile an own program (the user needs to play around with CMake). The other issue is related with the development platform / building: I want to have automated regression testing when I commit, for example, or there should be fewer dependencies on boost to speed up the compilation.
Of course, some additional functionality will still be implemented, it is just not the main focus.
Update: Since a Python interface seems not too hard to achieve, I decided to change focus and attempt to finish the Python interface first.
0.2.1 (done, 03-Apr-2018)
Compilation of user programs should be much simpler thanks to a new helper script (also with tutorial). Added a HarmonicOscillatorFactory to simplify setup of harmonic oscillator operators, which now also includes ladder operators. Added another demo that showcases laser-induced vibrational excitation of a Morse oscillator. Tried to make the RedfieldFactory more usable, though there is still work left. Finally, there were some minor internal restructurings to help with the coding (automated testing of demos, setup of code checkers, removal of dependencies, this sort of thing).
0.2.2 (done, 19-Aug-2018)
Sped up compilation a lot (faster turnaround during development mainly), which also reduces some dependencies. Added suffixes to express values in other units than atomic units, and an OscillatingField operator and functors to simplify the setup of laser fields. Finally, developed a prototype to have the WavePacket functionality available in Python. Not yet usable, but it works in principle.
0.2.3 (done, 24-Dec-2018)
The python prototype is well on track, with the last principal issues sorted out; you can now define functions in python and use them in the C++ code. Added a first simplification that can take a Hamiltonian and combine all the potential-like terms into a single operator, thus speeding up the computation. Finally, due to a user request, implemented a complex pump-probe demo with a host of accompagnying changes.
0.2.4 (done, 28-Apr-2019)
Python interface can be installed as a proper module. Some major renaming to disentangle different concepts. A couple of new demos that demonstrate different electronic states, thermalized states and Lindblad Liouvillians. Fixed and improbed some PropagationObservers, namely for logging and plot output.
0.3 (done, 30-Dec-2019)
The Python prototype was finished including porting all demos to Python. Also some cleanup here and there: The StateBuilder class was split into simple component functions and additional functions were added. The dependency on GFlags was removed, this is mostly obsoleted by the Python interface.
Arc 0.2: Basic usability (done)
The overall goal now is the inclusion of more complicated things and the finalization of various interfaces. Also, the documentation and build system should be upgraded.
0.1.1 (done, 02-Jun-2016)
Goal: Clean up the propagator interface, add electric fields.
We want to implement the Chebychev propagator, which requires a lot of time information to be set in advance. Any interface that can handle a Chebychev propagator should be able to handle more or less any other propagator. Also, time-dependent operators should be implemented in a way that they are easy to use (for laser fields, especially). The same holds for potentials and initial wave functions, both of which profit from using functors.
0.1.2 (done, 28-Dec-2016)
The Chebychev propagator has been improved with an auto-determination of
the operator spectrum. This should make the standard usage simpler. Also,
added a diagonalizer to solve for eigenstates and energies of a Hamiltonian.
Furthermore, the documentation was enhanced considerably, and the build
system switched to CMake. The new build system is considerably more complex,
but we hope to reap some benefits later, such as automated compilation of
dependencies or Windows-builds.
0.1.3 (done, 16-Mar-2017)
Grids and operators have been introduced to easily handle multiple coupled channels. A class to easily parse command line options and configuration files has been added. Finally, the documentation has been extended with additional tutorials and extensive covering of these new features
0.1.4 (done, 29-May-2017)
Got sidetracked by a user request for spherical harmonics.
Several classes for rotational problems have been added, in particular a grid for expanding in spherical harmonics, the corresponding angular momentum operator, and fitting initial wave functions. Also, some functionality to conveniently calculate expectation values and output the data to a file (e.g. for plotting) has been added. Plus some minor cleanup as usual.
0.2.0 (done, 03-Dec-2017)
Elementary plotting is implemented, and absorbing boundary conditions can be added to a Hamiltonian. Some minor cleanups were also done (more stable tests with fixed random seed, layout cleanup, more permissive license).
Arc 0.1: Basic functionality (done)
Get some basic functionality up and running, so that the program could in theory be used for real work. Low-hanging fruit are open systems (Lindblad and Redfield-style dissipation), which is the final goal for this arc.
0.0.1 (done, 13-Sep-2013)
Goal: Get a simple propagation of a free particle up and running.
This requires the basic layout and an implementation of the basic interfaces (grids, operators, propagators)
0.0.2 (done 27-Oct-2013)
Goal: Propagate a harmonic oscillator.
Requires composition of operators (addition, maybe also multiplication of operators). Also, multidimensional grids should be introduced.
0.0.3 (done 13-Apr-2014)
Goal: Propagate some density operator with Lindblad dissipation.
This requires a careful introduction of Liouville-space operators. A specific goal is to recycle the code of the normal operators and employ it to propagate density operators.
0.1.0 (done 18-Nov-2014)
Goal: Propagate a density operator using Redfield theory.
The nice thing with Redfield theory is that you need to evaluate some operator in the interaction picture, which requires as much flexibility as you can get. Also, with this release, the program would become useful for early adopters, such as me.
