# Function Reference¶

## Lattice1D Class¶

class trottersuzuki.Lattice1D

This class defines the lattice structure over which the state and potential matrices are defined.

Constructors

Lattice1D(dim_x, length_x, periodic_x_axis=False, coordinate_system="cartesian")

Construct a one-dimensional lattice.

Parameters

• dim_x : integer
Linear dimension of the squared lattice in the x direction.
• length_x : float
Physical length of the lattice’s side in the x direction.
• periodic_x_axis : bool,optional (default: False)
Boundary condition along the x axis (false=closed, true=periodic).
• coordinate_system : string,optional (default: “cartesian”)
Coordinates of the physical space (“cartesian” or “cylindrical”).

Returns

• Lattice1D : Lattice1D object
Define the geometry of the simulation.

Notes

For cylindrical coordinates the radial coordinate is used.

Example

>>> import trottersuzuki as ts  # import the module
>>> # Generate a 200-point Lattice1D with physical dimensions of 30
>>> # and closed boundary conditions.
>>> grid = ts.Lattice1D(200, 30.)


Members

get_x_axis()

Get the x-axis of the lattice.

Returns

• x_axis : numpy array
X-axis of the lattice

Attributes

length_x

Physical length of the lattice along the X-axis.

dim_x

Number of dots of the lattice along the X-axis.

delta_x

Resolution of the lattice along the X-axis: ratio between lenth_x and dim_x.

## Lattice2D Class¶

class trottersuzuki.Lattice2D

This class defines the lattice structure over which the state and potential matrices are defined.

Constructors

Lattice2D(dim_x, length_x, dim_y=None, length_y=None, periodic_x_axis=False, periodic_y_axis=False, coordinate_system="cartesian")

Construct the Lattice2D.

Parameters

• dim_x : integer
Linear dimension of the squared lattice in the x direction.
• length_x : float
Physical length of the lattice’s side in the x direction.
• dim_y : integer,optional (default: equal to dim_x)
Linear dimension of the squared lattice in the y direction.
• length_y : float,optional (default: equal to length_x)
Physical length of the lattice’s side in the y direction.
• periodic_x_axis : bool,optional (default: False)
Boundary condition along the x axis (false=closed, true=periodic).
• periodic_y_axis : bool,optional (default: False)
Boundary condition along the y axis (false=closed, true=periodic).
• angular_velocity : float, optional (default: 0.)
Angular velocity of the rotating reference frame (only for Cartesian coordinates).
• coordinate_system : string,optional (default: “cartesian”)
Coordinates of the physical space (“cartesian” or “cylindrical”).

Returns

• Lattice2D : Lattice2D object
Define the geometry of the simulation.

Notes

For cylindrical coordinates the radial coordinate is in place of the x-axis and the axial one is in place of the y-axis.

Example

>>> import trottersuzuki as ts  # import the module
>>> # Generate a 200x200 Lattice2D with physical dimensions of 30x30
>>> # and closed boundary conditions.
>>> grid = ts.Lattice2D(200, 30.)


Members

get_x_axis()

Get the x-axis of the lattice.

Returns

• x_axis : numpy array
X-axis of the lattice
get_y_axis()

Get the y-axis of the lattice.

Returns

• y_axis : numpy array
Y-axis of the lattice

Attributes

length_x

Physical length of the lattice along the X-axis.

length_y

Physical length of the lattice along the Y-axis.

dim_x

Number of dots of the lattice along the X-axis.

dim_y

Number of dots of the lattice along the Y-axis.

delta_x

Resolution of the lattice along the X-axis: ratio between lenth_x and dim_x.

delta_y

Resolution of the lattice along the y-axis: ratio between lenth_y and dim_y.

## State Classes¶

class trottersuzuki.State

This class defines the quantum state.

Constructors

State(grid, angular_momentum)

Create a quantum state.

Parameters

• grid : Lattice object
Define the geometry of the simulation.
• angular_momentum : integer, optional (default: 0)
Angular momentum for the cylindrical coordinates.

Returns

• state : State object
Quantum state.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D()  # Define the simulation's geometry
>>> def wave_function(x,y):  # Define a flat wave function
>>>     return 1.
>>> state = ts.State(grid)  # Create the system's state
>>> state.ini_state(wave_function)  # Initialize the wave function of the state

State(state)

Copy a quantum state.

Parameters

• state : State object
Quantum state to be copied

Returns

• state : State object
Quantum state.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D()  # Define the simulation's geometry
>>> state = ts.GaussianState(grid, 1.)  # Create the system's state with a gaussian wave function
>>> state2 = ts.State(state)  # Copy state into state2


Members

State.init_state(state_function):

Initialize the wave function of the state using a function.

Parameters

• state_function : python function
Python function defining the wave function of the state $$\psi$$.

Notes

The input arguments of the python function must be (x,y).

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D()  # Define the simulation's geometry
>>> def wave_function(x,y):  # Define a flat wave function
>>>     return 1.
>>> state = ts.State(grid)  # Create the system's state
>>> state.ini_state(wave_function)  # Initialize the wave function of the state

imprint(function)

Multiply the wave function of the state by the function provided.

Parameters

• function : python function
Function to be printed on the state.

Notes

Useful, for instance, to imprint solitons and vortices on a condensate. Generally, it performs a transformation of the state whose wave function becomes:

$\psi(x,y)' = f(x,y) \psi(x,y)$

being $$f(x,y)$$ the input function and $$\psi(x,y)$$ the initial wave function.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D()  # Define the simulation's geometry
>>> def vortex(x,y):  # Vortex function
>>>     z = x + 1j*y
>>>     angle = np.angle(z)
>>>     return np.exp(1j * angle)
>>> state = ts.GaussianState(grid, 1.)  # Create the system's state
>>> state.imprint(vortex)  # Imprint a vortex on the state

get_mean_px()

Return the expected value of the $$P_x$$ operator.

Returns

• mean_px : float
Expected value of the $$P_x$$ operator.
get_mean_pxpx()

Return the expected value of the $$P_x^2$$ operator.

Returns

• mean_pxpx : float
Expected value of the $$P_x^2$$ operator.
get_mean_py()

Return the expected value of the $$P_y$$ operator.

Returns

• mean_py : float
Expected value of the $$P_y$$ operator.
get_mean_pypy()

Return the expected value of the $$P_y^2$$ operator.

Returns

• mean_pypy : float
Expected value of the $$P_y^2$$ operator.
get_mean_x()

Return the expected value of the $$X$$ operator.

Returns

• mean_x : float
Expected value of the $$X$$ operator.
get_mean_xx()

Return the expected value of the $$X^2$$ operator.

Returns

• mean_xx : float
Expected value of the $$X^2$$ operator.
get_mean_y()

Return the expected value of the $$Y$$ operator.

Returns

• mean_y : float
Expected value of the $$Y$$ operator.
get_mean_yy()

Return the expected value of the $$Y^2$$ operator.

Returns

• mean_yy : float
Expected value of the $$Y^2$$ operator.
get_particle_density()

Return a matrix storing the squared norm of the wave function.

Returns

• particle_density : numpy matrix
Particle density of the state $$|\psi(x,y)|^2$$
get_phase()

Return a matrix of the wave function’s phase.

Returns

• get_phase : numpy matrix
Matrix of the wave function’s phase $$\phi(x,y) = \log(\psi(x,y))$$
get_squared_norm()

Return the squared norm of the quantum state.

Returns

• squared_norm : float
Squared norm of the quantum state.
loadtxt(file_name)

Load the wave function from a file.

Parameters

• file_name : string
Name of the file to be written.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D()  # Define the simulation's geometry
>>> state = ts.GaussianState(grid, 1.)  # Create the system's state
>>> state.write_to_file('wave_function.txt')  # Write to a file the wave function
>>> state2 = ts.State(grid)  # Create a quantum state
>>> state2.loadtxt('wave_function.txt')  # Load the wave function

write_particle_density(file_name)

Write to a file the particle density matrix of the wave function.

Parameters

• file_name : string
Name of the file.
write_phase(file_name)

Write to a file the wave function.

Parameters

• file_name : string
Name of the file to be written.
write_to_file(file_name)

Write to a file the wave function.

Parameters

• file_name : string
Name of the file to be written.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D()  # Define the simulation's geometry
>>> state = ts.GaussianState(grid, 1.)  # Create the system's state
>>> state.write_to_file('wave_function.txt')  # Write to a file the wave function
>>> state2 = ts.State(grid)  # Create a quantum state
>>> state2.loadtxt('wave_function.txt')  # Load the wave function

class trottersuzuki.BesselState

This class defines a quantum state with sinusoidal like wave function.

This class is a child of State class.

Constructors

BesselState(grid, angular_momentum=0, zeros=1, n_y=0, norm=1, phase=0)

Construct the quantum state with wave function given by a first kind of Bessel functions.

Parameters

• grid : Lattice object
Define the geometry of the simulation.
• angular_momentum : integer, optional (default: 0)
Angular momentum for the cylindrical coordinates.
• zeros : integer, optional (default: 1)
Number of zeros points along the radial axis.
• n_y : integer, optional (default: 1)
Quantum number (available if grid is a Lattice2D object).
• norm : float, optional (default: 1)
Squared norm of the quantum state.
• phase : float, optional (default: 1)
Relative phase of the wave function.

Returns

• BesselState : State object.

Quantum state with wave function given by a first kind of Bessel functions. The wave function is given by:

$\psi(r,z,\phi) = f(r,z)e^{i l \phi}$

with

$f(r,z) = \sqrt{N}/\tilde{N} J_l(r r_i / L_r) \cos(n_y \pi r / (2L_z)) \mathrm{e}^{(i \phi_0)}$

being $$N$$ the norm of the state, $$\tilde{N}$$ a normalization factor for $$J_l$$, $$J_l$$ the Bessel function of the first kind with angulat momentum $$l$$, $$r_i$$ the radial coordinate of the i-th zero of $$J_l$$ $$L_r$$ the length of the lattice along the radial axis, $$L_z$$ the length of the lattice along the z axis, $$n_y$$ the quantum number and $$\phi_0$$ the relative phase.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D(300, 30., True, True, 0., "cylindrical")  # Define the simulation's geometry
>>> state = ts.BesselState(grid, 2, 1, 1)  # Create the system's state


Members

imprint(function)

Multiply the wave function of the state by the function provided.

Parameters

• function : python function
Function to be printed on the state.

Notes

Useful, for instance, to imprint solitons and vortices on a condensate. Generally, it performs a transformation of the state whose wave function becomes:

