Quick guide to QCLS

QCLS: Cluster Expansion Based Solver for Open Quantum System

Install

Requirement

C++ Build environment (Simply download VSBuildTools and install C++ build tools if you don't know how to configure it.)
Python 3.7 and later version
Scipy 1.4.1 and later version
numpy 1.16.5 and later version

Quick install
```
pip install -r requirements.txt
```

Setup

Install manually

Run the following code under the path ./cluster_py

python ./setup.py install

Install via pip

pip install QCLSolver

Install via conda (python<3.9)

conda install -c yesunhuang qclsolver

Suggested way of import

from QCLSolver.solver import Solve
from QCLSolver.data import Data
from QCLSolver.tool import*

Genernal procedure

Using QCLS is quite similar to using the mesolve in QuTiP, a quite simple procedure can be followed:

Create lists for representing the Hamiltonian, collapse operators and the initial state. Determine the tracking operators and the required cluster-expansion order.

(We are using the upper class English letters to represent creation operators and lower class ones to represent the annihilation operators. The system will automatically detect how many different letters u have inputted and assume the same number of modes in the system. )
Derive the equations for the systems using the construct function of Data class and store the instance.
Feed the Data instance into the Solve method and evolve the system.
Process the and visualize the result.

Quick Example

The following code shows how to use QCLS to simulate the Janes-Cumming model. (See also the same title notebooks from Quantum mechanics lectures with QuTiP)

The Hamiltonian can be expressed as

#parameters
wc = 1.0  * 2 * pi  # cavity frequency
wa = 1.0  * 2 * pi  # atom frequency
g  = 0.05 * 2 * pi  # coupling strength
kappa = 0.005       # cavity dissipation rate
gamma = 0.05  

#Create the time list
tlist = np.linspace(0,25,101) #numpy has been imported as np

#Build up the Hamiltonian operators
Hamilton = [['Aa',wc],['Bb',wa],['Ab',g],['aB',g]]

#Build up the Collapse operators
Co_ps = [['a',kappa ],['b',gamma ]]

#Define the inital states (Only folk states are supported now)
psi0 = [0,1]

#Add the tracking operators (The result will be returned at the same order of the operators in T_o)
T_o = ['Aa','Bb']

#Derive the equations under the expanson order of 2
data = Data(Hamilton ,Co_ps , T_o , 2)

#Evolve the system (We are using the ODE solver `solve_vip` from scipy, thus the parameters and the output forms are almost identity  )
sol = Solve(data , psi0, (0,25), t_eval = tlist )

#Visualize the result via matplotlib
fig, axes = plt.subplots(1, 1, figsize=(10,6))

axes.plot(tlist, np.real(sol.y[0]),color='red',linestyle='--',label="Cavity(QCLS)")
axes.plot(tlist, np.real(sol.y[1]),color='blue',linestyle='--',label="Atom excited state(QCLS)")
axes.legend(loc=0)
axes.set_xlabel('Time')
axes.set_ylabel('Occupation probability')

plt.show()

API

1.Data Class

1.1 Constructor

Prototype

class Data:
    def __init__(self, H, Co_ps, trackList, maxOPLen)

Parameters
1. H: The list of Hamiltonian, the form should be of [['Operators','Coefficient']], Coefficient can be a complex number or a function
2. Co_ps: Collapse operators, the form is the same as Hamiltonian.
3. trackOp: The list of the operators whose mean value you are going to track.
4. maxOPLen: The order of cluster expansion

1.2 UpdateInitialState(...)

Prototype

def UpdateInitialState(self, initialState)

Parameters
1. initialState: A list of initial folk states. The order of mode is following the alphabet order of the letters u used to represent the operators.
Return

A list of new current mean value of tracking operators calculated based on the initial state.