Stores radial Dirac spinor: F_nk = (f, g)
\[
\psi_{n\kappa m} = \frac{1}{r}
\begin{pmatrix}
f_{n\kappa}(r)\,\Omega_{\kappa m}\\
g_{n\kappa}(r)\,\Omega_{-\kappa m}
\end{pmatrix},
\quad
F_{n\kappa} =
\begin{pmatrix}
f_{n\kappa}(r)\\
g_{n\kappa}(r)
\end{pmatrix}
\]
- Construction.
- Takes in constant n and k=kappa values + grid
- A shared pointer to the Grid is stored (to avoid many copies of Grid)
- Operator Overloads
- Intuative operator overloads are provided (Fa, Fb are DiracSpinors):
- v * Fa, where v is a double or vector works the obvious way
- Fa * Fb = <Fa|Fb>
- Fa == Fb returns true if {na,ka}=={nb,kb}
- Fa > Fb : first compares n, and then kappa (via kappa_index)
- Fa +/- Fb : Adds/subtracts the two spinors (and updates p0/pinf)
- You can make copies: auto Fnew = Fa
- And you can re-asign: Fb = Fa (provided Fa and Fb have same n and kappa!)
- n and kappa are constant, cannot be changed. Avoids angular errors.
- all 'set_' functions return mutable references to variables
|
| | DiracSpinor (int in_n, int in_kappa, std::shared_ptr< const Grid > in_rgrid) |
| | Constructor: Requires n (PQN), kappa (Dirac QN), and grid (shared pointer, as it's a shared resource)
|
| |
| int | n () const |
| | Principal quantum number, n.
|
| |
| int | kappa () const |
| | Dirac quantum number, kappa.
|
| |
| int | l () const |
| | Orbital angular momentum Q number.
|
| |
| double | jjp1 () const |
| | j(j+1)
|
| |
| int | twoj () const |
| | 2j (twice the total angular momentum)
|
| |
| int | twojp1 () const |
| | 2j+1
|
| |
| int | parity () const |
| | (-1)^l, returns +/- 1
|
| |
| std::size_t | k_index () const |
| | kappa index (see AtomData)
|
| |
| Index | nk_index () const |
| | (n,kappa) index (see AtomData)
|
| |
| std::string | symbol (bool gnuplot=false) const |
| | Single-electron term symbol (e.g., 6s_1/2). Gnuplot=true => 6s_{1/2}.
|
| |
| std::string | shortSymbol () const |
| | e.g., 6p_1/2 => 6p-, 6p_3/2 => 6p+
|
| |
| bool & | exotic () |
| | Checks if spinor is for "exotic" lepton, or regular electron.
|
| |
| bool | exotic () const |
| | Checks if spinor is for "exotic" lepton, or regular electron.
|
| |
| bool | negativeEnergyStateQ () const |
| | Returns true if this is a negative-energy state.
|
| |
| void | set_new_kappa (int new_kappa) |
| | Changes 'kappa' angular quantum number. Use with caution!
|
| |
| const Grid & | grid () const |
| | Resturns a const reference to the radial grid.
|
| |
| std::shared_ptr< const Grid > | grid_sptr () const |
| | Resturns copy of shared_ptr to grid [shared resource] - used when we want to construct a new DiracSpinor that shares this grid.
|
| |
| double | en () const |
| | Single-particle energy, not including rest energy.
|
| |
|
double & | en () |
| |
| const std::vector< double > & | f () const |
| | Upper (large) radial component function, f.
|
| |
|
std::vector< double > & | f () |
| |
| double | f (std::size_t i) const |
| | Upper (large) radial component, f(r_i)
|
| |
|
double & | f (std::size_t i) |
| |
| const std::vector< double > & | g () const |
| | Lower (small) radial component function, g.
|
| |
|
std::vector< double > & | g () |
| |
| double | g (std::size_t i) const |
| | Lower (small) radial component, g(r_i)
|
| |
|
double & | g (std::size_t i) |
| |
| auto | min_pt () const |
| | First non-zero point (index for f[i])
|
| |
|
auto & | min_pt () |
| |
| auto | max_pt () const |
| | Effective size(); index after last non-zero point (index for f[i])
|
| |
|
auto & | max_pt () |
| |
| double | r0 () const |
| | r0 = r[min_pt] (in atomic units)
|
| |
| double | rinf () const |
| | rinf = r[max_pt]
|
| |
| auto | its () const |
| | Number of iterations until energy convergence (for latest routine only)
|
| |
|
auto & | its () |
| |
| auto | occ_frac () const |
| | Occupation fraction. =1 for closed shells. =1/(2j+1) for valence.
|
| |
|
auto & | occ_frac () |
| |
| auto | eps () const |
| | Fractional energy convergence: eps = |(en'-en)/en|.
|
| |
|
auto & | eps () |
| |
| const DiracSpinor & | scale (const double factor) |
| | Scales DiracSpinor (f and g) by constant.
|
| |
| const DiracSpinor & | scale (const std::vector< double > &v) |
| | Scales DiracSpinor (f and g) by function of r.
|
| |
| void | normalise (double norm_to=1.0) |
| | By default normalises to 1, but can normalise to other number.
|
| |
| void | zero_boundaries () |
| | Forces f(r) and g(r) to be zero outside of [p0,pinf)
|
| |
| double | norm () const |
| | Returns the norm, defined: Norm = Sqrt[<a|a>].
|
| |
| double | norm2 () const |
| | Returns the norm^2, defined: Norm2 = <a|a>
|
| |
| std::pair< double, double > | r0pinfratio () const |
| | Returns [f[p0]/f_max , f[pinf]/f_max] - for tests.
|
| |
| std::vector< double > | rho () const |
| | rho(r) = sum_m |Psi^2|(r) = (2j+1) * x_occ * |F^2|(r)
|
| |
| int | num_electrons () const |
| | Number of occupied electrons: (2j+1)*occ_frac.
|
| |
| DiracSpinor & | operator+= (const DiracSpinor &rhs) |
| | Adds rhs to this, in place; must have same kappa.
|
| |
| DiracSpinor & | operator-= (const DiracSpinor &rhs) |
| | Subtracts rhs from this, in place; must have same kappa.
|
| |
| DiracSpinor & | operator*= (const double x) |
| | Scales this by scalar x, in place.
|
| |
| DiracSpinor & | operator*= (const std::vector< double > &v) |
| | Multiplies this by function v(r), pointwise, in place.
|
| |
| void | orthog (const DiracSpinor &rhs) |
| | A more correct way to force orthogonality than normal.
|
| |
|
| static bool | comp_l (const DiracSpinor &lhs, const DiracSpinor &rhs) |
| | Comparator (for sorting): by l.
|
| |
| static bool | comp_j (const DiracSpinor &lhs, const DiracSpinor &rhs) |
| | Comparator (for sorting): by 2j.
|
| |
| static bool | comp_ki (const DiracSpinor &lhs, const DiracSpinor &rhs) |
| | Comparator (for sorting): by kappa_index.
|
| |
| static bool | comp_n (const DiracSpinor &lhs, const DiracSpinor &rhs) |
| | Comparator (for sorting): by n.
|
| |
| static bool | comp_en (const DiracSpinor &lhs, const DiracSpinor &rhs) |
| | Comparator (for sorting): by energy.
|
| |
| static std::pair< double, std::string > | check_ortho (const std::vector< DiracSpinor > &a, const std::vector< DiracSpinor > &b) |
| | Returns worst |<a|b>| (or |<a|b>-1| for a=b) {val, state_names}.
|
| |
| static void | orthonormaliseOrbitals (std::vector< DiracSpinor > &orbs, int num_its=1) |
| | (approximately) OrthoNormalises a set of any orbitals
|
| |
| static DiracSpinor | orthogonaliseWrt (const DiracSpinor &Fin, const std::vector< DiracSpinor > &orbs) |
| | Forces Fin to be orthogonal to orbs. If Fn (i.e., {n,k}) in in orbs, replaces Fin with that from orbs.
|
| |
| static DiracSpinor | orthonormaliseWrt (const DiracSpinor &Fin, const std::vector< DiracSpinor > &orbs) |
| | As orthogonaliseWrt(), but normalises Fin afterwards.
|
| |
| static std::string | shortSymbol (int n, int kappa) |
| | e.g., 6p_1/2 => 6p-, 6p_3/2 => 6p+
|
| |
| static std::string | state_config (const std::vector< DiracSpinor > &orbs) |
| | Returns formatted states string (e.g., '7sp5d') given list of orbs.
|
| |
| static DiracSpinor | exactHlike (int n, int k, std::shared_ptr< const Grid > rgrid, double zeff, double alpha=PhysConst::alpha, double mass=1.0) |
| | Constructs an exact H-like (pointlike Coulomb) DiracSpinor.
|
| |
| static DiracSpinor | exactHlike_cntm (double en, int k, std::shared_ptr< const Grid > rgrid, double zeff, double alpha=PhysConst::alpha, double mass=1.0) |
| | Constructs an exact (Dirac-Coulomb) continuum DiracSpinor.
|
| |
| static std::vector< DiracSpinor > | HlikeBasis (int max_l, int num_ns, std::shared_ptr< const Grid > rgrid, double zeff, double alpha=PhysConst::alpha, double mass=1.0) |
| | Constructs a basis of H-like (pointlike) DiracSpinors.
|
| |
| static std::vector< DiracSpinor > | HlikeBasis (const std::string &basis_string, std::shared_ptr< const Grid > rgrid, double zeff, double alpha=PhysConst::alpha, double mass=1.0) |
| | Constructs a basis of H-like (pointlike) DiracSpinors.
|
| |
| static const DiracSpinor * | find (int n, int k, const std::vector< DiracSpinor > &orbs) |
| | Searches for {n,k} in list of orbitals, returns pointer (may be null)
|
| |
| static int | max_tj (const std::vector< DiracSpinor > &orbs) |
| | Returns maximum (2j) found in {orbs}.
|
| |
| static int | max_l (const std::vector< DiracSpinor > &orbs) |
| | Returns maximum l found in {orbs}.
|
| |
| static int | max_n (const std::vector< DiracSpinor > &orbs) |
| | Returns maximum n found in {orbs}.
|
| |
| static int | max_n (const std::vector< DiracSpinor > &orbs, int kappa) |
| | Returns maximum n found in {orbs}, for given kappa.
|
| |
| static std::size_t | max_kindex (const std::vector< DiracSpinor > &orbs) |
| | Returns maximum kappa_index found in {orbs}.
|
| |
| static double | max_En (const std::vector< DiracSpinor > &orbs) |
| | Returns maximum Energy found in {orbs}.
|
| |
| static double | min_En (const std::vector< DiracSpinor > &orbs) |
| | Returns maximum Energy found in {orbs}.
|
| |
| static std::pair< std::vector< DiracSpinor >, std::vector< DiracSpinor > > | split_by_energy (const std::vector< DiracSpinor > &orbitals, double Fermi_energy, int n_min_core=1, int n_max_excited=9999, bool positrons_are_excited=true) |
| | Splits orbitals into two groups (i.e., core, excited) by energy.
|
| |
| static std::pair< std::vector< DiracSpinor >, std::vector< DiracSpinor > > | split_by_core (const std::vector< DiracSpinor > &orbitals, const std::vector< DiracSpinor > &core, int n_min_core=1) |
| | Splits orbitals into two groups (i.e., core, excited)
|
| |
| static std::vector< DiracSpinor > | subset (const std::vector< DiracSpinor > &basis, const std::string &subset_string, bool exclude_negative_energy=true) |
| | Takes a subset of an input basis (by copy), according to subset_string.
|
| |
|
| double | operator* (const DiracSpinor &Fa, const DiracSpinor &Fb) |
| | Returns radial integral (Fa,Fb) = Int(fa*fb + ga*gb)
|
| |
| DiracSpinor | operator+ (DiracSpinor lhs, const DiracSpinor &rhs) |
| | Returns lhs + rhs; must have same kappa.
|
| |
| DiracSpinor | operator- (DiracSpinor lhs, const DiracSpinor &rhs) |
| | Returns lhs - rhs; must have same kappa.
|
| |
| DiracSpinor | operator* (DiracSpinor Fa, const double x) |
| | Returns Fa scaled by scalar x.
|
| |
| DiracSpinor | operator* (const double x, DiracSpinor Fa) |
| | Returns Fa scaled by scalar x.
|
| |
| DiracSpinor | operator* (const std::vector< double > &v, DiracSpinor Fa) |
| | Returns Fa multiplied by function v(r), pointwise.
|
| |
| bool | operator== (const DiracSpinor &lhs, const DiracSpinor &rhs) |
| | Equality: true if {n,kappa} match.
|
| |
| bool | operator!= (const DiracSpinor &lhs, const DiracSpinor &rhs) |
| | Inequality: true if {n,kappa} differ.
|
| |
| bool | operator< (const DiracSpinor &lhs, const DiracSpinor &rhs) |
| | Ordering: compares n, then kappa (via kappa_index)
|
| |
| bool | operator> (const DiracSpinor &lhs, const DiracSpinor &rhs) |
| | Ordering: compares n, then kappa (via kappa_index)
|
| |
| bool | operator<= (const DiracSpinor &lhs, const DiracSpinor &rhs) |
| | Ordering: compares n, then kappa (via kappa_index)
|
| |
| bool | operator>= (const DiracSpinor &lhs, const DiracSpinor &rhs) |
| | Ordering: compares n, then kappa (via kappa_index)
|
| |
| std::ostream & | operator<< (std::ostream &ostr, const DiracSpinor &Fa) |
| | Writes short symbol to ostream.
|
| |
1.9.8