$\psi(x,y)' = f(x,y) \psi(x,y)$

being $$f(x,y)$$ the input function and $$\psi(x,y)$$ the initial wave function.

get_mean_px()

Return the expected value of the $$P_x$$ operator.

Returns

• mean_px : float
Expected value of the $$P_x$$ operator.
get_mean_pxpx()

Return the expected value of the $$P_x^2$$ operator.

Returns

• mean_pxpx : float
Expected value of the $$P_x^2$$ operator.
get_mean_py()

Return the expected value of the $$P_y$$ operator.

Returns

• mean_py : float
Expected value of the $$P_y$$ operator.
get_mean_pypy()

Return the expected value of the $$P_y^2$$ operator.

Returns

• mean_pypy : float
Expected value of the $$P_y^2$$ operator.
get_mean_x()

Return the expected value of the $$X$$ operator.

Returns

• mean_x : float
Expected value of the $$X$$ operator.
get_mean_xx()

Return the expected value of the $$X^2$$ operator.

Returns

• mean_xx : float
Expected value of the $$X^2$$ operator.
get_mean_y()

Return the expected value of the $$Y$$ operator.

Returns

• mean_y : float
Expected value of the $$Y$$ operator.
get_mean_yy()

Return the expected value of the $$Y^2$$ operator.

Returns

• mean_yy : float
Expected value of the $$Y^2$$ operator.
get_particle_density()

Return a matrix storing the squared norm of the wave function.

Returns

• particle_density : numpy matrix
Particle density of the state $$|\psi(x,y)|^2$$
get_phase()

Return a matrix of the wave function’s phase.

Returns

• get_phase : numpy matrix
Matrix of the wave function’s phase $$\phi(x,y) = \log(\psi(x,y))$$
get_squared_norm()

Return the squared norm of the quantum state.

Returns

• squared_norm : float
Squared norm of the quantum state.
loadtxt(file_name)

Load the wave function from a file.

Parameters

• file_name : string
Name of the file to be written.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D(300, 30., True, True, 0., "cylindrical")  # Define the simulation's geometry
>>> state = ts.BesselState(grid, 1.)  # Create the system's state
>>> state.write_to_file('wave_function.txt')  # Write to a file the wave function
>>> state2 = ts.State(grid)  # Create a quantum state
>>> state2.loadtxt('wave_function.txt')  # Load the wave function

write_particle_density(file_name)

Write to a file the particle density matrix of the wave function.

Parameters

• file_name : string
Name of the file.
write_phase(file_name)

Write to a file the wave function.

Parameters

• file_name : string
Name of the file to be written.
write_to_file(file_name)

Write to a file the wave function.

Parameters

• file_name : string
Name of the file to be written.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D(300, 30., True, True, 0., "cylindrical")  # Define the simulation's geometry
>>> state = ts.BesselState(grid, 1.)  # Create the system's state
>>> state.write_to_file('wave_function.txt')  # Write to a file the wave function
>>> state2 = ts.State(grid)  # Create a quantum state
>>> state2.loadtxt('wave_function.txt')  # Load the wave function

class trottersuzuki.ExponentialState

This class defines a quantum state with exponential like wave function.

This class is a child of State class.

Constructors

ExponentialState(grid, n_x=1, n_y=1, norm=1, phase=0)

Construct the quantum state with exponential like wave function.

Parameters

• grid : Lattice object
Defines the geometry of the simulation.
• n_x : integer,optional (default: 1)
First quantum number.
• n_y : integer,optional (default: 1)
Second quantum number (available if grid is a Lattice2D object).
• norm : float,optional (default: 1)
Squared norm of the quantum state.
• phase : float,optional (default: 0)
Relative phase of the wave function.

Returns

• ExponentialState : State object.

Quantum state with exponential like wave function. The wave function is give by:n

$\psi(x,y) = \sqrt{N}/L \mathrm{e}^{i 2 \pi (n_x x + n_y y) / L} \mathrm{e}^{i \phi}$

being $$N$$ the norm of the state, $$L$$ the length of the lattice edge, $$n_x$$ and $$n_y$$ the quantum numbers and $$\phi$$ the relative phase.

Notes

The geometry of the simulation has to have periodic boundary condition to use Exponential state as initial state of a real time evolution. Indeed, the wave function is not null at the edges of the space.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D(300, 30., True, True)  # Define the simulation's geometry
>>> state = ts.ExponentialState(grid, 2, 1)  # Create the system's state


Member

imprint(function)

Multiply the wave function of the state by the function provided.

Parameters

• function : python function
Function to be printed on the state.

Notes

Useful, for instance, to imprint solitons and vortices on a condensate. Generally, it performs a transformation of the state whose wave function becomes:

$\psi(x,y)' = f(x,y) \psi(x,y)$

being $$f(x,y)$$ the input function and $$\psi(x,y)$$ the initial wave function.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D()  # Define the simulation's geometry
>>> def vortex(x,y):  # Vortex function
>>>     z = x + 1j*y
>>>     angle = np.angle(z)
>>>     return np.exp(1j * angle)
>>> state = ts.GaussianState(grid, 1.)  # Create the system's state
>>> state.imprint(vortex)  # Imprint a vortex on the state

get_mean_px()

Return the expected value of the $$P_x$$ operator.

Returns

• mean_px : float
Expected value of the $$P_x$$ operator.
get_mean_pxpx()

