Detailed API

Submodules

LASED.constants module

Contains definitions of useful fundamental constants. Author: Manish Patel Last Edited: 25/08/2021

LASED.decay_constant module

This is a file to define functions to calculate the generalised decay constants Author: Manish Patel Date created: 27/07/2021

LASED.decay_constant.generalisedDecayConstant(ep, epp, g, G, Q_decay)

Calculates the branching ratio for the generalised decay constant.

This ratio must be multiplied by 1/tau to get the generalised decay constant in Grad/s. This is then used for evaluating vertical coherences.

Parameters

• ep (State) – Excited State object

• epp (State) – Excited State object

• g (State) – Ground State object

• G (list) – :List of all ground State objects

• tau (float) – Lifetime of state in ns

• Q_decay (list) – List of decay channel polarisations allowed by transition rules, usually [-1, 0, 1]

Returns

Value of the branching ratio for the generalised decay constant gamma_{ep, epp, g}.

LASED.density_matrix module

Density matrix operations Author: Manish Patel Date Created: 11/06/2021

LASED.density_matrix.JNumber(state_list)

Calculate the angular momentum from the number of sub-states in the list.

Parameters

state_list (list) – List of sub-states of a single angular momentum state.

Returns

int: The total angular momentum of the state.

LASED.density_matrix.appendDensityMatrixToFlatCoupledMatrix(flatrho, density_rho, sub_states, n)

Adds density matrix elements to a flat, coupled matrix.

Parameters

• flat_rho (list) – array of arrays with one column of all density matrix elements of coupled E and G states

• n (int) – number of states in total laser-coupled system

• sub-states (list) – a list of the excited or ground states

• density_rho (ndarray) – either the excited or ground state density matrix with the convention that the upper left-hand of the matrix is state population for m_J = -J if the state has angular momentum J

LASED.density_matrix.getSingleStateMatrix(flat_rho, n, sub_states)

Obtain an angular momentum state density matrix from the flattened coupled state density rho vector.

Parameters

• flat_rho (list of list) – flattened 2D density matrix of coupled E & G states with the laser.

• n (int) – number of states in total laser-coupled system.

• sub_states (list) – a list of the excited or ground states, E or G respectively.

Returns

A square matrix of size length of sub_states. Elements are ordered from left to right according to the order of sub_states e.g. if state labelled 1 is first then first element would correspond to rho_11 i.e. population of state 1.

Return type

ndarray

LASED.detuning module

Define functions for the detuning of an atomic system

LASED.detuning.angularFreq(wavelength)

Calculates the angular frequency in Grad/s from a given wavelength.

Parameters

wavelength (float) – A wavelength in nm

Returns

The angular frequency in Grad/s

Return type

float

LASED.detuning.delta(e, g)

Detunings between substates.

Parameters:

e (State): State object g (State): State object

Returns

Difference in angular frequency of states (Grad/s).

Return type

float

LASED.detuning.dopplerDelta(e, g, w_q, lambda_q, v_z)

The detuning between excited and ground states.

Accounts for a fixed motion of the atoms. Used between excited and ground states.

Parameters

• e (State) – State object for excited state.

• g (State) – State object for ground state.

• w_q (float) – Angular frequency of exciting laser in rad/s.

• lambda_q (float) – Wavelength of exciting laser in m.

• v_z (float) – Velocity component of atoms in direction of laser in m/s.

Returns

The detuning between ground and excited states including the doppler detuning due to a given atomic velocity.

Return type

float

LASED.generate_sub_states module

Generate Sub States. Generates sub-states of a quantum state

LASED.generate_sub_states.generateSubStates(label_from, w, L, S, J=None, I=None, F=None)

Generates a vector of sub-states given quantum numbers.

Parameters

• label_from (int) – the number assigned to the first state generated - goes from -m_F to +m_F so the number given will be assigned to -m_F

• w (float) – the angular frequency (in Grad/s) given to the states generated

