infophysics / entropictrajectories

The Entropic Trajectories Framework: Many Body QM Simulations and Analysis.

Entropic Trajectories

This is the Entropic Trajectories library which is a framework for solving many-body quantum systems. For a the full technical documentation see ... For various papers using the ET framework see ...

Prerequisites

The Entropic Trajectories Framework uses many existing packages under the hood. These include the BLAS and LAPACK libraries, which must be installed before cloning this repository. BLAS and LAPACK can be found at,

• BLAS (Basic Linear Algebra Subprograms); http://www.netlib.org/blas/
• LAPACK (Linear Algebra PACKage); http://www.netlib.org/lapack/
• LAPACKe (C wrapper for LAPACK); https://www.netlib.org/lapack/lapacke.html

Linux installation

Make sure that you have the python development environment installed,

$ sudo apt-get install python3-dev

You will also need a suitable version of CMake and GCC,

$ sudo apt-get install cmake
$ sudo apt-get install gcc

To install BLAS and LAPACK (LAPACKe) on Ubuntu simply run the following command in the terminal,

$ sudo apt-get install libblas-dev checkinstall
$ sudo apt-get install libblas-doc checkinstall
$ sudo apt-get install liblapacke-dev checkinstall
$ sudo apt-get install liblapack-doc checkinstall
$ sudo apt-get instlal libopenblas-dev checkinstall

OpenBLAS is also needed for some of the methods included in CBLAS. Other distributions can likely issue a similar command with different package managers (See https://distrowatch.com/dwres.php?resource=package-management for a list of common ones). You will also need a fortran compiler if you don't already have one,

$ sudo apt-get install gfortran

Again, other distributions will use a similar command with a different package manager.

Windows

Pybind11

The ET framework uses a python wrapper called pybind11 in order to generate python bindings.

• Pybind11; https://github.com/pybind/pybind11 (Wenzel Jakob) Pybind is compiled together with the ET framework, so one only needs to extract the source files into the include directory. This is done automatically via a submodule.

TODO:

Installing from PyPI

For 64-bit Linux or Mac systems, instally 'etraj' should just require running:

pip install etraj

You can then test that it works by running the example above.

Installing from source

Requirements: You must have CMake>=2.8.12 and a C++11 compatible compiler (GCC>=4.8) to build.

First, you must check out this repository using the recursive command in order to download the latest versions of the included libraries as well,

$ git clone --recurse-submodules [email protected]:infophysics/EntropicTrajectories.git

If the recursive command failed, you can download the main files and simply update the submodules using,

$ git clone [email protected]:infophysics/EntropicTrajectories.git
$ git submodule init
$ git submodule update

Then, once all of the submodules are there, simply run the installer,

$ python setup.py install

Usage

Python bindings to the Entropic Trajectories library:

import etraj

For more examples on possible calls, please see the tests folder.

Support

• Bugs: Please report bugs to the issue tracker on Github such that we can keep track of them and eventually fix them. Please explain how to reproduce the issue (including code) and which system you are running on.
• Help: Help can be provided also via the issue tracker by tagging your issue with 'question'
• Contributing: Please fork this repository then make a pull request. In this pull request, explain the details of your change and include tests.

Technical implementation

• Implementation also based on this

See AUTHORS.md for information on the developers.

Citation

When you use etraj, please say so in your slides or publications (for publications, see Zenodo link above). You can mention this in addition to how you cite EntropicTrajectories. This is important for us being able to get funding to support this project.

entropictrajectories's Issues

imgui

Add an imgui interface so that people can use c++ directly rather than python.

BLAS Level two

Need to finish implementing BLAS level two functions. There should be a complete set of tests as well as speed tests for these functions and their wrappers in python.

Matrix classification functions. We need methods for determining whether a given matrix is square, symmetric, upper triangular, lower triangular, hermitian, banded, etc.

Iterators

Need to add iterator functionality to Vector, Grid, and Field classes.

Hierarchy of class ownerships

There are some issues with class ownership between Grid, Field and Interpolator and the various parameters of things like "the number of nearest neighbors" to use in a KDTree search and the number of neighbors for a given monomial expansion. All of these things should agree all the time, so special care needs to be taken to ensure this throughout the code.

Matrix Classification. There should be an enumeration of different matrix types and a container that holds various types for a given matrix.

RBF-FD

Create methods for implementing the RBF-FD method for computing derivatives using the RBF approximation.

Global interpolation functions

Need to add a set of global interpolation functions so that interpolations can be performed without explicitly creating Interpolator classes. Much in the style of what can be found in scipy.

Local Taylor Expansion - get an actual function interpolation for a point.

Create some methods for returning either an abstract function approximation at a point, or some way of generating samples from a set of approximation parameters. Maybe some kind of abstract ScalarFieldFunction or something.

RK4 Integration

Finish implementing the abstract Integrator class and a subclass for implementing RK4 approximations. The Integrator class will need a DiffEQ definition that will be fed into different algorithms in the subclasses.

Info, trace and error messages

Each object, i.e. Vector, Matrix, Grid, etc., needs to have an attribute called "_info", which will be a string containing pertinent temporary information. For example, if a matrix multiplication fails, the object it was called on will log a message in _info so that a logging system can extract the relevant information and record it.

Matrix Notebooks. There should be some notebooks demonstrating various linear algebra techniques using the Matrix class. This will rely on more complex methods such as the linear solver from BLAS level two and SVD from LAPACK. It would also be good to utilize QR and LU decompositions.

Constrained Least Squares

Currently we create a global Taylor expansion interpolant in one dimension. There is the beginning of a constrained least squares being developed inside the interpolation and interpolant classes, however it needs to be fully implemented and tested (easiest with the heat equation).

Logging system

Update the logging system to use a pre-compiler expression that chooses either a global logger or individual loggers at compile time. This would define the void init() function and the message functions at compile time using some CMake option like -DLOG_LEVEL=GLOBAL, -DLOG_LEVEL=LOCAL.