Return the expected value of the $$P_x^2$$ operator.

Returns

• mean_pxpx : float
Expected value of the $$P_x^2$$ operator.
get_mean_py()

Return the expected value of the $$P_y$$ operator.

Returns

• mean_py : float
Expected value of the $$P_y$$ operator.
get_mean_pypy()

Return the expected value of the $$P_y^2$$ operator.

Returns

• mean_pypy : float
Expected value of the $$P_y^2$$ operator.
get_mean_x()

Return the expected value of the $$X$$ operator.

Returns

• mean_x : float
Expected value of the $$X$$ operator.
get_mean_xx()

Return the expected value of the $$X^2$$ operator.

Returns

• mean_xx : float
Expected value of the $$X^2$$ operator.
get_mean_y()

Return the expected value of the $$Y$$ operator.

Returns

• mean_y : float
Expected value of the $$Y$$ operator.
get_mean_yy()

Return the expected value of the $$Y^2$$ operator.

Returns

• mean_yy : float
Expected value of the $$Y^2$$ operator.
get_particle_density()

Return a matrix storing the squared norm of the wave function.

Returns

• particle_density : numpy matrix
Particle density of the state $$|\psi(x,y)|^2$$
get_phase()

Return a matrix of the wave function’s phase.

Returns

• get_phase : numpy matrix
Matrix of the wave function’s phase $$\phi(x,y) = \log(\psi(x,y))$$
get_squared_norm()

Return the squared norm of the quantum state.

Returns

• squared_norm : float
Squared norm of the quantum state.
loadtxt(file_name)

Load the wave function from a file.

Parameters

• file_name : string
Name of the file to be written.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D()  # Define the simulation's geometry
>>> state = ts.GaussianState(grid, 1.)  # Create the system's state
>>> state.write_to_file('wave_function.txt')  # Write to a file the wave function
>>> state2 = ts.State(grid)  # Create a quantum state
>>> state2.loadtxt('wave_function.txt')  # Load the wave function

write_particle_density(file_name)

Write to a file the particle density matrix of the wave function.

Parameters

• file_name : string
Name of the file.
write_phase(file_name)

Write to a file the wave function.

Parameters

• file_name : string
Name of the file to be written.
write_to_file(file_name)

Write to a file the wave function.

Parameters

• file_name : string
Name of the file to be written.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D()  # Define the simulation's geometry
>>> state = ts.GaussianState(grid, 1.)  # Create the system's state
>>> state.write_to_file('wave_function.txt')  # Write to a file the wave function
>>> state2 = ts.State(grid)  # Create a quantum state
>>> state2.loadtxt('wave_function.txt')  # Load the wave function

class trottersuzuki.GaussianState

This class defines a quantum state with gaussian like wave function.

This class is a child of State class.

Constructors

GaussianState(grid, omega_x, omega_y=omega_x, mean_x=0, mean_y=0, norm=1, phase=0)

Construct the quantum state with gaussian like wave function.

Parameters

• grid : Lattice object
Defines the geometry of the simulation.
• omega_x : float
Inverse of the variance along x-axis.
• omega_y : float, optional (default: omega_x)
Inverse of the variance along y-axis (available if grid is a Lattice2D object).
• mean_x : float, optional (default: 0)
X coordinate of the gaussian function’s peak.
• mean_y : float, optional (default: 0)
Y coordinate of the gaussian function’s peak (available if grid is a Lattice2D object).
• norm : float, optional (default: 1)
Squared norm of the state.
• phase : float, optional (default: 0)
Relative phase of the wave function.

Returns

• GaussianState : State object.

Quantum state with gaussian like wave function. The wave function is given by:n

$\psi(x,y) = (N/\pi)^{1/2} (\omega_x \omega_y)^{1/4} \mathrm{e}^{-(\omega_x(x-\mu_x)^2 + \omega_y(y-\mu_y)^2)/2} \mathrm{e}^{i \phi}$

being $$N$$ the norm of the state, $$\omega_x$$ and $$\omega_y$$ the inverse of the variances, $$\mu_x$$ and $$\mu_y$$ the coordinates of the function’s peak and $$\phi$$ the relative phase.

Notes

The physical dimensions of the Lattice2D have to be enough to ensure that the wave function is almost zero at the edges.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D(300, 30.)  # Define the simulation's geometry
>>> state = ts.GaussianState(grid, 2.)  # Create the system's state


Members

imprint(function)

Multiply the wave function of the state by the function provided.

Parameters

• function : python function
Function to be printed on the state.

Notes

Useful, for instance, to imprint solitons and vortices on a condensate. Generally, it performs a transformation of the state whose wave function becomes:

$\psi(x,y)' = f(x,y) \psi(x,y)$

being $$f(x,y)$$ the input function and $$\psi(x,y)$$ the initial wave function.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D()  # Define the simulation's geometry
>>> def vortex(x,y):  # Vortex function
>>>     z = x + 1j*y
>>>     angle = np.angle(z)
>>>     return np.exp(1j * angle)
>>> state = ts.GaussianState(grid, 1.)  # Create the system's state
>>> state.imprint(vortex)  # Imprint a vortex on the state

get_mean_px()

Return the expected value of the $$P_x$$ operator.

Returns

• mean_px : float
Expected value of the $$P_x$$ operator.
get_mean_pxpx()