• L (int) – orbital angular momentum

• S (int) – spin quantum number

• J (int) – total angular momentum

• I (int) – nuclear isospin

• F (int) – total angular momentum + isospin

Returns

A list of State objects from -m_F to +m_F with labels beginning at label_from

Return type

list

LASED.half_rabi_freq module

Definition of the half-Rabi frequency and all other functions needed to calculate it

LASED.half_rabi_freq.coupling(e, g, q)

Coupling constants between states via laser radiation

Parameters

• e (State) – the excited state

• g (State) – the ground state

• q (int) – the laser polarisation coupling e and g. This can be -1 for LH circular, +1 for RH circular, or 0 for linear polarisation.

• Returns – float: the coupling constant between an excited and ground state

LASED.half_rabi_freq.gaussianIntensity(P_las, r_sigma, r)

Intensity of Gaussian TEM_00 laser beam profile.

Parameters

• P_las (float) – Power of laser given by power meter in mW

• r_sigma (float) – Radius at 2D standard deviation of a Gaussian in mm

• r (float) – Radius in mm at which the laser intensity is evaluated

Returns

Intensity in mW/mm^2 at radius r from beam axis given a Gaussian intensity profile

Return type

float

LASED.half_rabi_freq.halfRabiFreq(intensity, lifetime, wavelength)

Calculates the half-Rabi frequency in Grad/s.

Parameters

• intensity – intensity of laser in mW/mm^2

• lifetime – lifetime of the excited state to the ground state transition in nanoseconds

• wavelength – wavelength (in metres) corresponding to the resonant transition from the ground to excited state.

Returns

The half-Rabi frequency in Grad/s.

Return type

float

LASED.index module

Definition of the index function

LASED.index.getStateLabelsFromLineNo(line_no, n)

Gets the indeces for labelling rho [i, j] from the line number of an array.

Parameters

• line_no (int) – line number of an array e.g. position of a row in a matrix or column in rho_t

• n – the number of states in the system

Returns

A tuple of the indeces for the matrix position

Return type

tuple

LASED.index.index(i, j, n)

Function to return the index of an element of a 2D density matrix if flattened to a 1D array

Parameters

• i (State) – To get the row number of the element to be selected

• j (State) – To get the column number of the element to be selected

• n (int) – dimension of the square array i.e. number of states in the system

Returns

Index of the element in a 1D array

Return type

int

Example

To get the index of rho_44 in a 4-level system call index(four, four, 4) where “four” is the variable which stores the State object labelled 4.

LASED.laser_atom_system module

The LaserAtomSystem class definition.

class LASED.laser_atom_system.LaserAtomSystem(E, G, tau, Q, laser_wavelength, laser_intensity=None, laser_power=None, tau_f=None, tau_b=None, rabi_scaling=None, rabi_factors=None)

Bases: object

A physical system composed of a laser field acting on an atomic system.

Q_decay

List of ints describing the selection rules of the decay. Selection rules are set to +1, -1, and 0.

Type

list

rho_t

List of flattened 2D arrays over the time interval simulated for. This is initialised as empty as no time evolution has taken place.

Type

list

E

List of State objects which are the excited states of the system.

Type

list

G

List of State objects which are the ground states of the system.

Type

list

tau

Lifetime of transition in nanoseconds between excited and ground state.

Type

float

Q

List of laser polarisations. This can be +1, 0, -1 for right-hand circular, left-hand circular, and linear polarisation. If more than one polarisation is in the list then the system will be excited with a linear combination of the polarisations.

Type

list

laser_wavelength

Wavelength of transition from ground to excited state in metres.

Type

float

laser_intensity

Intensity of the laser in mW/mm^2.

Type

float

laser_power

Power of the laser in mW. This is needed for Gaussian averaging of beam profile.

Type

float

tau_f

Upper state lifetime to states outside of laser coupling in nanoseconds.

