Module Namespace Reference

Modules are run using calculated atomic wavefunctions. More...

Typedefs
using	module_function_t = void(*)(const IO::InputBlock &input, const Wavefunction &wf)
	function (function ptr) signature for modules
using	nkIndex = DiracSpinor::Index

Functions
void	Kionisation (const IO::InputBlock &input, const Wavefunction &wf)
	Calculates atomic ionisation factor, Kion(E,q) = |<a|j_L|e>|^2, summed over core states, where E is deposited energy: E = |E_a| + e. More...
void	testBasis (const IO::InputBlock &input, const Wavefunction &wf)
void	writeOrbitals (const IO::InputBlock &input, const Wavefunction &wf)
	Module: writes orbitals to text file (gnuplot format)
void	continuum (const IO::InputBlock &input, const Wavefunction &wf)
	Module to output continuum state wavefunctions to disk, and calculate matrix elements between them and bound states.
void	tests (const IO::InputBlock &input, const Wavefunction &wf)
	A range of run-time tests (orthonorm, <H>, sum rules etc.) – see input options. More...
void	Breit (const IO::InputBlock &input, const Wavefunction &wf)
void	exampleModule (const IO::InputBlock &input, const Wavefunction &wf)
	Example module, designed as a "template" to help you add a new module. Note: if you add a new Module, you must also update module_lists.hpp, so it will be compiled into the rest of the code.
void	BW_effect (const std::vector< DiracSpinor > &valence, const DiracOperator::TensorOperator *const h0, const ExternalField::DiagramRPA *const rpa0, const DiracOperator::TensorOperator *const h, const ExternalField::DiagramRPA *const rpa)
void	tune_Rmag (const DiracSpinor &Fv, const double eps_target, const std::optional< IO::InputBlock > &hfs_options, const Wavefunction &wf, const DiracOperator::TensorOperator *const h0, const ExternalField::DiagramRPA *const rpa0)
void	BW_screening_factor (const Wavefunction &wf, const DiracOperator::TensorOperator *const h0, const ExternalField::DiagramRPA *const rpa0, const DiracOperator::TensorOperator *const h, const ExternalField::DiagramRPA *const rpa)
void	fit (std::vector< double > &xd, std::vector< double > &yd, std::size_t terms)
void	b_moments (const std::string &iso, const DiracSpinor &v, double R0_fm, int max_power)
void	HFAnomaly (const IO::InputBlock &input, const Wavefunction &wf)
	Calculates hyperfine anomaly: BW effect, differential anomaly, fits Rmag.
void	fieldShift (const IO::InputBlock &input, const Wavefunction &wf)
	Calculates field shift: F = d(E)/d(<r^2>)
void	ladder (const IO::InputBlock &input, const Wavefunction &wf)
	Module for testing ladder diagram implementation.
void	check_L_symmetry (const std::vector< DiracSpinor > &core, const std::vector< DiracSpinor > &excited, const std::vector< DiracSpinor > &valence, const Coulomb::QkTable &qk, bool include_L4, const Angular::SixJTable &sj, const Coulomb::LkTable *const lk)
void	lifetimes (const IO::InputBlock &input, const Wavefunction &wf)
	Calculates lifetimes (E1, E2, M1)
void	matrixElements (const IO::InputBlock &input, const Wavefunction &wf)
	Calculates matrix elements of any tensor operator, with RPA.
void	structureRad (const IO::InputBlock &input, const Wavefunction &wf)
	Calculates Structure Radiation + Normalisation of States. More...
void	CI_matrixElements (const IO::InputBlock &input, const Wavefunction &wf)
	Calculates matrix elements for CI wavefunctions.
void	muonPV (const IO::InputBlock &input, const Wavefunction &wf)
	Example module, designed as a "template" to help you add a new module. Note: if you add a new Module, you must also update module_lists.hpp, so it will be compiled into the rest of the code.
void	calculatePNC (const IO::InputBlock &input, const Wavefunction &wf)
	Calculates E1 PNC amplitude. More...
void	polarisability (const IO::InputBlock &input, const Wavefunction &wf)
	Calculate atomic (dipole) polarisability, alpha, at given frequency. More...
void	dynamicPolarisability (const IO::InputBlock &input, const Wavefunction &wf)
	Calculate dynamic (dipole) polarisability, alpha(w), as fn of frequency.
void	transitionPolarisability (const IO::InputBlock &input, const Wavefunction &wf)
	Transition polarisabilities, alpha (and later beta)
