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])