tpogden / maxwellbloch

A Python package for solving the coupled Maxwell-Bloch equations describing the nonlinear propagation of near-resonant light through thermal quantised systems such as atomic vapours.

MaxwellBloch

MaxwellBloch is a Python package for solving the coupled Maxwell-Bloch equations describing the nonlinear propagation of near-resonant light through thermal quantised systems such as atomic vapours.

Above is an example solution for the propagation of a 4π pulse through a dense atomic vapour. The pulse immediately breaks up on entering the medium and the resultant pulses form two optical solitons each with a pulse area of 2π.

Documentation

Docs for the project are at maxwellbloch.readthedocs.io.

Install

I recommend using Conda environments.

You can create and activate an environment named mb with all the required dependencies for MaxwellBloch with

conda create --name mb -c conda-forge python=3 numpy=1 scipy=1 qutip=4
conda activate mb

The MaxwellBloch package can then be installed from PyPI using

pip install maxwellbloch

More detailed installation instructions can be found in the docs along with many example problems.

Attribution

If you use MaxwellBloch for research, please use the following citation:

@misc{ogden2020maxwellbloch,
  author = {Ogden, Thomas P.},
  title = {{MaxwellBloch}: a Python package for solving the coupled 
    Maxwell-Bloch equations describing the nonlinear propagation of 
    near-resonant light through thermal quantised systems such as atomic 
    vapors.},
  year = {2020},
  publisher = {GitHub},
  journal = {GitHub repository},
  howpublished = {\url{https://github.com/tpogden/maxwellbloch}}
}

Changelog

See CHANGELOG.md.

License

MIT License. See LICENSE.txt.

maxwellbloch's Issues

Give atom a label in json

e.g. "two-level-sech-pulse", "lambda-eit", "vee", "ladder", "y", "diamond".

Add OB Solver class

Write MBSolve.z_step_fields_ab() and put in MBSolve.mb_solve_ab()

• Instead of overwriting mb_solve() with Euler step, rename to mb_solve_euler() and introduce mb_solve_ab(). mb_solve will then take a step argument (default step='ab').

Fix bug: Rabi frequencies wrong for multiple coupled levels

This looks to me to be a serious bug:

    ...
        for f in self.fields:
            
            H_Omega = qu.Qobj(np.zeros([self.num_states, self.num_states]))
            
            for c in f.coupled_levels:
                H_Omega += self.sigma(c[0],c[1]) + self.sigma(c[1],c[0])
                H_Omega *= pi*f.rabi_freq # 2π*rabi_freq/2
    ...

The H_Omega *= pi*f.rabi_freq # 2π*rabi_freq/2 line should be happening in the fields loop, not the coupled_levels loop. This will result in the value being multiplied too many times in the case of multiple coupled levels -- we've probably not hit this so far

https://github.com/tommyogden/maxwellbloch/blob/master/maxwellbloch/ob_atom.py#L140

Make solve_over_thermal_detunings return np array

solve_over_thermal_detunings currently returns a list of qutip result objects. But I never use these for anything, I just need the arrays. Then I can use vector operations rather than looping.

Add save and load functions to MBSolve

• We need to be able to save MBSolve.mbsolve() output to a .qu file, and load it back.

Test the get_Omegas_intp_t_funcs method

Add ability to save results to text as well as qu file format

Add tool for producing videos of fields

Solve two-level problem with OBAtom

Add docstrings to mb_solve, ob_solve, ob_atom, ob_base modules

Bump version

Bump version to 0.2.0.

Add Docstrings to each t_func

Example link in README is a 404

Add OBAtom.build() method

This should build the Atom operators (H_0, H_Delta, H_Omega) or more usefully rebuild in the case that we've changed something post-init in the fields, like supplying a custom t_func.

• build_H_0() should take no arguments, just like build_H_Delta() and build_H_Omega(). So should build_c_ops().

Add MBSolve.fields_area() method

Add ability to shift to a fixed frame of reference

The problem is solved in the frame of reference moving at the speed of light. To convert into the fixed (lab) frame of reference, we need to skew the field results along the time axis, as well providing a fixed frame tlist.

This requires two methods on MBSolve:

• tlist_fixed_frame(speed_of_light)
• Omegas_fixed_frame(speed_of_light)

Allow running from the command line

We should be able to run e.g.

python mb_solve.py my-input-file.json

or

python ob_solve.py my-input-file.json

to solve a problem.

Add requirements file

Add Ramp Off, On time function

Write tests for Field.build_rabi_freq_t_func method

Motivation

Test coverage for this method.

Tasks

The following cases should be covered:

• The t_func argument is None (i.e. no time dependence)
• The t_func argument is a correct string (e.g. 'square_1', 'ramp_onoff_2')
• The t_func argument is an incorrect string (e.g. 'foo_1')

Allow t_funcs to be set without field number

I want the fields to be defined without the field number, i.e. rabi_freq_t_func: gaussian instead of rabi_freq_t_func: gaussian_1.

I could do this in OBAtom.build_fields. Take each dict and append the number there.

Plan ang_mom factors module

Omegas_fixed_frame uses real rather than abs values

• We cannot interpolate complex values so the Omegas_fixed_frame method currently takes the real part. But in most cases we are using the abs values.
• We should name the method Omegas_abs_fixed_frame and possibly also include a Omegas_real_fixed_frame, Omegas_angle_fixed_frame in case we want them.
• Can't it also use vectorised values ofthe new arrays rather than loop?

Unnest the mbsolve loop

Problem

Moving through the z steps is currently done with nested loops, with the outer loop representing those steps in which we want to save the result. We have both z_step and z_step_inner.

I.e. if we need 200 steps for numerical stability, but we only want to record the result at 50 points, we would set z_step: 50 and z_step_inner: 4.

Solution

It will be simpler to have a single loop, and just save when we need to. It will introduce additional comparisons in the loop which brings some cost, but this should be negligible. It should also simplify things when we want to bring in different behaviour on the first and second steps.

Complete first working version of MBSolve.mb_solve

• Implement the main loop to move through space steps.

Exception raised in mb_solve() if the decay list is empty

Write example MBSolve JSON definition

Add OBAtom class.

To be built from JSON, derives from OBBase.

Design MB Solve

Remove MBSolve.insert_first_inner_z_step

• If z_steps_inner == 1 then we end up with z_list[1] == z_list[2].
• This means that z_list is not strictly increasing. It is reasonable to expect that both z_list and t_list are strictly increasing lists.
• It is now my opinion that the small first Euler step is more trouble than it is worth. While it prevents large error being introduced in the first step, in nearly every case we start at a z_0 before any atoms are present. This means that for either an Euler or AB step, nothing happens to the field anyway.
• I've already found one problem I think is due to z_list not strictly increasing -- the 2D interpolation to shift back to a fixed frame is unstable.

Write an OBSolve.set_field_rabi_freq_t_func() method

This will take a field_idx as an argument, and allow us to set a custom t_func for a field.

This should call the OBAtom.build() method afterwards, so this issue is dependent on #64.

Make average_states_over_thermal_detunings use np arrays

Test to/from JSON for ob_solve

Fix bug: Save function calls OBSolve save on each step

The save method added to MBSolve in #28 caused the OBSolve save method to be called each step. This is not what we want.

Move the OBSolve save functionality back to OBBase and stop the MBSolve solver from calling it each z-step.

Write OBAtom.get_coherence function to sum the coupled level coherences

• This is used in mb_solve algorithm.

Add Field.build_rabi_freq_t_func docstring

Needs to make clear that the argument is a string representing a function in t_funcs, not a function.

ramp_onoff can use ramp_on, ramp_off

Test the interpolation

Add CI build

Move get_field_sum_coherence from OBAtom to OBSolve (as is dependent on time)

Tests on ob_atom are currently skipped as OBAtom.get_field_sum_coherence() throws if called before ob_solve() is run

Update README with links to examples and tutorial

• Also update CHANGELOG

Use QuTiP's ui.progressbar to remove dependency

Test to/from JSON for mb_solve

Add FFT to get Omegas_zt in the frequency domain

• Use this to check absorption and dispersion profiles are as expected for weak pulse.

Add OBScan class

Fix PEP8 problems

Ongoing issue to fix PEP problems.

Fix Field to_from_json_str test

The test doesn't work because it expects the t_func to be passed to the json_dict as a string, e.g. 'square_1', but it's actually passing the function, square_1.

Refactor spectral analysis methods into new class

There's too much in MBSolve now, we should have a Spectral class (or just module?) that takes an MBSolve and provides spectral analysis methods.

Fix time functions

There's a few problems with the time functions in t_funcs.py that need fixing.

• The gaussian_fwhm_[1] functions should just be called gaussian_[1] as this is how we're defining Gaussians.
• The ramp_on_[1] functions are to use fwhm_[1] and on_[1] insteady of width_[1] and centre_[1] for clarity.
• Same for ramp_off_[1] and ramp_onoff_[1].
• The ramp_onoff_[1] functions are defined incorrectly and will not work as expected for amplitudes other than 1.0. Fix this.