Return the expected value of the $$P_x^2$$ operator.

Returns

• mean_pxpx : float
Expected value of the $$P_x^2$$ operator.
get_mean_py()

Return the expected value of the $$P_y$$ operator.

Returns

• mean_py : float
Expected value of the $$P_y$$ operator.
get_mean_pypy()

Return the expected value of the $$P_y^2$$ operator.

Returns

• mean_pypy : float
Expected value of the $$P_y^2$$ operator.
get_mean_x()

Return the expected value of the $$X$$ operator.

Returns

• mean_x : float
Expected value of the $$X$$ operator.
get_mean_xx()

Return the expected value of the $$X^2$$ operator.

Returns

• mean_xx : float
Expected value of the $$X^2$$ operator.
get_mean_y()

Return the expected value of the $$Y$$ operator.

Returns

• mean_y : float
Expected value of the $$Y$$ operator.
get_mean_yy()

Return the expected value of the $$Y^2$$ operator.

Returns

• mean_yy : float
Expected value of the $$Y^2$$ operator.
get_particle_density()

Return a matrix storing the squared norm of the wave function.

Returns

• particle_density : numpy matrix
Particle density of the state $$|\psi(x,y)|^2$$
get_phase()

Return a matrix of the wave function’s phase.

Returns

• get_phase : numpy matrix
Matrix of the wave function’s phase $$\phi(x,y) = \log(\psi(x,y))$$
get_squared_norm()

Return the squared norm of the quantum state.

Returns

• squared_norm : float
Squared norm of the quantum state.
loadtxt(file_name)

Load the wave function from a file.

Parameters

• file_name : string
Name of the file to be written.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D()  # Define the simulation's geometry
>>> state = ts.GaussianState(grid, 1.)  # Create the system's state
>>> state.write_to_file('wave_function.txt')  # Write to a file the wave function
>>> state2 = ts.State(grid)  # Create a quantum state
>>> state2.loadtxt('wave_function.txt')  # Load the wave function

write_particle_density(file_name)

Write to a file the particle density matrix of the wave function.

Parameters

• file_name : string
Name of the file.
write_phase(file_name)

Write to a file the wave function.

Parameters

• file_name : string
Name of the file to be written.
write_to_file(file_name)

Write to a file the wave function.

Parameters

• file_name : string
Name of the file to be written.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D()  # Define the simulation's geometry
>>> state = ts.GaussianState(grid, 1.)  # Create the system's state
>>> state.write_to_file('wave_function.txt')  # Write to a file the wave function
>>> state2 = ts.State(grid)  # Create a quantum state
>>> state2.loadtxt('wave_function.txt')  # Load the wave function

class trottersuzuki.SinusoidState

This class defines a quantum state with sinusoidal like wave function.

This class is a child of State class.

Constructors

SinusoidState(grid, n_x=1, n_y=1, norm=1, phase=0)

Construct the quantum state with sinusoidal like wave function.

Parameters

• grid : Lattice object
Define the geometry of the simulation.
• n_x : integer, optional (default: 1)
First quantum number.
• n_y : integer, optional (default: 1)
Second quantum number (available if grid is a Lattice2D object).
• norm : float, optional (default: 1)
Squared norm of the quantum state.
• phase : float, optional (default: 1)
Relative phase of the wave function.

Returns

• SinusoidState : State object.

Quantum state with sinusoidal like wave function. The wave function is given by:

$\psi(x,y) = 2\sqrt{N}/L \sin(2\pi n_x x / L) \sin(2\pi n_y y / L) \mathrm{e}^{(i \phi)}$

being $$N$$ the norm of the state, $$L$$ the length of the lattice edge, $$n_x$$ and $$n_y$$ the quantum numbers and $$\phi$$ the relative phase.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D(300, 30., True, True)  # Define the simulation's geometry
>>> state = ts.SinusoidState(grid, 2, 0)  # Create the system's state


Members

imprint(function)

Multiply the wave function of the state by the function provided.

Parameters

• function : python function
Function to be printed on the state.

Notes

Useful, for instance, to imprint solitons and vortices on a condensate. Generally, it performs a transformation of the state whose wave function becomes:

$\psi(x,y)' = f(x,y) \psi(x,y)$

being $$f(x,y)$$ the input function and $$\psi(x,y)$$ the initial wave function.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D()  # Define the simulation's geometry
>>> def vortex(x,y):  # Vortex function
>>>     z = x + 1j*y
>>>     angle = np.angle(z)
>>>     return np.exp(1j * angle)
>>> state = ts.GaussianState(grid, 1.)  # Create the system's state
>>> state.imprint(vortex)  # Imprint a vortex on the state

get_mean_px()

Return the expected value of the $$P_x$$ operator.

Returns

• mean_px : float
Expected value of the $$P_x$$ operator.
get_mean_pxpx()

Return the expected value of the $$P_x^2$$ operator.

Returns

• mean_pxpx : float
Expected value of the $$P_x^2$$ operator.
get_mean_py()

Return the expected value of the $$P_y$$ operator.

Returns

• mean_py : float
Expected value of the $$P_y$$ operator.
get_mean_pypy()

Return the expected value of the $$P_y^2$$ operator.

Returns

• mean_pypy : float
Expected value of the $$P_y^2$$ operator.
get_mean_x()

Return the expected value of the $$X$$ operator.

Returns