Type

float

tau_b

Ground state lifetime to states outside of laser coupling in nanoseconds.

Type

float

rho_0

2D array creating the density matrix at t = 0.

Type

list of list

rabi_scaling

The normalisation of the Rabi frequency. The half-Rabi frequency is divided by this number. Use this if there are more than one polarisations to normalise the population.

Type

float

rabi_factors

Elements of this list are multiplies by the half-Rabi frequency for each polarisation. This can be used to obtain elliptical polarisation.

Type

list

Q_decay = [1, 0, -1]

Rho_0(i, j)

Accessor for an element in rho_0.

Parameters

• i (State) – First state index.

• j (State) – Second state index.

Returns

element of the laser-atom system density matrix at t=0.

Return type

complex

Example

print(Rho_0(one, two))

Rho_t(i, j)

Accessor for an element in rho_t.

Parameters

• i (State) – First state index

• j (State) – Second state index

Returns

Array of an element in laser-atom system for all of the simulation time

Return type

list

Example

print(Rho_t(one, two)) prints element rho_12 if one and two are State objects corresponding to label 1 and 2 respectively.

angularShape_0(state, theta, phi)

Gets the angular shape (radius) of the atomic state given at t = 0.

Parameters

• state (char) – Either “e” or “g” specifying the excited or lower state.

• theta (array_like) – Azimuthal (longitudinal) coordinate in [0, 2*pi].

• phi (array_like) – Polar (colatitudinal) coordinate in [0, pi].

Returns

A list of lists with the radius of the angular shape of the atomic state given at t = 0.

Return type

(2D array)

Example

calcium.angularShape(“g”, theta, phi) for a pre-defined calcium system gives the angular shape of the lower state density matrix.

angularShape_t(state, theta, phi)

Gets the time evolution of the angular shape (radius) of the atomic state given.

Parameters

• state (char) – Either “e” or “g” specifying the excited or lower state.

• theta (array_like) – Azimuthal (longitudinal) coordinate in [0, 2*pi].

• phi (array_like) – Polar (colatitudinal) coordinate in [0, pi].

Returns

List of 2D arrays of the radius of the angular shape of the atomic state for a given time in the evolution of the laser-atom system.

Return type

(List of 2D array)

appendDensityMatrixToRho_0(density_rho, state_type)

Sets the laser-atom system density matrix at t=0 to the matrix given.

Parameters

• density_rho (ndarray) – 2D array of the system density matrix.

• state_type (char) – Defines whether the density matrix is for the ground or excited state. Either an “e” or “g” for excited and ground state density matrices respectively.

Note

Density matrix input must be square and the size of the matrix must match with E or G.

clearRho_0()

Makes all values of rho_0 zero.

property n

Total number of substates.

Returns

Number of substates.

Return type

int

property rho_e0

Upper state density matrix for the initial condition.

Returns

Upper state density matrix composed of all states defined in E.

Return type

ndarray

property rho_et

Upper state density matrix for all of the time evolution.

Returns

A list of upper state density matrices for the time evolution.

Return type

list of ndarray

property rho_g0

Lower state density matrix for the initial condition.

Returns

Lower state density matrix composed of all states defined in G.

Return type

ndarray

property rho_gt

Lower state density matrix for all of the time evolution.

Returns

A list oflower state density matrices for the time evolution.

Return type

list of ndarray

rho_t = []

rotateRho_0(alpha, beta, gamma)

Rotate rho_0 by the Euler angles alpha, beta, and gamma.

Parameters

• alpha (float) – rotation (in radians) around z-axis

• beta (float) – rotation (in radians) about the y’-axis

• gamma (float) – rotation (in radians) about the z’’-axis

rotateRho_t(alpha, beta, gamma)

Rotate rho_0 by the Euler angles alpha, beta, and gamma.

Parameters

• alpha (float) – rotation (in radians) around z-axis

