The Tomographer C++ Framework groups a set of classes and functions which allow to reliably analyze data from quantum experiments. These serve in particular as components for the tomorun executable program.

The API documentation for the Python interface to Tomographer is available here.

Tomographer's Components

The classes and routines of the project belong to several categories.

Generic Tools

These are basic tools and utilities:

Tools for storing and manipulating histograms, such as Tomographer::Histogram and Tomographer::HistogramWithErrorBars;
Most tools, e.g. C++ language utilities and other tools, are defined in the namespace Tomographer::Tools;
Tomographer::MAT provides a set of routines to read data from MATLAB files (based on the MatIO library);
Tomographer provides a lightweight mechanism for logging messages. See Logging and Loggers;
Some more utilities are provided in the namespace Tomographer::MathTools (generate a Haar-random unitary, manipulate spherical coordinates, etc.).

Engine for Running a Metropolis-Hastings Random Walk

The Tomographer::MHRandomWalk takes care of running a Metropolis-Hastings random walk. You need to give it a specification of the random walk parameters, including what the state space is, the jump function, starting point, step size, etc. in the form of a type implementing the MHWalker Interface.
While running the random walk, you'll want to collect some form of statistics. This is done with objects which comply with the MHRWStatsCollector Interface. For example, see Tomographer::ValueHistogramMHRWStatsCollector and Tomographer::ValueHistogramWithBinningMHRWStatsCollector.
For example a specific implementation: The Tomographer::DenseDM::TSpace::LLHMHWalker is a type implementing the MHWalker Interface, which is capable of running a random walk on the space of quantum states represented by dense C++ Eigen matrices, and using the distribution proportional to the loglikelihood function on the Hilbert-Schmidt measure.

Engine for Multiprocessing: Running Tasks in Parallel

An abstract multiprocessing framework is specified using a set of interfaces, see Multiprocessing Task Interfaces. This requires on one hand an implementation of a multiprocessing environment, and on the other hand a specification of which tasks are to be run.
Classes in the Tomographer::MultiProc::OMP namespace are an implementation of a multiprocessing environment using OpenMP. This dispatches the tasks over several threads (on a same machine).

Both Together: Running Metropolis-Hastings Random Walks in Parallel

The Tomographer::MHRWTasks namespace groups a set of classes which may be used to specify a series of Metropolis-Hastings random walks to be run in parallel, which can be executed by a Multiprocessing Task Interfaces such as Tomographer::MultiProc::OMP.
On top of this the classes in Tomographer::MHRWTasks::ValueHistogramTools provide more specific definitions for collecting a histogram about a value (e.g. figure of merit) during a Metropolis-Hastings random walk.

Specific Implementation for Quantum States Specified as Densely Stored Matrices

These classes provide the types and specification of how to perform the random walk, how to calculate the loglikelihood function as well as the figures of merit for quantum states, with the quantum states and POVM effects stored explicitly as matrices (either directly, or via a X Parameterization or T Parameterization). Classes relating to this implementation are located in the Tomographer::DenseDM namespace.

Currently, this is the only concrete implementation of our tomography method. In the future, one could imagine extensions to other implementations, such as directly performing the random walk in the X-parameterization space.

The Tomographer::DenseDM::DMTypes class defines some canonical types for this implementation, such as the type used to store a matrix, the type used to store a X-parameterziation vector, etc.
A class implementing the DenseLLH Interface is capable of calculating the loglikelihood function for a particular experiment. Currently, we only support observed POVM effects which can be written as a product of POVM effects (though this is not necessarily a product POVM!), in the class Tomographer::DenseDM::IndepMeasLLH.
The class Tomographer::DenseDM::TSpace::LLHMHWalker specifies the random walk in T-space on the basis of given types (in DMTypes) and a way to calculate the LLH function (via a DenseLLH Interface compliant object).
Some predefined figures of merit for the random walk in T space are defined as FidelityToRefCalculator, PurifDistToRefCalculator, TrDistToRefCalculator, and ObservableValueCalculator.

Tools for writing C++ code interfaced with Python

A set of typedefs and utilities provided in the namespace tpy allow you to easily write fast C++ code using the above components, while providing a convenient Python interface for easy control and manipulation. See here for more info.

Documentation Pages

Important Namespaces

Tomographer — base Tomographer namespace
Tomographer::Tools — various C++ language-related tools
Tomographer::MathTools — various mathematical tools
Additional tools are available in selected namespaces. See the List of Namespaces.

Specific Topics

Other Specific Resources

Useful Resources for Debugging

Tomorun — The Standalone Executable

The tomorun command-line program is simply a straightforward piecing together of the different components detailed above. It can be used as a standalone program, giving it the measurement data as input (via a MATLAB data file), and retrieving the final histogram of the figure of merit as output.

For help on using tomorun, refer to this "getting started" page, or query its help text using tomorun --help.

Topics:

Known Bugs & To Do List

Bug List
To Do List