• mean_x : float
Expected value of the $$X$$ operator.
get_mean_xx()

Return the expected value of the $$X^2$$ operator.

Returns

• mean_xx : float
Expected value of the $$X^2$$ operator.
get_mean_y()

Return the expected value of the $$Y$$ operator.

Returns

• mean_y : float
Expected value of the $$Y$$ operator.
get_mean_yy()

Return the expected value of the $$Y^2$$ operator.

Returns

• mean_yy : float
Expected value of the $$Y^2$$ operator.
get_particle_density()

Return a matrix storing the squared norm of the wave function.

Returns

• particle_density : numpy matrix
Particle density of the state $$|\psi(x,y)|^2$$
get_phase()

Return a matrix of the wave function’s phase.

Returns

• get_phase : numpy matrix
Matrix of the wave function’s phase $$\phi(x,y) = \log(\psi(x,y))$$
get_squared_norm()

Return the squared norm of the quantum state.

Returns

• squared_norm : float
Squared norm of the quantum state.
loadtxt(file_name)

Load the wave function from a file.

Parameters

• file_name : string
Name of the file to be written.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D()  # Define the simulation's geometry
>>> state = ts.GaussianState(grid, 1.)  # Create the system's state
>>> state.write_to_file('wave_function.txt')  # Write to a file the wave function
>>> state2 = ts.State(grid)  # Create a quantum state
>>> state2.loadtxt('wave_function.txt')  # Load the wave function

write_particle_density(file_name)

Write to a file the particle density matrix of the wave function.

Parameters

• file_name : string
Name of the file.
write_phase(file_name)

Write to a file the wave function.

Parameters

• file_name : string
Name of the file to be written.
write_to_file(file_name)

Write to a file the wave function.

Parameters

• file_name : string
Name of the file to be written.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D()  # Define the simulation's geometry
>>> state = ts.GaussianState(grid, 1.)  # Create the system's state
>>> state.write_to_file('wave_function.txt')  # Write to a file the wave function
>>> state2 = ts.State(grid)  # Create a quantum state
>>> state2.loadtxt('wave_function.txt')  # Load the wave function


## Potential Classes¶

class trottersuzuki.Potential

This class defines the external potential that is used for Hamiltonian class.

Constructors

Potential(grid)

Construct the external potential.

Parameters

• grid : Lattice object
Define the geometry of the simulation.

Returns

• Potential : Potential object
Create external potential.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D()  # Define the simulation's geometry
>>> # Define a constant external potential
>>> def external_potential_function(x,y):
>>>     return 1.
>>> potential = ts.Potential(grid)  # Create the external potential
>>> potential.init_potential(external_potential_function)  # Initialize the external potential


Members

init_potential(potential_function)

Initialize the external potential.

Parameters

• potential_function : python function
Define the external potential function.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D()  # Define the simulation's geometry
>>> # Define a constant external potential
>>> def external_potential_function(x,y):
>>>     return 1.
>>> potential = ts.Potential(grid)  # Create the external potential
>>> potential.init_potential(external_potential_function)  # Initialize the external potential

get_value(x, y)

Get the value at the lattice’s coordinate (x,y).

Returns

• value : float
Value of the external potential.
class trottersuzuki.HarmonicPotential

This class defines the external potential, that is used for Hamiltonian class.

This class is a child of Potential class.

Constructors

HarmonicPotential(grid, omegax, omegay, mass=1., mean_x=0., mean_y=0.)

Construct the harmonic external potential.

Parameters

• grid : Lattice2D object
Define the geometry of the simulation.
• omegax : float
Frequency along x-axis.
• omegay : float
Frequency along y-axis.
• mass : float,optional (default: 1.)
Mass of the particle.
• mean_x : float,optional (default: 0.)
Minimum of the potential along x axis.
• mean_y : float,optional (default: 0.)
Minimum of the potential along y axis.

Returns

• HarmonicPotential : Potential object
Harmonic external potential.

Notes

External potential function:n

$V(x,y) = 1/2 m (\omega_x^2 x^2 + \omega_y^2 y^2)$

being $$m$$ the particle mass, $$\omega_x$$ and $$\omega_y$$ the potential frequencies.

Example

>>> import trottersuzuki as ts  # Import the module
>>> grid = ts.Lattice2D()  # Define the simulation's geometry
>>> potential = ts.HarmonicPotential(grid, 2., 1.)  # Create an harmonic external potential


Members

get_value(x, y)

Get the value at the lattice’s coordinate (x,y).

Returns

• value : float
Value of the external potential.

## Hamiltonian Classes¶

class trottersuzuki.Hamiltonian

This class defines the Hamiltonian of a single component system.

Constructors

Hamiltonian(grid, potential=0, mass=1., coupling=0., LeeHuangYang_coupling=0., angular_velocity=0., rot_coord_x=0, rot_coord_y=0)

Construct the Hamiltonian of a single component system.

Parameters

• grid : Lattice object
Define the geometry of the simulation.
• potential : Potential object
Define the external potential of the Hamiltonian ($$V$$).
• mass : float,optional (default: 1.)
Mass of the particle ($$m$$).
• coupling : float,optional (default: 0.)
Coupling constant of intra-particle interaction ($$g$$).
• LeeHuangYang_coupling : float,optional (default: 0.)
Coupling constant of the Lee-Huang-Yang term ($$g_{LHY}$$).
• angular_velocity : float,optional (default: 0.)
The frame of reference rotates with this angular velocity ($$\omega$$).
• rot_coord_x : float,optional (default: 0.)
X coordinate of the center of rotation.
• rot_coord_y : float,optional (default: 0.)
Y coordinate of the center of rotation.