void	QED (const IO::InputBlock &input, const Wavefunction &wf)
	Calculates QED corrections to energies and matrix elements.
void	runModules (const IO::InputBlock &input, const Wavefunction &wf)
	Loops through all given modules, runs them one at a time.
void	runModule (const IO::InputBlock &input, const Wavefunction &wf)
	Figures out which module to run (Must be updated for each new module!)
void	list_modules ()
	Lists all available modules.
void	screeningFactors (const IO::InputBlock &input, const Wavefunction &wf)
	Calculates effective exchange screening factors (Correlation Potential)
void	VQE (const IO::InputBlock &input, const Wavefunction &wf)
	Just a test: example for playing with VQE.
void	write_H (const LinAlg::Matrix< double > &Hci, const std::string &csf_fname)
void	write_CSFs (const std::vector< CI::CSF2 > &CSFs, int twoJ, const std::map< nkm, int > &orbital_map, const std::string &csf_fname)
template<class Integrals >
void	write_CoulombIntegrals (const std::string &fname, const std::vector< DiracSpinor > &ci_sp_basis, const std::map< nkm, int > &orbital_map, const Integrals &qk)

Detailed Description

Modules are run using calculated atomic wavefunctions.

After the pogram has generated wavefunctions (Hartree-Fock etc), any number of modules can then be run (see input documentation for how to run them). Examples include: calculating matrix elements, lifetimes, PNC etc.

To add a new module:

• a) Write the function (in the Module namespace). You can either add this to one of the existing module cpp/hpp files, or make a new file.
• b) Add your module function name to the module_list map [in Modules/modules_list.hpp]
• c) If you added a new file, add the new .hpp file to the include's list in Modules/modules_list.hpp
• ** See "Modules/exampleModule.{c/h}pp" for an example: you may start from there using that one as a template

Function Documentation

calculatePNC()

void Module::calculatePNC	(	const IO::InputBlock &	input,
		const Wavefunction &	wf
	)

Calculates E1 PNC amplitude.

Uses both 'solving equations' (TDHF) and sum-over-states methods. For solving equations, calculates both:

• <yA_w|d| B> + <A |d|xB_w>
• <A |w|XB_d> + <YA_d|w| B>
• Does not (yet) include DCP

Allowed inputs:

Module::pnc{ c; t; transition; rpa; omega; nmain; }

• c, t: half-density radius and skin-thickness (in fm) for rho(r). Will look up default values by default.
• transition: For E1_PNC a->b transition.
  • in form "a,b", uses the 'short' notation:
  • e.g., "6s+,7s+" for 6s_1/2 -> 7s_1/2
  • e.g., "6s+,5d-" for 6s_1/2 -> 5d_3/2
• rpa: true/false. Include RPA or not (TDHF ,method)
• omega: frequency used for RPA (default is transition frequency of valence).
• nmain: highest n (prin. q. number) considered as part of 'main'.
  • If not given, will be max(n_core)+4
  • (Calculation broken into core, main, tail)

Kionisation()

void Module::Kionisation	(	const IO::InputBlock &	input,
		const Wavefunction &	wf
	)

Calculates atomic ionisation factor, Kion(E,q) = |<a|j_L|e>|^2, summed over core states, where E is deposited energy: E = |E_a| + e.

XXX print each nk

polarisability()

void Module::polarisability	(	const IO::InputBlock &	input,
		const Wavefunction &	wf
	)

Calculate atomic (dipole) polarisability, alpha, at given frequency.

• J. Mitroy, M. S. Safronova, and C. W. Clark, Theory and Applications of Atomic and Ionic Polarizabilities, J. Phys. B 43, 44 (2010).

structureRad()

void Module::structureRad	(	const IO::InputBlock &	input,
		const Wavefunction &	wf
	)

Calculates Structure Radiation + Normalisation of States.

Note: Most input options are similar to MatrixElements module:

Module::structureRad{ operator; options; rpa; printBoth; onlyDiagonal; omega; n_minmax; }

n_minmax: is input as list of ints: n_minmax = min,max; min: minimum n for core states kept in summations max: maximum n for excited states kept in summations

For explanation of the rest, see MatrixElements module.

tests()

void Module::tests	(	const IO::InputBlock &	input,
		const Wavefunction &	wf
	)

A range of run-time tests (orthonorm, <H>, sum rules etc.) – see input options.

Note: These are run-time tests to ensure input params were OK, not unit tests! (see unitTests.cpp for unit tests)