• beta (float) – rotation (in radians) about the y’-axis

• gamma (float) – rotation (in radians) about the z’’-axis

saveToCSV(filename, precision=None)

Saves rho_t as a csv file.

Parameters

• filename (string) – Name of the csv file created.

• precision (int) – Precision of numbers in decimal places.

Returns

Void.

setRho_0(i, j, value)

Sets a value to an element of rho_0.

Parameters

• i (State) – First state index

• j (State) – Second state index

• value (np.complex) – Sets the value of rho_ij to the complex value here

time = []

timeEvolution(time, beam_profile_averaging=None, doppler_averaging=None, print_eq=None, detuning=None, atomic_velocity=None, r_sigma=None, n_beam_averaging=None, doppler_width=None, doppler_detunings=None, pretty_print_eq=None, pretty_print_eq_tex=None, pretty_print_eq_pdf=None, pretty_print_eq_filename=None)

Evolves the laser-atom system over time.

Produces a list of flattened 2D density matrices which correspond to the time array. This is stored in rho_t.

Parameters

• time (list) – Array of the times in the time evolution in nanoseconds e.g. time = [0, 1, 2] to simulate up to 2 ns

• beam_profile_averaging (bool) – Turn on averaging over a Gaussian TEM00 laser beam profile. Must have n_beam_averaging to state the number of averages to take over the beam profile and r_sigma to characterise the standard debviation of the Gaussian beam.

• doppler_averaging (bool) – Turn on averaging over the doppler profile of the atoms. Must have doppler_width and doppler_detunings as well.

• print_eq (bool) – Turn on printing the coupled differential equatiuons numerically.

• atomic_velocity (float) – The velocity component of the atoms in the direction of the laser beam in metres/second. This is used for doppler shifting the energy levels.

• r_sigma (float) – The radial distance to the 2D standard deviation in millimetres of the Gaussian beam profile of the laser.

• n_beam_averaging (int) – The number of times the beam profile will be split to average over. The higher the number, the more accurate the beam profile averaging but it will be slower.

• doppler_width (float) – The doppler width of the beam profile in Grad/s.

• doppler_detunings (list) – List of the doppler detunings creating a doppler profile. This list will be averaged over. Must go from a -ve detuning to a +ve detuning. All detunings are in Grad/s.

• pretty_print_eq (bool) – Turn on printing of the coupled differential equations symbolically using Sympy. Only available using an IPython environment e.g. Jupyter.

• pretty_print_eq_tex (bool) – Produces a .tex file with the equations of motion printed symbolically using Sympy. Must input a filename for the .tex file with the keyword “pretty_print_eq_filename”.

• pretty_print_eq_pdf (bool) – Produces a .pdf file with the equations of motion printed symbolically using Sympy and pdflatex. Must have pdflatex installed on your system. Must input a filename for the .tex file with the keyword “pretty_print_eq_filename”.

• Note – Must have laser_power attribute for Gaussian averaging of the beam and must have laser_intensity attribute when not Gaussian averaging. Also, cannot print equations in doppler or Gaussian averaging.

LASED.matrix_methods module

Defines functions to manipulate matrices.

LASED.matrix_methods.printNonZeroMatrixElements(A)

Prints non-zero matrix elements

Parameters

A (ndarray) – A matrix

LASED.rotation module

Define functions for rotating density matrices in the QED simulation of a laser-atom system. Author: Manish Patel Date created: 12/05/2021

LASED.rotation.createDictionaryOfSubStates(E, G)

Creates a dictionary of sub-states with (F, m) as the key and the State object as the value.

Parameters

• E (list of States) – List of excited sub-states in the laser-atom system.

• G (list of States) – List of ground sub-states in the laser-atom system

Returns

A dictionary with (F, m) as the keys and the corresponding State object as the value

Return type

dictionary

LASED.rotation.rotateElement(rho, i, j, n, sub_state_dict, alpha, beta, gamma)