Returns

• Hamiltonian : Hamiltonian object

Hamiltonian of the system to be simulated:

$H(x,y) = \frac{1}{2m}(P_x^2 + P_y^2) + V(x,y) + g |\psi(x,y)|^2 + g_{LHY} |\psi(x,y)|^3 + \omega L_z$

being $$m$$ the particle mass, $$V(x,y)$$ the external potential, $$g$$ the coupling constant of intra-particle interaction, $$g_{LHY}$$ the coupling constant of the Lee-Huang-Yang term, $$\omega$$ the angular velocity of the frame of reference and $$L_z$$ the angular momentum operator along the z-axis.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D()  # Define the simulation's geometry
>>> potential = ts.HarmonicPotential(grid, 1., 1.)  # Create an harmonic external potential
>>> hamiltonian = ts.Hamiltonian(grid, potential)  # Create the Hamiltonian of an harmonic oscillator

class trottersuzuki.Hamiltonian2Component

This class defines the Hamiltonian of a two component system.

Constructors

Hamiltonian2Component(grid, potential_1=0, potential_2=0, mass_1=1., mass_2=1., coupling_1=0., coupling_12=0., coupling_2=0., omega_r=0, omega_i=0, angular_velocity=0., rot_coord_x=0, rot_coord_y=0)

Construct the Hamiltonian of a two component system.

Parameters

• grid : Lattice object
Define the geometry of the simulation.
• potential_1 : Potential object
External potential to which the first state is subjected ($$V_1$$).
• potential_2 : Potential object
External potential to which the second state is subjected ($$V_2$$).
• mass_1 : float,optional (default: 1.)
Mass of the first-component’s particles ($$m_1$$).
• mass_2 : float,optional (default: 1.)
Mass of the second-component’s particles ($$m_2$$).
• coupling_1 : float,optional (default: 0.)
Coupling constant of intra-particle interaction for the first component ($$g_1$$).
• coupling_12 : float,optional (default: 0.)
Coupling constant of inter-particle interaction between the two components ($$g_{12}$$).
• coupling_2 : float,optional (default: 0.)
Coupling constant of intra-particle interaction for the second component ($$g_2$$).
• omega_r : float,optional (default: 0.)
Real part of the Rabi coupling ($$\mathrm{Re}(\Omega)$$).
• omega_i : float,optional (default: 0.)
Imaginary part of the Rabi coupling ($$\mathrm{Im}(\Omega)$$).
• angular_velocity : float,optional (default: 0.)
The frame of reference rotates with this angular velocity ($$\omega$$).
• rot_coord_x : float,optional (default: 0.)
X coordinate of the center of rotation.
• rot_coord_y : float,optional (default: 0.)
Y coordinate of the center of rotation.

Returns

• Hamiltonian2Component : Hamiltonian2Component object

Hamiltonian of the two-component system to be simulated.

$\begin{split}H = \begin{bmatrix} H_1 & \frac{\Omega}{2} \\ \frac{\Omega}{2} & H_2 \end{bmatrix}\end{split}$

being

\begin{align}\begin{aligned}H_1 = \frac{1}{2m_1}(P_x^2 + P_y^2) + V_1(x,y) + g_1|\psi_1(x,y)|^2 + g_{12}|\psi_2(x,y)|^2 + \omega L_z\\H_2 = \frac{1}{2m_2}(P_x^2 + P_y^2) + V_2(x,y) + g_2|\psi_2(x,y)|^2 + g_{12}|\psi_1(x,y)|^2 + \omega L_z\end{aligned}\end{align}

and, for the i-th component, $$m_i$$ the particle mass, $$V_i(x,y)$$ the external potential, $$g_i$$ the coupling constant of intra-particle interaction; $$g_{12}$$ the coupling constant of inter-particle interaction $$\omega$$ the angular velocity of the frame of reference, $$L_z$$ the angular momentum operator along the z-axis and $$\Omega$$ the Rabi coupling.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D()  # Define the simulation's geometry
>>> potential = ts.HarmonicPotential(grid, 1., 1.)  # Create an harmonic external potential
>>> hamiltonian = ts.Hamiltonian2Component(grid, potential, potential)  # Create the Hamiltonian of an harmonic oscillator for a two-component system


## Solver Class¶

class trottersuzuki.Solver

This class defines the evolution tasks.

Constructors

Solver(grid, state1, hamiltonian, delta_t, Potential=None,
State2=None, Potential2=None, kernel_type="cpu")

Construct the Solver object. Potential is only to be passed if it is time-evolving.

Parameters

• grid : Lattice object
Define the geometry of the simulation.
• state1 : State object
First component’s state of the system.
• hamiltonian : Hamiltonian object
Hamiltonian of the two-component system.
• delta_t : float
A single evolution iteration, evolves the state for this time.
• Potential: Potential object, optional.
Time-evolving potential in component one.
• state2 : State object, optional.
Second component’s state of the system.
• Potential2: Potential object, optional.
Time-evolving potential in component two.
• kernel_type : str, optional (default: ‘cpu’)
Which kernel to use (either cpu or gpu).

