OneDim-QM-NI

One Dimensional Quantum Mechanics - Numerical Implementation.

This is a tiny modern Fortran library for illustration and teaching purposes. Its aim is to help people study Fortran together with one dimensional quantum systems.

API

The following derived types are defined in the module OneDim_QM_NI: fortran type, public :: steady_state_system type, extends(steady_state_system), public :: time_dependent_system

The library works with double precision numbers. fortran integer, parameter, public :: dp = kind(1.0d0)

type(steady_state_system) :: a

Procedure | Description | Parameters --- | --- | --- Constructor subroutine.
Usage:
call a%init(name, type, mass, start, finish, steps, args, potential[, silent, boundary_cond_s, boundary_cond_f, boundary_param_s, boundary_param_f]) | Initializes an steady state system and calculates its eigenvalues, eigenvectors and position operator. | character(len=*), intent(in) :: name: name of the system.
character(len=*), intent(in) :: type: either electronic or atomic. If electronic, assumes energies in eV, lengths in $\text{\r{A}}$-s, masses in units of the electron mass $me$ and time scales in fs-s. If atomic, assumes energies in peV, lengths in $\mu$m-s, masses in units of the atomic mass unit AMU and time scales in ms-s.
real(dp), intent(in) :: mass: mass of the particle in electronic or atomic units.
real(dp), intent(in) :: start, finish: length of the 1-dimensional space in electronic or atomic units.
integer, intent(in) :: steps: number of discretization steps of the interval and number of quantum levels.
real(dp), intent(in) :: args(:): Arguments passed to the potential function.
procedure(frml) :: potential: implementation of the potential function in electronic or atomic units. Must comply with interface frml.
logical, optional, intent(in) :: silent: if .true., the program will not write to terminal.
`character(len=*), optional, intent(in) ::boundaryconds, boundarycondf: boundary condition specifier. Options areFree,Dirichlet,Neumann,RobinandPeriodic. If onlyboundarycondsis specified, the boundary conditions are fixed at both ends. Ifboundarycondsis not specified, assumesFreeboundary conditions at both ends.<br />real(dp), optional, intent(in) :: boundaryparams: must only be specified ifboundaryconds = "Robin"`. Is a real nonzero constant $\alpha$ such that $\Psin(x1) = \alpha \Psin'(x1)$.
`real(dp), optional, intent(in) :: boundaryparamf: must only be specified ifboundarycondf = "Robin"`. Is a real nonzero constant $\alpha$ such that $\Psin(xN) = -\alpha \Psin'(x_N)$.

Component | Description --- | --- a%Hx(N, N) | Hamiltonian in the position basis. N is the number of states and discretization points. a%Hh(N, N) | Hamiltonian in the Hamiltonian basis. a%eig(N) | Energy eigenvalues. a%rot(N, N) | Rotation from position to Hamiltonian basis. a%pos(N, N) | Position matrix elements in the Hamiltonian basis.

Interface frml:

``` fortran abstract interface function frml(position, args) result(u) !Represents a potential function in the position basis. import dp real(dp), intent(in) :: position real(dp), intent(in) :: args(:)

real(dp) :: u

end function frml end interface ```

type(time_dependent_system) :: b

Additionally to all routines and components of type(steady_state_system), contains: Procedure | Description | Parameters --- | --- | --- Constructor subroutine.
Usage:
call b%init_td(t_start, t_end, t_steps, t_args, Ht, [selected_states, selected_states_start, silent]) | Initializes a dynamics simulation. | real(dp), intent(in) :: t_start, t_end: lenght of the time interval in electronic or atomic units.
integer, intent(in) :: steps: number of discretization steps in the time interval.
real(dp), intent(in) :: t_args(:): Arguments passed to the time dependent Hamiltonian function.
procedure(tdep_hamil) :: Ht: implementation of the time dependent Hamiltonian function in electronic or atomic units. Must comply with interface tdep_hamil.
integer, optional, intent(in) :: selected_states, selected_states_start: for approximations. If specified, the dynamics simulation it will only account for the states [selected_states_start, selected_states_start + selected_states - 1].
logical, optional, intent(in) :: silent: if .true., the program will not write to terminal. Dynamical simulation starter.
Usage:
call b%get_tevop() | Performs the dynamics simulation, granting access to the b%tevop(:, :, :) time evolution operator.

Component | Description --- | --- b%tevop(N, N, Nt) | Time evolution operator in the Hamiltonian basis. N is the number of selected states (selected_states if it was specified in the constructor or the number of discretization points otherwise). Nt is the number of discretization points in the time interval. b%tevop(:, :, ik) is a matrix representing $\hat{U}(tk, ts)$, where $tk = ts + (te - ts) \times (k-1)/(N_t-1)$.

Interface tdep_hamil:

``` fortran abstract interface function tdep_hamil(H, pos, time, targs) result(u) !Represents a time-dependent Hamiltonian in the Hamiltonian basis. import dp complex(dp), intent(in) :: H(:, :), pos(:, :) real(dp), intent(in) :: time real(dp), intent(in) :: targs(:)

complex(dp) :: u(size(H(:, 1)), size(H(1, :)))

end function tdep_hamil end interface ```

Usage

The repository includes two examples. Please read them carefully. These can be run by using fpm run --example Free_Particle_in_a_Box fpm run --example Experimental_System

Build

An automated build is available for Fortran Package Manager users. This is the recommended way to build and use OneDim-QM-NI in your projects. You can add OneDim-QM-NI to your project dependencies by including

[dependencies] OneDim-QM-NI = { git="https://github.com/irukoa/OneDim-QM-NI.git" } in the fpm.toml file.