Rotates an element of a density matrix rho_ij by the euler angles given.

Parameters

• rho (complex) – The density matrix to be rotated.

• i (state) – A sub-state of the laser-atom system.

• j (state) – A sub-state of the laser-atom system.

• sub_state_dict (dict of State) – Dictionary of States with (F,m) tuple as the keys and the corresponding State object as the value.

• n (int) – Total number of sub-states in the system.

• alpha (float) – rotation around z-axis in radians.

• beta (float) – rotation about the y’-axis in radians.

• gamma (float) – rotation about the z’’-axis in radians.

Returns

The rotated density matrix element.

Return type

complex

LASED.rotation.rotateFlatDensityMatrix(flat_rho, n, E, G, alpha, beta, gamma)

Rotate the excited and ground state populations by the Euler angles.

Parameters

• flat_rho (list) – A flattened 2D density matrix

• n (int) – Number of substates which compose the density matrix flat_rho

• E (list of States) – list of excited State objects which compose flat_rho

• G (list of States) – list of ground State objects which compose flat_rho

• alpha (float) – rotation around z-axis in radians.

• beta (float) – rotation about the y’-axis in radians.

• gamma (float) – rotation about the z’’-axis in radians.

Returns

A rotated flattened 2D density matrix

Return type

list of lists

LASED.rotation.small_Wigner_D(J, beta, mp, m)

Calculates the small Wigner D-matrix elements for rotation.

Parameters

• J (int) – total angular momentum quantum number of the state which will be rotated with the resulting D-matrix.

• beta (float) – rotation about the y’-axis in radians.

• mp (int) – row number of element in the Wigner D-matrix

• m (int) – column number oif element in the Wigner D-matrix

Returns

The small Wigner D-matrix elements

Return type

float

LASED.rotation.wigner_D(J, mu, m, alpha, beta, gamma)

Calculates the Wigner D-matrix for rotation by Eueler angles (alpha, beta, gamma).

Parameters

• J (int) – total angular momentum quantum number of the state which will be rotated with the

• D-matrix. (resulting) –

• alpha (float) – rotation around z-axis in radians.

• beta (float) – rotation about the y’-axis in radians.

• gamma (float) – rotation about the z’’-axis in radians.

Returns

A square matrix of size 2J+1.

Return type

ndarray

LASED.save_to_csv module

This is a file to define the function to save rho_t as a csv file.

LASED.save_to_csv.saveRhotAsCSV(n, E, G, time, rho_t, filename, precision=None)

Saves rho_t to a csv file.

Creates a csv file with filename and saves each element’s time evolution as a column.

Parameters

• n (int) – Number of substates in the system.

• E (list of States) – List of State objects in excited state of system.

• G (list of States) – List of State objects in ground state of system.

• rho_t (list of lists) – List of flattened 2D density matrices representing time evolution of density matrix.

• filename (string) – Name of the csv file created.

• precision (int) – Precision of numbers in decimal places.

Returns

Void

LASED.save_to_csv.stateLabel(s, state_type)

Returns the short-hand label of the state.

Parameters

• s (State) – a State object.

• state_type (string) – either ‘e’ or ‘g’ for excited state or ground state. The ground state is primed.

Returns

“J=k;m_J=l” if k and l are J and m quantum numbers. If the state has isospin then it is “F=k;m_F=l”

Return type

string

LASED.save_to_csv.writeCSV(filename, headers, data, precision=None)

Creates a csv file using pandas dataframe.

Parameters

• headers – Array of strings used as column headers.

• data – Array of arrays of data used for the columns, must be same size as headers

• filename – String of the name of the csv file output

• precision (int) – Precision of numbers in decimal places.

Returns

Void.

LASED.state module

Class definition for an atomic state

class LASED.state.State(label, w, m, L, S, J=None, I=None, F=None)

Bases: object

An atomic state.

label

Number labelling of state e.g. state |2> would have label 2.