Returns

• Solver : Solver object
Solver object for the simulation of a two-component system.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D()  # Define the simulation's geometry
>>> state_1 = ts.GaussianState(grid, 1.)  # Create first-component system's state
>>> state_2 = ts.GaussianState(grid, 1.)  # Create second-component system's state
>>> potential = ts.HarmonicPotential(grid, 1., 1.)  # Create harmonic potential
>>> hamiltonian = ts.Hamiltonian2Component(grid, potential, potential)  # Create an harmonic oscillator Hamiltonian
>>> solver = ts.Solver(grid, state_1, hamiltonian, 1e-2, State2=state_2)  # Create the solver


Members

evolve(iterations, imag_time=False)

Evolve the state of the system.

Parameters

• iterations : integer
Number of iterations.
• imag_time : bool,optional (default: False)
Whether to perform imaginary time evolution (True) or real time evolution (False).

Notes

The norm of the state is preserved both in real-time and in imaginary-time evolution.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D()  # Define the simulation's geometry
>>> state = ts.GaussianState(grid, 1.)  # Create the system's state
>>> potential = ts.HarmonicPotential(grid, 1., 1.)  # Create harmonic potential
>>> hamiltonian = ts.Hamiltonian(grid, potential)  # Create a harmonic oscillator Hamiltonian
>>> solver = ts.Solver(grid, state, hamiltonian, 1e-2)  # Create the solver
>>> solver.evolve(1000)  # perform 1000 iteration in real time evolution

get_inter_species_energy()

Get the inter-particles interaction energy of the system.

Returns

• get_inter_species_energy : float
Inter-particles interaction energy of the system.
get_intra_species_energy(which=3)

Get the intra-particles interaction energy of the system.

Parameters

• which : integer,optional (default: 3)
Which intra-particles interaction energy to return: total system (default, which=3), first component (which=1), second component (which=2).
get_kinetic_energy(which=3)

Get the kinetic energy of the system.

Parameters

• which : integer,optional (default: 3)
Which kinetic energy to return: total system (default, which=3), first component (which=1), second component (which=2).
get_potential_energy(which=3)

Get the potential energy of the system.

Parameters

• which : integer,optional (default: 3)
Which potential energy to return: total system (default, which=3), first component (which=1), second component (which=2).
get_rabi_energy()

Get the Rabi energy of the system.

Returns

• get_rabi_energy : float
Rabi energy of the system.
get_rotational_energy(which=3)

Get the rotational energy of the system.

Parameters

• which : integer,optional (default: 3)
Which rotational energy to return: total system (default, which=3), first component (which=1), second component (which=2).
get_squared_norm(which=3)

Get the squared norm of the state (default: total wave-function).

Parameters

• which : integer,optional (default: 3)
Which squared state norm to return: total system (default, which=3), first component (which=1), second component (which=2).
get_LeeHuangYang_energy()

Get the Lee-Huang-Yang energy.

Returns

• LeeHuangYang_energy : float
Lee-Huang-Yang energy of the system.
get_total_energy()

Get the total energy of the system.

Returns

• get_total_energy : float
Total energy of the system.

Example

>>> import trottersuzuki as ts  # import the module
>>> grid = ts.Lattice2D()  # Define the simulation's geometry
>>> state = ts.GaussianState(grid, 1.)  # Create the system's state
>>> potential = ts.HarmonicPotential(grid, 1., 1.)  # Create harmonic potential
>>> hamiltonian = ts.Hamiltonian(grid, potential)  # Create a harmonic oscillator Hamiltonian
>>> solver = ts.Solver(grid, state, hamiltonian, 1e-2)  # Create the solver
>>> solver.get_total_energy()  # Get the total energy
1

Solver::update_parameters()

Notify the solver if any parameter changed in the Hamiltonian

## Tools¶

map_lattice_to_coordinate_space(grid, x, y=None)

Map the lattice coordinate to the coordinate space depending on the coordinate system.

Parameters

• grid : Lattice object
Defines the topology.
• x : int.
Grid point.
• y : int, optional.
Grid point, 2D case.

Returns

• x_p, y_p : tuple.
Coordinate of the physical space.
get_vortex_position(grid, state, approx_cloud_radius=0.)

Get the position of a single vortex in the quantum state.

Parameters

• grid : Lattice object
Define the geometry of the simulation.
• state : State object
System’s state.
• approx_cloud_radius : float, optional
Radius of the circle, centered at the Lattice2D’s origin, where the vortex core is expected to be. Need for a better accuracy.

Returns

• coords : numpy array
Coordinates of the vortex core’s position (coords[0]: x coordinate; coords[1]: y coordinate).

Notes

Only one vortex must be present in the state.

Example

>>> import trottersuzuki as ts  # import the module
>>> import numpy as np
>>> grid = ts.Lattice2D()  # Define the simulation's geometry
>>> state = ts.GaussianState(grid, 1.)  # Create a state with gaussian wave function
>>> def vortex_a(x, y):  # Define the vortex to be imprinted
>>>     z = x + 1j*y
>>>     angle = np.angle(z)
>>>     return np.exp(1j * angle)
>>> state.imprint(vortex)  # Imprint the vortex on the state
>>> ts.get_vortex_position(grid, state)
array([  8.88178420e-16,   8.88178420e-16])
`