pol - polarizabilities

The pol program calculates the dc and ac polarizabilities of the specified atomic states. The expression for electric-dipole ac polarizability at the frequency \(\omega\) of the state \(|JM\rangle\) can be written (in a.u.) as a sum over unperturbed intermediate states \(n\),

\[\alpha(\omega) = 2 \sum_n \frac{(E_n-E) |\langle JM|D_z|n\rangle|^2}{(E_n-E)^2 - \omega^2} ,\]

where \(D\) is an electric dipole moment operator and \(E\) and \(E_n\) are the energies of the initial and intermediate states, respectively.

To find \(\alpha\), we can rewrite this expression as

\[\alpha(\omega) = \sum_n \langle JM|D_z|n\rangle \,\langle n|D_z| JM\rangle \left[ \frac{1}{E_n-E+\omega} + \frac{1}{E_n-E-\omega} \right] .\]

Then we use the Sternheimer[1] or Dalgarno-Lewis[2] method and solve the inhomogeneous equations

\[(H - E \pm \omega)\, |\delta \phi_{\pm} \rangle = D_z\, |JM \rangle,\]

to find \(|\delta \phi_{\pm} \rangle\),

\[\begin{split}|\delta \phi_{\pm} \rangle &= \frac{1}{H - E \pm \omega} D_z |JM \rangle \\ &= \sum_n \frac{1}{H - E \pm \omega}|n\rangle \langle n |D_z |JM \rangle,\end{split}\]

where \(H\) is the Hamiltonian, and we use the closure relation \(\sum_n | n \rangle \langle n | = 1\). After that, the polarizability can be found as the sum of two matrix elements

\[\alpha(\omega) = \langle JM| D_z |\delta \phi_{+} \rangle + \langle JM| D_z |\delta \phi_{-} \rangle .\]

If electrons in an atomic system are divided into valence and core electrons, the polarizability can be divided accordingly as

\[\alpha \equiv \alpha_v + \alpha_c,\]

where \(\alpha_v\) and \(\alpha_c\) are the valence and core contributions.

The program pol calculates only the valence polarizability \(\alpha_v\). The core polarizability needs to be computed separately with a different program.

Disregarding the vector polarizability, we can present the expression for \(\alpha(\omega)\) as the sum of the scalar and tensor parts,

\[\alpha(\omega) = \alpha_0 + \alpha_2 \, \frac{3M^2-J(J+1)}{J(2J-1)}.\]

The pol program gives both scalar and tensor polarizabilities if the latter is not zero.

This program requires several input files from previously run pconf and pdtm programs, including CONF.DET and CONF.XIJ of the parity of the level of interest (renamed to CONF0.DET and CONF0.XIJ), CONF.INP, CONF.XIJ, CONF.HIJ, and CONF.JJJ of the opposite parity, and the file DTM.INT from pdtm.

Here is a summary of the input and output files used in pol.

Input Files:

  • CONF.INP - list of relativistic configurations and system parameters

  • CONF.DAT - basis set radial orbitals

  • CONF.HIJ - sorted Hamiltonian matrix elements (from sort applied to CONFp.HIJ)

  • CONF.JJJ - sorted \(J^2\) matrix elements (from sort applied to CONFp.JJJ)

  • CONF.XIJ - eigenvectors and eigenvalues of the opposite-parity state

  • CONF0.DET - list of determinants for the state whose polarizability is computed

  • CONF0.JJJ - \(J^2\) matrix elements for the state whose polarizability is computed

  • CONF0.XIJ - eigenvectors and eigenvalues for the state whose polarizability is computed

  • DTM.INT - radial integrals from pdtm

Output Files:

  • POL.RES - scalar and tensor polarizabilities for the requested level and frequency ranges

  • POL_E1.RES - intermediate E1 matrix elements used in the polarizability sum

  • POL_p.XIJ - solution vector \(|\delta\phi_+\rangle\); written during calculation and re-read when Mode = 1

  • POL_m.XIJ - solution vector \(|\delta\phi_-\rangle\); written during calculation and re-read when Mode = 1

  • POL_J_p.XIJ - \(J\)-decomposition of \(|\delta\phi_+\rangle\)

  • POL_J_m.XIJ - \(J\)-decomposition of \(|\delta\phi_-\rangle\)

For example, if we want to calculate polarizabilities for an even state:

cp CONFeven.DET CONF0.DET
cp CONFeven.XIJ CONF0.XIJ

cp CONFodd.INP CONF.INP
cp CONFodd.XIJ CONF.XIJ
cp CONFodd.HIJ CONF.HIJ
cp CONFodd.JJJ CONF.JJJ

Note that pconf writes CONFp.HIJ and CONFp.JJJ in unsorted parallel format. Before running pol, these must be sorted using the sort program, which produces the sorted serial files CONF.HIJ and CONF.JJJ that pol expects.

The pol program requires a list of key-value parameters in a file pol.in:

Mode   = (0, 1)
Method = (0, 1, 2)
Level  = N
Ranges = initial_wavelength final_wavelength step_size [, ...]
IP1    = N

The value of Mode can take the following values:

  • Mode = 0 - start a new calculation

  • Mode = 1 - continue a previous calculation, reading POL_p.XIJ and POL_m.XIJ from disk

The value of Method can take the following values:

  • Method = 0 - invert the matrix and iterate until convergence; restart with iteration if inversion diverges

  • Method = 1 - invert the matrix only, without iterative refinement

  • Method = 2 - modified iteration that restarts every 2 iterations while retaining solution vectors; use when Method = 0 diverges

The value of Level is the index of the eigenvector in CONF0.XIJ for which the polarizability is calculated.

The Ranges field takes a comma-separated list of wavelength ranges, each specified as initial_wavelength final_wavelength step_size (in nm). The special range 0 0 0 computes the dc (static) polarizability.

The value of IP1 sets the dimension of the initial approximation subspace (default: IP1 = 15000).

For example, to calculate dc polarizabilities, as well as ac polarizabilities from \(\lambda=500\) nm to \(\lambda=505\) nm in steps of \(0.5\) nm, for the first state in CONF0.XIJ, we can use the following pol.in:

Mode = 0
Method = 0
Level = 1
Ranges = 0 0 0, 500 505 0.5

The range 0 0 0 corresponds to calculations of dc polarizabilities, while 500 505 0.5 corresponds to calculating ac polarizabilities from \(\lambda=500\) nm to \(\lambda=505\) nm in steps of \(0.5\) nm.

Before parallel pol can be run, the parallel matrix files CONFp.HIJ and CONFp.JJJ have to be sorted. This can be done using the sort program, which sorts the matrix elements of the operators \(H\) and \(J^2\) in order of ascending index (as done in the serial version of pconf). It takes in CONFp.JJJ or CONFp.HIJ and writes a sorted serial version of the file, with an additional integer at the start storing the total number of matrix elements.

Running pol

To run pol, run the command:

pol

References