Type

int

w

Angular frequency corresponding to energy of state in Grad/s.

Type

float

L

Orbital angular momentum quantum number.

Type

int

S

Spin quantum number.

Type

int

m

Degeneracy of the total angular momentum.

Type

int

J

Resultant of L coupling to S.

Type

int

I

Nuclear spin quantum number.

Type

int

F

Total angular momentum.

Type

int

LASED.symbolic_print module

LASED.symbolic_print.appendEqToTexFile(file, input_str)

Appends an equation to a .tex file given.

Parameters

• file (file) – file object to write to

• input_str (string) – The string (equation) to be written to the .tex file

LASED.symbolic_print.callPdfLatex(filename)

Calls pdflatex on the system to convert the .tex file to a .pdf file. Must have pdflatex installed.

Parameters

filename (string) – Name of the .tex file to be converted.

LASED.symbolic_print.closeTexFile(file)

Closes a .tex file which has been written to

Parameters

file (file) – file object to be closed

LASED.symbolic_print.createTexFile(filename)

Creates a .tex file with the filename given and returns a file

Parameters

filename (string) – Name of the .tex file created.

Returns

.tex file with filename

Return type

file

LASED.symbolic_print.symbolicPrintRhoee(n, E, G, Q, Q_decay, tau_f, rabi_scaling, rabi_factors, pretty_print_eq=None, pretty_print_eq_file=None)

Prints the density matrix elements rho_ee’’ for the motion of the laser-atom system using Sympy.

LASED.symbolic_print.symbolicPrintRhoeg(n, E, G, Q, Q_decay, tau_f, tau_b, detuning, laser_wavelength, atomic_velocity, rabi_scaling, rabi_factors, pretty_print_eq=None, pretty_print_eq_file=None)

Prints the density matrix elements rho_eg for the motion of the laser-atom system using Sympy.

LASED.symbolic_print.symbolicPrintRhoge(n, E, G, Q, Q_decay, tau_f, tau_b, detuning, laser_wavelength, atomic_velocity, rabi_scaling, rabi_factors, pretty_print_eq=None, pretty_print_eq_file=None)

Prints the density matrix elements rho_ge for the motion of the laser-atom system using Sympy.

LASED.symbolic_print.symbolicPrintRhogg(n, E, G, Q, Q_decay, tau_b, rabi_scaling, rabi_factors, pretty_print_eq=None, pretty_print_eq_file=None)

Prints the density matrix elements rho_gg’’ for the motion of the laser-atom system using Sympy.

LASED.symbolic_print.symbolicPrintSystem(n, E, G, Q, Q_decay, tau_f, tau_b, detuning, laser_wavelength, atomic_velocity, rabi_scaling, rabi_factors, pretty_print_eq=None, pretty_print_eq_tex=None, pretty_print_eq_pdf=None, pretty_print_eq_filename=None)

Prints the equations of motion of the laser-atom system in full using Sympy.

LASED.time_evolution module

This file contains the function to calculate the time evolution of the density matrix for an atomic system interacting with a laser.

LASED.time_evolution.timeEvolution(n, E, G, Q, Q_decay, tau, laser_intensity, laser_wavelength, time, rho0, rho_output, tau_f=None, tau_b=None, detuning=None, rabi_scaling=None, rabi_factors=None, print_eq=None, atomic_velocity=None, pretty_print_eq=None, pretty_print_eq_tex=None, pretty_print_eq_pdf=None, pretty_print_eq_filename=None)

Calculates the time evolution of a laser-atom system.

Uses a flattened density matrix rho0 and calculates the time evolution over the time specified. The density matrix at each time step is stored in rho_output.

LASED.time_evolution.timeEvolutionDopplerAveraging(n, E, G, Q, Q_decay, tau, laser_intensity, laser_wavelength, doppler_width, doppler_detunings, time, rho0, rho_output, tau_f=None, tau_b=None, detuning=None, rabi_scaling=None, rabi_factors=None, print_eq=None, atomic_velocity=None, pretty_print_eq=None, pretty_print_eq_tex=None, pretty_print_eq_pdf=None, pretty_print_eq_filename=None)

Calculates the time evolution of a laser-atom system with a Gaussian doppler profile for the atoms.

Uses a flattened density matrix rho0 and calculates the time evolution over the time specified. The density matrix at each time step is stored in rho_output.

LASED.time_evolution.timeEvolutionGaussianAndDopplerAveraging(n, E, G, Q, Q_decay, tau, laser_power, r_sigma, n_intensity, laser_wavelength, doppler_width, doppler_detunings, time, rho0, rho_output, tau_f=None, tau_b=None, detuning=None, rabi_scaling=None, rabi_factors=None, print_eq=None, atomic_velocity=None, pretty_print_eq=None, pretty_print_eq_tex=None, pretty_print_eq_pdf=None, pretty_print_eq_filename=None)

Calculates the time evolution of a laser-atom system with a Gaussian doppler profile for the atoms and a Gaussian laser beam profile.

Uses a flattened density matrix rho0 and calculates the time evolution over the time specified. The density matrix at each time step is stored in rho_output.

LASED.time_evolution.timeEvolutionGaussianAveraging(n, E, G, Q, Q_decay, tau, laser_power, r_sigma, n_intensity, laser_wavelength, time, rho0, rho_output, tau_f=None, tau_b=None, detuning=None, rabi_scaling=None, rabi_factors=None, print_eq=None, atomic_velocity=None, pretty_print_eq=None, pretty_print_eq_tex=None, pretty_print_eq_pdf=None, pretty_print_eq_filename=None)

Calculates the time evolution of a laser-atom system with a Gaussian laser beam profile.

Uses a flattened density matrix rho0 and calculates the time evolution over the time specified. The density matrix at each time step is stored in rho_output.

LASED.time_evolution_matrix module

This is a file to define a function to populate the time evolution matrix for a laser-atom system Author: Manish Patel Date created: 12/05/2021

LASED.time_evolution_matrix.rho_eepp(A, n, E, G, Q, Q_decay, tau, rabi, rabi_factors, tau_f=None, numeric_print=None)

Function to populate the matrix A with coefficients for populations and atomic coherences of the excited states.

LASED.time_evolution_matrix.rho_eg(A, n, E, G, Q, Q_decay, tau, rabi, rabi_factors, laser_wavelength, atomic_velocity, tau_f=None, tau_b=None, detuning=None, numeric_print=None)

Function to populate the matrix A with coefficients for optical coherences between excited and ground states.

LASED.time_evolution_matrix.rho_ge(A, n, E, G, Q, Q_decay, tau, rabi, rabi_factors, laser_wavelength, atomic_velocity, tau_f=None, tau_b=None, detuning=None, numeric_print=None)

Function to populate the matrix A with coefficients for optical coherences between ground and excited states.

LASED.time_evolution_matrix.rho_ggpp(A, n, E, G, Q, Q_decay, tau, rabi, rabi_factors, tau_b=None, numeric_print=None)

Function to populate the matrix A with coefficients for populations and atomic coherences of the ground states.

LASED.time_evolution_matrix.timeEvolutionMatrix(n, E, G, Q, Q_decay, tau, laser_wavelength, laser_intensity, tau_f=None, tau_b=None, detuning=None, numeric_print=None, rabi_scaling=None, rabi_factors=None, atomic_velocity=None, pretty_print_eq=None, pretty_print_eq_tex=None, pretty_print_eq_pdf=None, pretty_print_eq_filename=None)

Function to create and populate the coupled differential equation matrix A for the laser-atom system.

Returns

Matrix which contains all thera coefficients for the set of coupled differential equations describing a laser-atom system.

Return type

ndarray

Module contents