pairinteraction package

Python interface for pairinteraction

pairinteraction.binding.HypergeometricU(a, b, z) → double[source]
Parameters

  • a (double) –

  • b (double) –

  • z (double) –

class pairinteraction.binding.MatrixElementCache(self) → MatrixElementCache[source]

Bases: object

__init__(self, cachedir) -> MatrixElementCache

Parameters

cachedir (std::string const &) –

getDefectDB(self) → std::string const &[source]
getDiamagnetism(self, state_row, state_col, k) → double[source]
Parameters

  • state_row (StateOne const &) –

  • state_col (StateOne const &) –

  • k (int) –

getElectricDipole(self, state_row, state_col) → double[source]
Parameters

  • state_row (StateOne const &) –

  • state_col (StateOne const &) –

getElectricMultipole(self, state_row, state_col, k) → double[source]
Parameters

  • state_row (StateOne const &) –

  • state_col (StateOne const &) –

  • k (int) –

  • getElectricMultipole(self –

  • state_row –

  • state_col –

  • kappa_radial (int) –

  • -> double (kappa_angular)) –

  • state_row –

  • state_col –

  • kappa_radial –

  • kappa_angular (int) –

getMagneticDipole(self, state_row, state_col) → double[source]
Parameters

  • state_row (StateOne const &) –

  • state_col (StateOne const &) –

getRadial(self, state_row, state_col, kappa) → double[source]
Parameters

  • state_row (StateOne const &) –

  • state_col (StateOne const &) –

  • kappa (int) –

loadElectricDipoleDB(self, path, species)[source]
Parameters

  • path (std::string const &) –

  • species (std::string const &) –

precalculateDiamagnetism(self, basis_one, k, q)[source]
Parameters

  • basis_one (std::vector< StateOne,std::allocator< StateOne > > const &) –

  • k (int) –

  • q (int) –

precalculateElectricMomentum(self, basis_one, q)[source]
Parameters

  • basis_one (std::vector< StateOne,std::allocator< StateOne > > const &) –

  • q (int) –

precalculateMagneticMomentum(self, basis_one, q)[source]
Parameters

  • basis_one (std::vector< StateOne,std::allocator< StateOne > > const &) –

  • q (int) –

precalculateMultipole(self, basis_one, k)[source]
Parameters

  • basis_one (std::vector< StateOne,std::allocator< StateOne > > const &) –

  • k (int) –

precalculateRadial(self, basis_one, k)[source]
Parameters

  • basis_one (std::vector< StateOne,std::allocator< StateOne > > const &) –

  • k (int) –

setDefectDB(self, path)[source]
Parameters

path (std::string const &) –

setMethod(self, m)[source]
Parameters

m (method_t const &) –

size(self) → size_t[source]
property thisown

The membership flag

class pairinteraction.binding.Numerov(self, qd) → Numerov[source]

Bases: object

Parameters

qd (QuantumDefect const &) –

integrate(self) → Eigen::MatrixX< double >[source]
static power_kernel(power) → int[source]
Parameters

power (int) –

property thisown

The membership flag

pairinteraction.binding.Numerov_power_kernel(power) → int[source]
Parameters

power (int) –

class pairinteraction.binding.PerturbativeInteraction(self, cache) → PerturbativeInteraction[source]

Bases: object

Parameters

  • cache (MatrixElementCache &) –

  • __init__(self –

  • angle (double) –

  • -> PerturbativeInteraction (cache)) –

  • angle –

  • cache –

getC3(self, states) → Eigen::MatrixX< double >[source]
Parameters

states (std::vector< StateTwo,std::allocator< StateTwo > > const &) –

getC6(self, state, deltaN) → double[source]
Parameters

  • state (StateTwo const &) –

  • deltaN (double) –

  • getC6(self –

  • states (std::vector< StateTwo,std::allocator< StateTwo > > const &) –

  • -> Eigen::MatrixX< double > (deltaN)) –

  • states –

  • deltaN –

getEnergy(self, states) → Eigen::MatrixX< double >[source]
Parameters

states (std::vector< StateTwo,std::allocator< StateTwo > > const &) –

property thisown

The membership flag

class pairinteraction.binding.QuantumDefect(self, species, n, l, j) → QuantumDefect[source]

Bases: object

Parameters

  • species (std::string const &) –

  • n (int) –

  • l (int) –

  • j (double) –

  • __init__(self –

  • species –

  • n –

  • l –

  • j –

  • -> QuantumDefect (database)) –

  • species –

  • n –

  • l –

  • j –

  • database (std::string const &) –

property Z
property a1
property a2
property a3
property a4
property ac
property energy
property j
property l
property n
property nstar
property rc
property species
property thisown

The membership flag

pairinteraction.binding.RadialWFWhittaker(r, nu, l) → double[source]
Parameters

  • r (double) –

  • nu (double) –

  • l (int) –

class pairinteraction.binding.StateOne(self) → StateOne[source]

Bases: object

__init__(self, species, n, l, j, m) -> StateOne

Parameters

  • species (std::string) –

  • n (int) –

  • l (int) –

  • j (float) –

  • m (float) –

  • __init__(self –

  • -> StateOne (label)) –

  • label (std::string) –

getElement(self) → std::string const &[source]
getEnergy(self) → double[source]

getEnergy(self, cache) -> double

Parameters

cache (MatrixElementCache &) –

getHash(self) → size_t const &[source]
getJ(self) → float const &[source]
getL(self) → int const &[source]
getLabel(self) → std::string const &[source]
getM(self) → float const &[source]
getN(self) → int const &[source]
getNStar(self) → double[source]

getNStar(self, cache) -> double

Parameters

cache (MatrixElementCache &) –

getReflected(self) → StateOne[source]
getS(self) → float const &[source]
getSpecies(self) → std::string const &[source]
isArtificial(self) → bool[source]
isGeneralized(self) → bool[source]
str(self) → std::string[source]
property thisown

The membership flag

class pairinteraction.binding.StateTwo(self) → StateTwo[source]

Bases: object

__init__(self, species, n, l, j, m) -> StateTwo

Parameters

  • species (std::array< std::string,2 >) –

  • n (std::array< int,2 >) –

  • l (std::array< int,2 >) –

  • j (std::array< float,2 >) –

  • m (std::array< float,2 >) –

  • __init__(self –

  • -> StateTwo (second_state)) –

  • label (std::array< std::string,2 >) –

  • __init__(self –

  • first_state (StateOne) –

  • -> StateTwo –

  • first_state –

  • second_state (StateOne) –

getElement(self) → ArrayStringTwo[source]

getElement(self, idx) -> std::string const &

Parameters

idx (int) –

getEnergy(self) → double[source]

getEnergy(self, cache) -> double

Parameters

  • cache (MatrixElementCache &) –

  • getEnergy(self –

  • -> double (cache)) –

  • idx (int) –

  • getEnergy(self –

  • idx –

  • -> double –

  • idx –

  • cache –

getFirstState(self) → StateOne[source]
getHash(self) → size_t const &[source]
getJ(self) → ArrayFloatTwo[source]

getJ(self, idx) -> float const &

Parameters

idx (int) –

getL(self) → ArrayIntTwo[source]

getL(self, idx) -> int const &

Parameters

idx (int) –

getLabel(self) → ArrayStringTwo[source]

getLabel(self, idx) -> std::string const &

Parameters

idx (int) –

getLeRoyRadius(self, cache) → double[source]
Parameters

cache (MatrixElementCache &) –

getM(self) → ArrayFloatTwo[source]

getM(self, idx) -> float const &

Parameters

idx (int) –

getN(self) → ArrayIntTwo[source]

getN(self, idx) -> int const &

Parameters

idx (int) –

getNStar(self) → ArrayDoubleTwo[source]

getNStar(self, cache) -> ArrayDoubleTwo

Parameters

  • cache (MatrixElementCache &) –

  • getNStar(self –

  • -> double (cache)) –

  • idx (int) –

  • getNStar(self –

  • idx –

  • -> double –

  • idx –

  • cache –

getReflected(self) → StateTwo[source]
getS(self) → ArrayFloatTwo[source]

getS(self, idx) -> float const &

Parameters

idx (int) –

getSecondState(self) → StateOne[source]
getSpecies(self) → ArrayStringTwo[source]

getSpecies(self, idx) -> std::string const &

Parameters

idx (int) –

isArtificial(self) → ArrayBoolTwo[source]

isArtificial(self, idx) -> bool

Parameters

idx (int) –

isGeneralized(self) → ArrayBoolTwo[source]

isGeneralized(self, idx) -> bool

Parameters

idx (int) –

str(self) → std::string[source]
property thisown

The membership flag

class pairinteraction.binding.Symmetry(self) → Symmetry[source]

Bases: object

property inversion
property permutation
property reflection
property rotation
property thisown

The membership flag

class pairinteraction.binding.SystemOneComplex(self, species, cache) → SystemOneComplex[source]

Bases: pairinteraction.binding._SystemStateOneComplex

Parameters

  • species (std::string) –

  • cache (MatrixElementCache &) –

  • __init__(self –

  • species –

  • cache –

  • -> SystemOneComplex (other)) –

  • species –

  • cache –

  • memory_saving (bool) –

  • __init__(self –

  • -> SystemOneComplex –

  • other (SystemOne< std::complex< double > > const &) –

add(self, system)
Parameters

system (SystemBase< std::complex< double >,StateOne > &) –

addHamiltonianEntry(self, state_row, state_col, value)
Parameters

  • state_row (StateOne const &) –

  • state_col (StateOne const &) –

  • value (std::complex< double >) –

addStates(self, s)
Parameters

  • s (std::set< StateOne,std::less< StateOne >,std::allocator< StateOne > > const &) –

  • addStates(self –

  • s) –

  • s –

applySchriefferWolffTransformation(self, system0)
Parameters

system0 (SystemBase< std::complex< double >,StateOne > &) –

buildBasis(self)
buildHamiltonian(self)
buildInteraction(self)
canonicalize(self)
constrainBasisvectors(self, indices_of_wanted_basisvectors)
Parameters

indices_of_wanted_basisvectors (std::vector< size_t,std::allocator< size_t > >) –

diagonalize(self, energy_lower_bound, energy_upper_bound)
Parameters

  • energy_lower_bound (double) –

  • energy_upper_bound (double) –

  • diagonalize(self –

  • energy_lower_bound –

  • energy_upper_bound –

  • threshold) –

  • energy_lower_bound –

  • energy_upper_bound –

  • threshold (double) –

  • diagonalize(self) –

  • diagonalize(self –

  • threshold) –

  • threshold –

enableDiamagnetism(self, enable)[source]
Parameters

enable (bool) –

forgetStatemixing(self)
getBasisvectorIndex(self, searched_state) → size_t
Parameters

  • searched_state (StateOne const &) –

  • getBasisvectorIndex(self –

  • -> VectorSizeT (searched_states)) –

  • searched_states (std::vector< StateOne,std::allocator< StateOne > > const &) –

getBasisvectors(self) → Eigen::SparseMatrix< std::complex< double > > &
getConnections(self, system_to, threshold) → ArrayVectorSizeTTwo
Parameters

  • system_to (SystemBase< std::complex< double >,StateOne > &) –

  • threshold (double) –

getHamiltonian(self) → Eigen::SparseMatrix< std::complex< double > > &
getHamiltonianEntry(self, state_row, state_col) → std::complex< double >
Parameters

  • state_row (StateOne const &) –

  • state_col (StateOne const &) –

getMainStates(self) → VectorStateOne
getNumBasisvectors(self) → size_t
getNumStates(self) → size_t
getOverlap(self, generalizedstate) → Eigen::VectorX< double >
Parameters

  • generalizedstate (StateOne const &) –

  • getOverlap(self –

  • -> Eigen::VectorX< double > (gamma)) –

  • generalizedstates (std::vector< StateOne,std::allocator< StateOne > > const &) –

  • getOverlap(self –

  • -> Eigen::VectorX< double > –

  • state_index (size_t const &) –

  • getOverlap(self –

  • -> Eigen::VectorX< double > –

  • states_indices (std::vector< size_t,std::allocator< size_t > > const &) –

  • getOverlap(self –

  • generalizedstate –

  • to_z_axis (std::array< double,3 >) –

  • -> Eigen::VectorX< double > –

  • generalizedstate –

  • to_z_axis –

  • to_y_axis (std::array< double,3 >) –

  • getOverlap(self –

  • generalizedstates –

  • to_z_axis –

  • -> Eigen::VectorX< double > –

  • generalizedstates –

  • to_z_axis –

  • to_y_axis –

  • getOverlap(self –

  • state_index –

  • to_z_axis –

  • -> Eigen::VectorX< double > –

  • state_index –

  • to_z_axis –

  • to_y_axis –

  • getOverlap(self –

  • states_indices –

  • to_z_axis –

  • -> Eigen::VectorX< double > –

  • states_indices –

  • to_z_axis –

  • to_y_axis –

  • getOverlap(self –

  • generalizedstate –

  • alpha (double) –

  • beta (double) –

  • -> Eigen::VectorX< double > –

  • generalizedstate –

  • alpha –

  • beta –

  • gamma (double) –

  • getOverlap(self –

  • state_index –

  • alpha –

  • beta –

  • -> Eigen::VectorX< double > –

  • state_index –

  • alpha –

  • beta –

  • gamma –

  • getOverlap(self –

  • generalizedstates –

  • alpha –

  • beta –

  • -> Eigen::VectorX< double > –

  • generalizedstates –

  • alpha –

  • beta –

  • gamma –

  • getOverlap(self –

  • states_indices –

  • alpha –

  • beta –

  • -> Eigen::VectorX< double > –

  • states_indices –

  • alpha –

  • beta –

  • gamma –

getSpecies(self) → std::string const &[source]
getStateIndex(self, searched_state) → size_t
Parameters

  • searched_state (StateOne const &) –

  • getStateIndex(self –

  • -> VectorSizeT (searched_states)) –

  • searched_states (std::vector< StateOne,std::allocator< StateOne > > const &) –

getStates(self) → VectorStateOne
getStatesMultiIndex(self) → states_set< StateOne >::type const &
restrictEnergy(self, e_min, e_max)
Parameters

  • e_min (double) –

  • e_max (double) –

restrictJ(self, j_min, j_max)
Parameters

  • j_min (float) –

  • j_max (float) –

  • restrictJ(self –

  • j) –

  • j (std::set< float,std::less< float >,std::allocator< float > >) –

restrictL(self, l_min, l_max)
Parameters

  • l_min (int) –

  • l_max (int) –

  • restrictL(self –

  • l) –

  • l (std::set< int,std::less< int >,std::allocator< int > >) –

restrictM(self, m_min, m_max)
Parameters

  • m_min (float) –

  • m_max (float) –

  • restrictM(self –

  • m) –

  • m (std::set< float,std::less< float >,std::allocator< float > >) –

restrictN(self, n_min, n_max)
Parameters

  • n_min (int) –

  • n_max (int) –

  • restrictN(self –

  • n) –

  • n (std::set< int,std::less< int >,std::allocator< int > >) –

rotate(self, to_z_axis, to_y_axis)
Parameters

  • to_z_axis (std::array< double,3 >) –

  • to_y_axis (std::array< double,3 >) –

  • rotate(self –

  • alpha (double) –

  • beta (double) –

  • gamma) –

  • alpha –

  • beta –

  • gamma (double) –

setBfield(self, field)[source]
Parameters

  • field (std::array< double,3 >) –

  • setBfield(self –

  • field –

  • to_z_axis (std::array< double,3 >) –

  • to_y_axis) –

  • field –

  • to_z_axis –

  • to_y_axis (std::array< double,3 >) –

  • setBfield(self –

  • field –

  • alpha (double) –

  • beta (double) –

  • gamma) –

  • field –

  • alpha –

  • beta –

  • gamma (double) –

setConservedMomentaUnderRotation(self, momenta)[source]
Parameters

momenta (std::set< float,std::less< float >,std::allocator< float > > const &) –

setConservedParityUnderReflection(self, parity)[source]
Parameters

parity (enum parity_t) –

setEfield(self, field)[source]
Parameters

  • field (std::array< double,3 >) –

  • setEfield(self –

  • field –

  • to_z_axis (std::array< double,3 >) –

  • to_y_axis) –

  • field –

  • to_z_axis –

  • to_y_axis (std::array< double,3 >) –

  • setEfield(self –

  • field –

  • alpha (double) –

  • beta (double) –

  • gamma) –

  • field –

  • alpha –

  • beta –

  • gamma (double) –

setHamiltonianEntry(self, state_row, state_col, value)
Parameters

  • state_row (StateOne const &) –

  • state_col (StateOne const &) –

  • value (std::complex< double >) –

setIonCharge(self, c)[source]
Parameters

c (int) –

setMinimalNorm(self, threshold)
Parameters

threshold (double const &) –

setRydIonDistance(self, d)[source]
Parameters

d (double) –

setRydIonOrder(self, o)[source]
Parameters

o (unsigned int) –

property thisown

The membership flag

unitarize(self)
class pairinteraction.binding.SystemOneReal(self, species, cache) → SystemOneReal[source]

Bases: pairinteraction.binding._SystemStateOneReal

Parameters

  • species (std::string) –

  • cache (MatrixElementCache &) –

  • __init__(self –

  • species –

  • cache –

  • -> SystemOneReal (other)) –

  • species –

  • cache –

  • memory_saving (bool) –

  • __init__(self –

  • -> SystemOneReal –

  • other (SystemOne< double > const &) –

add(self, system)
Parameters

system (SystemBase< double,StateOne > &) –

addHamiltonianEntry(self, state_row, state_col, value)
Parameters

  • state_row (StateOne const &) –

  • state_col (StateOne const &) –

  • value (double) –

addStates(self, s)
Parameters

  • s (std::set< StateOne,std::less< StateOne >,std::allocator< StateOne > > const &) –

  • addStates(self –

  • s) –

  • s –

applySchriefferWolffTransformation(self, system0)
Parameters

system0 (SystemBase< double,StateOne > &) –

buildBasis(self)
buildHamiltonian(self)
buildInteraction(self)
canonicalize(self)
constrainBasisvectors(self, indices_of_wanted_basisvectors)
Parameters

indices_of_wanted_basisvectors (std::vector< size_t,std::allocator< size_t > >) –

diagonalize(self, energy_lower_bound, energy_upper_bound)
Parameters

  • energy_lower_bound (double) –

  • energy_upper_bound (double) –

  • diagonalize(self –

  • energy_lower_bound –

  • energy_upper_bound –

  • threshold) –

  • energy_lower_bound –

  • energy_upper_bound –

  • threshold (double) –

  • diagonalize(self) –

  • diagonalize(self –

  • threshold) –

  • threshold –

enableDiamagnetism(self, enable)[source]
Parameters

enable (bool) –

forgetStatemixing(self)
getBasisvectorIndex(self, searched_state) → size_t
Parameters

  • searched_state (StateOne const &) –

  • getBasisvectorIndex(self –

  • -> VectorSizeT (searched_states)) –

  • searched_states (std::vector< StateOne,std::allocator< StateOne > > const &) –

getBasisvectors(self) → Eigen::SparseMatrix< double > &
getConnections(self, system_to, threshold) → ArrayVectorSizeTTwo
Parameters

  • system_to (SystemBase< double,StateOne > &) –

  • threshold (double) –

getHamiltonian(self) → Eigen::SparseMatrix< double > &
getHamiltonianEntry(self, state_row, state_col) → double
Parameters

  • state_row (StateOne const &) –

  • state_col (StateOne const &) –

getMainStates(self) → VectorStateOne
getNumBasisvectors(self) → size_t
getNumStates(self) → size_t
getOverlap(self, generalizedstate) → Eigen::VectorX< double >
Parameters

  • generalizedstate (StateOne const &) –

  • getOverlap(self –

  • -> Eigen::VectorX< double > (gamma)) –

  • generalizedstates (std::vector< StateOne,std::allocator< StateOne > > const &) –

  • getOverlap(self –

  • -> Eigen::VectorX< double > –

  • state_index (size_t const &) –

  • getOverlap(self –

  • -> Eigen::VectorX< double > –

  • states_indices (std::vector< size_t,std::allocator< size_t > > const &) –

  • getOverlap(self –

  • generalizedstate –

  • to_z_axis (std::array< double,3 >) –

  • -> Eigen::VectorX< double > –

  • generalizedstate –

  • to_z_axis –

  • to_y_axis (std::array< double,3 >) –

  • getOverlap(self –

  • generalizedstates –

  • to_z_axis –

  • -> Eigen::VectorX< double > –

  • generalizedstates –

  • to_z_axis –

  • to_y_axis –

  • getOverlap(self –

  • state_index –

  • to_z_axis –

  • -> Eigen::VectorX< double > –

  • state_index –

  • to_z_axis –

  • to_y_axis –

  • getOverlap(self –

  • states_indices –

  • to_z_axis –

  • -> Eigen::VectorX< double > –

  • states_indices –

  • to_z_axis –

  • to_y_axis –

  • getOverlap(self –

  • generalizedstate –

  • alpha (double) –

  • beta (double) –

  • -> Eigen::VectorX< double > –

  • generalizedstate –

  • alpha –

  • beta –

  • gamma (double) –

  • getOverlap(self –

  • state_index –

  • alpha –

  • beta –

  • -> Eigen::VectorX< double > –

  • state_index –

  • alpha –

  • beta –

  • gamma –

  • getOverlap(self –

  • generalizedstates –

  • alpha –

  • beta –

  • -> Eigen::VectorX< double > –

  • generalizedstates –

  • alpha –

  • beta –

  • gamma –

  • getOverlap(self –

  • states_indices –

  • alpha –

  • beta –

  • -> Eigen::VectorX< double > –

  • states_indices –

  • alpha –

  • beta –

  • gamma –

getSpecies(self) → std::string const &[source]
getStateIndex(self, searched_state) → size_t
Parameters

  • searched_state (StateOne const &) –

  • getStateIndex(self –

  • -> VectorSizeT (searched_states)) –

  • searched_states (std::vector< StateOne,std::allocator< StateOne > > const &) –

getStates(self) → VectorStateOne
getStatesMultiIndex(self) → states_set< StateOne >::type const &
restrictEnergy(self, e_min, e_max)
Parameters

  • e_min (double) –

  • e_max (double) –

restrictJ(self, j_min, j_max)
Parameters

  • j_min (float) –

  • j_max (float) –

  • restrictJ(self –

  • j) –

  • j (std::set< float,std::less< float >,std::allocator< float > >) –

restrictL(self, l_min, l_max)
Parameters

  • l_min (int) –

  • l_max (int) –

  • restrictL(self –

  • l) –

  • l (std::set< int,std::less< int >,std::allocator< int > >) –

restrictM(self, m_min, m_max)
Parameters

  • m_min (float) –

  • m_max (float) –

  • restrictM(self –

  • m) –

  • m (std::set< float,std::less< float >,std::allocator< float > >) –

restrictN(self, n_min, n_max)
Parameters

  • n_min (int) –

  • n_max (int) –

  • restrictN(self –

  • n) –

  • n (std::set< int,std::less< int >,std::allocator< int > >) –

rotate(self, to_z_axis, to_y_axis)
Parameters

  • to_z_axis (std::array< double,3 >) –

  • to_y_axis (std::array< double,3 >) –

  • rotate(self –

  • alpha (double) –

  • beta (double) –

  • gamma) –

  • alpha –

  • beta –

  • gamma (double) –

setBfield(self, field)[source]
Parameters

  • field (std::array< double,3 >) –

  • setBfield(self –

  • field –

  • to_z_axis (std::array< double,3 >) –

  • to_y_axis) –

  • field –

  • to_z_axis –

  • to_y_axis (std::array< double,3 >) –

  • setBfield(self –

  • field –

  • alpha (double) –

  • beta (double) –

  • gamma) –

  • field –

  • alpha –

  • beta –

  • gamma (double) –

setConservedMomentaUnderRotation(self, momenta)[source]
Parameters

momenta (std::set< float,std::less< float >,std::allocator< float > > const &) –

setConservedParityUnderReflection(self, parity)[source]
Parameters

parity (enum parity_t) –

setEfield(self, field)[source]
Parameters

  • field (std::array< double,3 >) –

  • setEfield(self –

  • field –

  • to_z_axis (std::array< double,3 >) –

  • to_y_axis) –

  • field –

  • to_z_axis –

  • to_y_axis (std::array< double,3 >) –

  • setEfield(self –

  • field –

  • alpha (double) –

  • beta (double) –

  • gamma) –

  • field –

  • alpha –

  • beta –

  • gamma (double) –

setHamiltonianEntry(self, state_row, state_col, value)
Parameters

  • state_row (StateOne const &) –

  • state_col (StateOne const &) –

  • value (double) –

setIonCharge(self, c)[source]
Parameters

c (int) –

setMinimalNorm(self, threshold)
Parameters

threshold (double const &) –

setRydIonDistance(self, d)[source]
Parameters

d (double) –

setRydIonOrder(self, o)[source]
Parameters

o (unsigned int) –

property thisown

The membership flag

unitarize(self)
class pairinteraction.binding.SystemTwoComplex(self, b1, b2, cache) → SystemTwoComplex[source]

Bases: pairinteraction.binding._SystemStateTwoComplex

Parameters

  • b1 (SystemOne< std::complex< double > > const &) –

  • b2 (SystemOne< std::complex< double > > const &) –

  • cache (MatrixElementCache &) –

  • __init__(self –

  • b1 –

  • b2 –

  • cache –

  • -> SystemTwoComplex (other)) –

  • b1 –

  • b2 –

  • cache –

  • memory_saving (bool) –

  • __init__(self –

  • -> SystemTwoComplex –

  • other (SystemTwo< std::complex< double > > const &) –

add(self, system)
Parameters

system (SystemBase< std::complex< double >,StateTwo > &) –

addHamiltonianEntry(self, state_row, state_col, value)
Parameters

  • state_row (StateTwo const &) –

  • state_col (StateTwo const &) –

  • value (std::complex< double >) –

addStates(self, s)
Parameters

  • s (std::set< StateTwo,std::less< StateTwo >,std::allocator< StateTwo > > const &) –

  • addStates(self –

  • s) –

  • s –

applySchriefferWolffTransformation(self, system0)
Parameters

system0 (SystemBase< std::complex< double >,StateTwo > &) –

buildBasis(self)
buildHamiltonian(self)
buildInteraction(self)
canonicalize(self)
constrainBasisvectors(self, indices_of_wanted_basisvectors)
Parameters

indices_of_wanted_basisvectors (std::vector< size_t,std::allocator< size_t > >) –

diagonalize(self, energy_lower_bound, energy_upper_bound)
Parameters

  • energy_lower_bound (double) –

  • energy_upper_bound (double) –

  • diagonalize(self –

  • energy_lower_bound –

  • energy_upper_bound –

  • threshold) –

  • energy_lower_bound –

  • energy_upper_bound –

  • threshold (double) –

  • diagonalize(self) –

  • diagonalize(self –

  • threshold) –

  • threshold –

enableGreenTensor(self, GTboolean)[source]
Parameters

GTboolean (bool) –

forgetStatemixing(self)
getBasisvectorIndex(self, searched_state) → size_t
Parameters

  • searched_state (StateTwo const &) –

  • getBasisvectorIndex(self –

  • -> VectorSizeT (searched_states)) –

  • searched_states (std::vector< StateTwo,std::allocator< StateTwo > > const &) –

getBasisvectors(self) → Eigen::SparseMatrix< std::complex< double > > &
getConnections(self, system_to, threshold) → ArrayVectorSizeTTwo
Parameters

  • system_to (SystemBase< std::complex< double >,StateTwo > &) –

  • threshold (double) –

getHamiltonian(self) → Eigen::SparseMatrix< std::complex< double > > &
getHamiltonianEntry(self, state_row, state_col) → std::complex< double >
Parameters

  • state_row (StateTwo const &) –

  • state_col (StateTwo const &) –

getMainStates(self) → VectorStateTwo
getNumBasisvectors(self) → size_t
getNumStates(self) → size_t
getOverlap(self, generalizedstate) → Eigen::VectorX< double >
Parameters

  • generalizedstate (StateTwo const &) –

  • getOverlap(self –

  • -> Eigen::VectorX< double > (gamma)) –

  • generalizedstates (std::vector< StateTwo,std::allocator< StateTwo > > const &) –

  • getOverlap(self –

  • -> Eigen::VectorX< double > –

  • state_index (size_t const &) –

  • getOverlap(self –

  • -> Eigen::VectorX< double > –

  • states_indices (std::vector< size_t,std::allocator< size_t > > const &) –

  • getOverlap(self –

  • generalizedstate –

  • to_z_axis (std::array< double,3 >) –

  • -> Eigen::VectorX< double > –

  • generalizedstate –

  • to_z_axis –

  • to_y_axis (std::array< double,3 >) –

  • getOverlap(self –

  • generalizedstates –

  • to_z_axis –

  • -> Eigen::VectorX< double > –

  • generalizedstates –

  • to_z_axis –

  • to_y_axis –

  • getOverlap(self –

  • state_index –

  • to_z_axis –

  • -> Eigen::VectorX< double > –

  • state_index –

  • to_z_axis –

  • to_y_axis –

  • getOverlap(self –

  • states_indices –

  • to_z_axis –

  • -> Eigen::VectorX< double > –

  • states_indices –

  • to_z_axis –

  • to_y_axis –

  • getOverlap(self –

  • generalizedstate –

  • alpha (double) –

  • beta (double) –

  • -> Eigen::VectorX< double > –

  • generalizedstate –

  • alpha –

  • beta –

  • gamma (double) –

  • getOverlap(self –

  • state_index –

  • alpha –

  • beta –

  • -> Eigen::VectorX< double > –

  • state_index –

  • alpha –

  • beta –

  • gamma –

  • getOverlap(self –

  • generalizedstates –

  • alpha –

  • beta –

  • -> Eigen::VectorX< double > –

  • generalizedstates –

  • alpha –

  • beta –

  • gamma –

  • getOverlap(self –

  • states_indices –

  • alpha –

  • beta –

  • -> Eigen::VectorX< double > –

  • states_indices –

  • alpha –

  • beta –

  • gamma –

getSpecies(self) → ArrayStringTwo[source]
getStateIndex(self, searched_state) → size_t
Parameters

  • searched_state (StateTwo const &) –

  • getStateIndex(self –

  • -> VectorSizeT (searched_states)) –

  • searched_states (std::vector< StateTwo,std::allocator< StateTwo > > const &) –

getStates(self) → VectorStateTwo
getStatesFirst(self) → VectorStateOne[source]
getStatesMultiIndex(self) → states_set< StateTwo >::type const &
getStatesSecond(self) → VectorStateOne[source]
restrictEnergy(self, e_min, e_max)
Parameters

  • e_min (double) –

  • e_max (double) –

restrictJ(self, j_min, j_max)
Parameters

  • j_min (float) –

  • j_max (float) –

  • restrictJ(self –

  • j) –

  • j (std::set< float,std::less< float >,std::allocator< float > >) –

restrictL(self, l_min, l_max)
Parameters

  • l_min (int) –

  • l_max (int) –

  • restrictL(self –

  • l) –

  • l (std::set< int,std::less< int >,std::allocator< int > >) –

restrictM(self, m_min, m_max)
Parameters

  • m_min (float) –

  • m_max (float) –

  • restrictM(self –

  • m) –

  • m (std::set< float,std::less< float >,std::allocator< float > >) –

restrictN(self, n_min, n_max)
Parameters

  • n_min (int) –

  • n_max (int) –

  • restrictN(self –

  • n) –

  • n (std::set< int,std::less< int >,std::allocator< int > >) –

rotate(self, to_z_axis, to_y_axis)
Parameters

  • to_z_axis (std::array< double,3 >) –

  • to_y_axis (std::array< double,3 >) –

  • rotate(self –

  • alpha (double) –

  • beta (double) –

  • gamma) –

  • alpha –

  • beta –

  • gamma (double) –

setAngle(self, a)[source]
Parameters

a (double) –

setConservedMomentaUnderRotation(self, momenta)[source]
Parameters

momenta (std::set< int,std::less< int >,std::allocator< int > > const &) –

setConservedParityUnderInversion(self, parity)[source]
Parameters

parity (enum parity_t) –

setConservedParityUnderPermutation(self, parity)[source]
Parameters

parity (enum parity_t) –

setConservedParityUnderReflection(self, parity)[source]
Parameters

parity (enum parity_t) –

setDistance(self, d)[source]
Parameters

d (double) –

setDistanceVector(self, d)[source]
Parameters

d (std::array< double,3 >) –

setHamiltonianEntry(self, state_row, state_col, value)
Parameters

  • state_row (StateTwo const &) –

  • state_col (StateTwo const &) –

  • value (std::complex< double >) –

setMinimalNorm(self, threshold)
Parameters

threshold (double const &) –

setOneAtomBasisvectors(self, indices)[source]
Parameters

indices (std::vector< std::array< size_t,2 >,std::allocator< std::array< size_t,2 > > > const &) –

setOrder(self, o)[source]
Parameters

o (double) –

setSurfaceDistance(self, d)[source]
Parameters

d (double) –

property thisown

The membership flag

unitarize(self)
class pairinteraction.binding.SystemTwoReal(self, b1, b2, cache) → SystemTwoReal[source]

Bases: pairinteraction.binding._SystemStateTwoReal

Parameters

  • b1 (SystemOne< double > const &) –

  • b2 (SystemOne< double > const &) –

  • cache (MatrixElementCache &) –

  • __init__(self –

  • b1 –

  • b2 –

  • cache –

  • -> SystemTwoReal (other)) –

  • b1 –

  • b2 –

  • cache –

  • memory_saving (bool) –

  • __init__(self –

  • -> SystemTwoReal –

  • other (SystemTwo< double > const &) –

add(self, system)
Parameters

system (SystemBase< double,StateTwo > &) –

addHamiltonianEntry(self, state_row, state_col, value)
Parameters

  • state_row (StateTwo const &) –

  • state_col (StateTwo const &) –

  • value (double) –

addStates(self, s)
Parameters

  • s (std::set< StateTwo,std::less< StateTwo >,std::allocator< StateTwo > > const &) –

  • addStates(self –

  • s) –

  • s –

applySchriefferWolffTransformation(self, system0)
Parameters

system0 (SystemBase< double,StateTwo > &) –

buildBasis(self)
buildHamiltonian(self)
buildInteraction(self)
canonicalize(self)
constrainBasisvectors(self, indices_of_wanted_basisvectors)
Parameters

indices_of_wanted_basisvectors (std::vector< size_t,std::allocator< size_t > >) –

diagonalize(self, energy_lower_bound, energy_upper_bound)
Parameters

  • energy_lower_bound (double) –

  • energy_upper_bound (double) –

  • diagonalize(self –

  • energy_lower_bound –

  • energy_upper_bound –

  • threshold) –

  • energy_lower_bound –

  • energy_upper_bound –

  • threshold (double) –

  • diagonalize(self) –

  • diagonalize(self –

  • threshold) –

  • threshold –

enableGreenTensor(self, GTboolean)[source]
Parameters

GTboolean (bool) –

forgetStatemixing(self)
getBasisvectorIndex(self, searched_state) → size_t
Parameters

  • searched_state (StateTwo const &) –

  • getBasisvectorIndex(self –

  • -> VectorSizeT (searched_states)) –

  • searched_states (std::vector< StateTwo,std::allocator< StateTwo > > const &) –

getBasisvectors(self) → Eigen::SparseMatrix< double > &
getConnections(self, system_to, threshold) → ArrayVectorSizeTTwo
Parameters

  • system_to (SystemBase< double,StateTwo > &) –

  • threshold (double) –

getHamiltonian(self) → Eigen::SparseMatrix< double > &
getHamiltonianEntry(self, state_row, state_col) → double
Parameters

  • state_row (StateTwo const &) –

  • state_col (StateTwo const &) –

getMainStates(self) → VectorStateTwo
getNumBasisvectors(self) → size_t
getNumStates(self) → size_t
getOverlap(self, generalizedstate) → Eigen::VectorX< double >
Parameters

  • generalizedstate (StateTwo const &) –

  • getOverlap(self –

  • -> Eigen::VectorX< double > (gamma)) –

  • generalizedstates (std::vector< StateTwo,std::allocator< StateTwo > > const &) –

  • getOverlap(self –

  • -> Eigen::VectorX< double > –

  • state_index (size_t const &) –

  • getOverlap(self –

  • -> Eigen::VectorX< double > –

  • states_indices (std::vector< size_t,std::allocator< size_t > > const &) –

  • getOverlap(self –

  • generalizedstate –

  • to_z_axis (std::array< double,3 >) –

  • -> Eigen::VectorX< double > –

  • generalizedstate –

  • to_z_axis –

  • to_y_axis (std::array< double,3 >) –

  • getOverlap(self –

  • generalizedstates –

  • to_z_axis –

  • -> Eigen::VectorX< double > –

  • generalizedstates –

  • to_z_axis –

  • to_y_axis –

  • getOverlap(self –

  • state_index –

  • to_z_axis –

  • -> Eigen::VectorX< double > –

  • state_index –

  • to_z_axis –

  • to_y_axis –

  • getOverlap(self –

  • states_indices –

  • to_z_axis –

  • -> Eigen::VectorX< double > –

  • states_indices –

  • to_z_axis –

  • to_y_axis –

  • getOverlap(self –

  • generalizedstate –

  • alpha (double) –

  • beta (double) –

  • -> Eigen::VectorX< double > –

  • generalizedstate –

  • alpha –

  • beta –

  • gamma (double) –

  • getOverlap(self –

  • state_index –

  • alpha –

  • beta –

  • -> Eigen::VectorX< double > –

  • state_index –

  • alpha –

  • beta –

  • gamma –

  • getOverlap(self –

  • generalizedstates –

  • alpha –

  • beta –

  • -> Eigen::VectorX< double > –

  • generalizedstates –

  • alpha –

  • beta –

  • gamma –

  • getOverlap(self –

  • states_indices –

  • alpha –

  • beta –

  • -> Eigen::VectorX< double > –

  • states_indices –

  • alpha –

  • beta –

  • gamma –

getSpecies(self) → ArrayStringTwo[source]
getStateIndex(self, searched_state) → size_t
Parameters

  • searched_state (StateTwo const &) –

  • getStateIndex(self –

  • -> VectorSizeT (searched_states)) –

  • searched_states (std::vector< StateTwo,std::allocator< StateTwo > > const &) –

getStates(self) → VectorStateTwo
getStatesFirst(self) → VectorStateOne[source]
getStatesMultiIndex(self) → states_set< StateTwo >::type const &
getStatesSecond(self) → VectorStateOne[source]
restrictEnergy(self, e_min, e_max)
Parameters

  • e_min (double) –

  • e_max (double) –

restrictJ(self, j_min, j_max)
Parameters

  • j_min (float) –

  • j_max (float) –

  • restrictJ(self –

  • j) –

  • j (std::set< float,std::less< float >,std::allocator< float > >) –

restrictL(self, l_min, l_max)
Parameters

  • l_min (int) –

  • l_max (int) –

  • restrictL(self –

  • l) –

  • l (std::set< int,std::less< int >,std::allocator< int > >) –

restrictM(self, m_min, m_max)
Parameters

  • m_min (float) –

  • m_max (float) –

  • restrictM(self –

  • m) –

  • m (std::set< float,std::less< float >,std::allocator< float > >) –

restrictN(self, n_min, n_max)
Parameters

  • n_min (int) –

  • n_max (int) –

  • restrictN(self –

  • n) –

  • n (std::set< int,std::less< int >,std::allocator< int > >) –

rotate(self, to_z_axis, to_y_axis)
Parameters

  • to_z_axis (std::array< double,3 >) –

  • to_y_axis (std::array< double,3 >) –

  • rotate(self –

  • alpha (double) –

  • beta (double) –

  • gamma) –

  • alpha –

  • beta –

  • gamma (double) –

setAngle(self, a)[source]
Parameters

a (double) –

setConservedMomentaUnderRotation(self, momenta)[source]
Parameters

momenta (std::set< int,std::less< int >,std::allocator< int > > const &) –

setConservedParityUnderInversion(self, parity)[source]
Parameters

parity (enum parity_t) –

setConservedParityUnderPermutation(self, parity)[source]
Parameters

parity (enum parity_t) –

setConservedParityUnderReflection(self, parity)[source]
Parameters

parity (enum parity_t) –

setDistance(self, d)[source]
Parameters

d (double) –

setDistanceVector(self, d)[source]
Parameters

d (std::array< double,3 >) –

setHamiltonianEntry(self, state_row, state_col, value)
Parameters

  • state_row (StateTwo const &) –

  • state_col (StateTwo const &) –

  • value (double) –

setMinimalNorm(self, threshold)
Parameters

threshold (double const &) –

setOneAtomBasisvectors(self, indices)[source]
Parameters

indices (std::vector< std::array< size_t,2 >,std::allocator< std::array< size_t,2 > > > const &) –

setOrder(self, o)[source]
Parameters

o (double) –

setSurfaceDistance(self, d)[source]
Parameters

d (double) –

property thisown

The membership flag

unitarize(self)
pairinteraction.binding.V(qd, x) → double[source]
Parameters

  • qd (QuantumDefect const &) –

  • x (double) –

class pairinteraction.binding.Whittaker(self, qd) → Whittaker[source]

Bases: object

Parameters

qd (QuantumDefect const &) –

integrate(self) → Eigen::MatrixX< double >[source]
static power_kernel(power) → double[source]
Parameters

power (int) –

property thisown

The membership flag

pairinteraction.binding.WhittakerW(k, m, z) → double[source]
Parameters

  • k (double) –

  • m (double) –

  • z (double) –

pairinteraction.binding.Whittaker_power_kernel(power) → double[source]
Parameters

power (int) –

class pairinteraction.binding.WignerD(self) → WignerD[source]

Bases: object

property thisown

The membership flag

class pairinteraction.binding._SwigNonDynamicMeta[source]

Bases: type

Meta class to enforce nondynamic attributes (no new attributes) for a class

mro()

Return a type’s method resolution order.

class pairinteraction.binding._SystemStateOneComplex(*args, **kwargs)[source]

Bases: object

Proxy of C++ SystemBase< std::complex< double >,StateOne > class.

add(self, system)[source]
Parameters

system (SystemBase< std::complex< double >,StateOne > &) –

addHamiltonianEntry(self, state_row, state_col, value)[source]
Parameters

  • state_row (StateOne const &) –

  • state_col (StateOne const &) –

  • value (std::complex< double >) –

addStates(self, s)[source]
Parameters

  • s (std::set< StateOne,std::less< StateOne >,std::allocator< StateOne > > const &) –

  • addStates(self –

  • s) –

  • s –

applySchriefferWolffTransformation(self, system0)[source]
Parameters

system0 (SystemBase< std::complex< double >,StateOne > &) –

buildBasis(self)[source]
buildHamiltonian(self)[source]
buildInteraction(self)[source]
canonicalize(self)[source]
constrainBasisvectors(self, indices_of_wanted_basisvectors)[source]
Parameters

indices_of_wanted_basisvectors (std::vector< size_t,std::allocator< size_t > >) –

diagonalize(self, energy_lower_bound, energy_upper_bound)[source]
Parameters

  • energy_lower_bound (double) –

  • energy_upper_bound (double) –

  • diagonalize(self –

  • energy_lower_bound –

  • energy_upper_bound –

  • threshold) –

  • energy_lower_bound –

  • energy_upper_bound –

  • threshold (double) –

  • diagonalize(self) –

  • diagonalize(self –

  • threshold) –

  • threshold –

forgetStatemixing(self)[source]
getBasisvectorIndex(self, searched_state) → size_t[source]
Parameters

  • searched_state (StateOne const &) –

  • getBasisvectorIndex(self –

  • -> VectorSizeT (searched_states)) –

  • searched_states (std::vector< StateOne,std::allocator< StateOne > > const &) –

getBasisvectors(self) → Eigen::SparseMatrix< std::complex< double > > &[source]
getConnections(self, system_to, threshold) → ArrayVectorSizeTTwo[source]
Parameters

  • system_to (SystemBase< std::complex< double >,StateOne > &) –

  • threshold (double) –

getHamiltonian(self) → Eigen::SparseMatrix< std::complex< double > > &[source]
getHamiltonianEntry(self, state_row, state_col) → std::complex< double >[source]
Parameters

  • state_row (StateOne const &) –

  • state_col (StateOne const &) –

getMainStates(self) → VectorStateOne[source]
getNumBasisvectors(self) → size_t[source]
getNumStates(self) → size_t[source]
getOverlap(self, generalizedstate) → Eigen::VectorX< double >[source]
Parameters

  • generalizedstate (StateOne const &) –

  • getOverlap(self –

  • -> Eigen::VectorX< double > (gamma)) –

  • generalizedstates (std::vector< StateOne,std::allocator< StateOne > > const &) –

  • getOverlap(self –

  • -> Eigen::VectorX< double > –

  • state_index (size_t const &) –

  • getOverlap(self –

  • -> Eigen::VectorX< double > –

  • states_indices (std::vector< size_t,std::allocator< size_t > > const &) –

  • getOverlap(self –

  • generalizedstate –

  • to_z_axis (std::array< double,3 >) –

  • -> Eigen::VectorX< double > –

  • generalizedstate –

  • to_z_axis –

  • to_y_axis (std::array< double,3 >) –

  • getOverlap(self –

  • generalizedstates –

  • to_z_axis –

  • -> Eigen::VectorX< double > –

  • generalizedstates –

  • to_z_axis –

  • to_y_axis –

  • getOverlap(self –

  • state_index –

  • to_z_axis –

  • -> Eigen::VectorX< double > –

  • state_index –

  • to_z_axis –

  • to_y_axis –

  • getOverlap(self –

  • states_indices –

  • to_z_axis –

  • -> Eigen::VectorX< double > –

  • states_indices –

  • to_z_axis –

  • to_y_axis –

  • getOverlap(self –

  • generalizedstate –

  • alpha (double) –

  • beta (double) –

  • -> Eigen::VectorX< double > –

  • generalizedstate –

  • alpha –

  • beta –

  • gamma (double) –

  • getOverlap(self –

  • state_index –

  • alpha –

  • beta –

  • -> Eigen::VectorX< double > –

  • state_index –

  • alpha –

  • beta –

  • gamma –

  • getOverlap(self –

  • generalizedstates –

  • alpha –

  • beta –

  • -> Eigen::VectorX< double > –

  • generalizedstates –

  • alpha –

  • beta –

  • gamma –

  • getOverlap(self –

  • states_indices –

  • alpha –

  • beta –

  • -> Eigen::VectorX< double > –

  • states_indices –

  • alpha –

  • beta –

  • gamma –

getStateIndex(self, searched_state) → size_t[source]
Parameters

  • searched_state (StateOne const &) –

  • getStateIndex(self –

  • -> VectorSizeT (searched_states)) –

  • searched_states (std::vector< StateOne,std::allocator< StateOne > > const &) –

getStates(self) → VectorStateOne[source]
getStatesMultiIndex(self) → states_set< StateOne >::type const &[source]
restrictEnergy(self, e_min, e_max)[source]
Parameters

  • e_min (double) –

  • e_max (double) –

restrictJ(self, j_min, j_max)[source]
Parameters

  • j_min (float) –

  • j_max (float) –

  • restrictJ(self –

  • j) –

  • j (std::set< float,std::less< float >,std::allocator< float > >) –

restrictL(self, l_min, l_max)[source]
Parameters

  • l_min (int) –

  • l_max (int) –

  • restrictL(self –

  • l) –

  • l (std::set< int,std::less< int >,std::allocator< int > >) –

restrictM(self, m_min, m_max)[source]
Parameters

  • m_min (float) –

  • m_max (float) –

  • restrictM(self –

  • m) –

  • m (std::set< float,std::less< float >,std::allocator< float > >) –

restrictN(self, n_min, n_max)[source]
Parameters

  • n_min (int) –

  • n_max (int) –

  • restrictN(self –

  • n) –

  • n (std::set< int,std::less< int >,std::allocator< int > >) –

rotate(self, to_z_axis, to_y_axis)[source]
Parameters

  • to_z_axis (std::array< double,3 >) –

  • to_y_axis (std::array< double,3 >) –

  • rotate(self –

  • alpha (double) –

  • beta (double) –

  • gamma) –

  • alpha –

  • beta –

  • gamma (double) –

setHamiltonianEntry(self, state_row, state_col, value)[source]
Parameters

  • state_row (StateOne const &) –

  • state_col (StateOne const &) –

  • value (std::complex< double >) –

setMinimalNorm(self, threshold)[source]
Parameters

threshold (double const &) –

property thisown

The membership flag

unitarize(self)[source]
class pairinteraction.binding._SystemStateOneReal(*args, **kwargs)[source]

Bases: object

Proxy of C++ SystemBase< double,StateOne > class.

add(self, system)[source]
Parameters

system (SystemBase< double,StateOne > &) –

addHamiltonianEntry(self, state_row, state_col, value)[source]
Parameters

  • state_row (StateOne const &) –

  • state_col (StateOne const &) –

  • value (double) –

addStates(self, s)[source]
Parameters

  • s (std::set< StateOne,std::less< StateOne >,std::allocator< StateOne > > const &) –

  • addStates(self –

  • s) –

  • s –

applySchriefferWolffTransformation(self, system0)[source]
Parameters

system0 (SystemBase< double,StateOne > &) –

buildBasis(self)[source]
buildHamiltonian(self)[source]
buildInteraction(self)[source]
canonicalize(self)[source]
constrainBasisvectors(self, indices_of_wanted_basisvectors)[source]
Parameters

indices_of_wanted_basisvectors (std::vector< size_t,std::allocator< size_t > >) –

diagonalize(self, energy_lower_bound, energy_upper_bound)[source]
Parameters

  • energy_lower_bound (double) –

  • energy_upper_bound (double) –

  • diagonalize(self –

  • energy_lower_bound –

  • energy_upper_bound –

  • threshold) –

  • energy_lower_bound –

  • energy_upper_bound –

  • threshold (double) –

  • diagonalize(self) –

  • diagonalize(self –

  • threshold) –

  • threshold –

forgetStatemixing(self)[source]
getBasisvectorIndex(self, searched_state) → size_t[source]
Parameters

  • searched_state (StateOne const &) –

  • getBasisvectorIndex(self –

  • -> VectorSizeT (searched_states)) –

  • searched_states (std::vector< StateOne,std::allocator< StateOne > > const &) –

getBasisvectors(self) → Eigen::SparseMatrix< double > &[source]
getConnections(self, system_to, threshold) → ArrayVectorSizeTTwo[source]
Parameters

  • system_to (SystemBase< double,StateOne > &) –

  • threshold (double) –

getHamiltonian(self) → Eigen::SparseMatrix< double > &[source]
getHamiltonianEntry(self, state_row, state_col) → double[source]
Parameters

  • state_row (StateOne const &) –

  • state_col (StateOne const &) –

getMainStates(self) → VectorStateOne[source]
getNumBasisvectors(self) → size_t[source]
getNumStates(self) → size_t[source]
getOverlap(self, generalizedstate) → Eigen::VectorX< double >[source]
Parameters

  • generalizedstate (StateOne const &) –

  • getOverlap(self –

  • -> Eigen::VectorX< double > (gamma)) –

  • generalizedstates (std::vector< StateOne,std::allocator< StateOne > > const &) –

  • getOverlap(self –

  • -> Eigen::VectorX< double > –

  • state_index (size_t const &) –

  • getOverlap(self –

  • -> Eigen::VectorX< double > –

  • states_indices (std::vector< size_t,std::allocator< size_t > > const &) –

  • getOverlap(self –

  • generalizedstate –

  • to_z_axis (std::array< double,3 >) –

  • -> Eigen::VectorX< double > –

  • generalizedstate –

  • to_z_axis –

  • to_y_axis (std::array< double,3 >) –

  • getOverlap(self –

  • generalizedstates –

  • to_z_axis –

  • -> Eigen::VectorX< double > –

  • generalizedstates –

  • to_z_axis –

  • to_y_axis –

  • getOverlap(self –

  • state_index –

  • to_z_axis –

  • -> Eigen::VectorX< double > –

  • state_index –

  • to_z_axis –

  • to_y_axis –

  • getOverlap(self –

  • states_indices –

  • to_z_axis –

  • -> Eigen::VectorX< double > –

  • states_indices –

  • to_z_axis –

  • to_y_axis –

  • getOverlap(self –

  • generalizedstate –

  • alpha (double) –

  • beta (double) –

  • -> Eigen::VectorX< double > –

  • generalizedstate –

  • alpha –

  • beta –

  • gamma (double) –

  • getOverlap(self –

  • state_index –

  • alpha –

  • beta –

  • -> Eigen::VectorX< double > –

  • state_index –

  • alpha –

  • beta –

  • gamma –

  • getOverlap(self –

  • generalizedstates –

  • alpha –

  • beta –

  • -> Eigen::VectorX< double > –

  • generalizedstates –

  • alpha –

  • beta –

  • gamma –

  • getOverlap(self –

  • states_indices –

  • alpha –

  • beta –

  • -> Eigen::VectorX< double > –

  • states_indices –

  • alpha –

  • beta –

  • gamma –

getStateIndex(self, searched_state) → size_t[source]
Parameters

  • searched_state (StateOne const &) –

  • getStateIndex(self –

  • -> VectorSizeT (searched_states)) –

  • searched_states (std::vector< StateOne,std::allocator< StateOne > > const &) –

getStates(self) → VectorStateOne[source]
getStatesMultiIndex(self) → states_set< StateOne >::type const &[source]
restrictEnergy(self, e_min, e_max)[source]
Parameters

  • e_min (double) –

  • e_max (double) –

restrictJ(self, j_min, j_max)[source]
Parameters

  • j_min (float) –

  • j_max (float) –

  • restrictJ(self –

  • j) –

  • j (std::set< float,std::less< float >,std::allocator< float > >) –

restrictL(self, l_min, l_max)[source]
Parameters

  • l_min (int) –

  • l_max (int) –

  • restrictL(self –

  • l) –

  • l (std::set< int,std::less< int >,std::allocator< int > >) –

restrictM(self, m_min, m_max)[source]
Parameters

  • m_min (float) –

  • m_max (float) –

  • restrictM(self –

  • m) –

  • m (std::set< float,std::less< float >,std::allocator< float > >) –

restrictN(self, n_min, n_max)[source]
Parameters

  • n_min (int) –

  • n_max (int) –

  • restrictN(self –

  • n) –

  • n (std::set< int,std::less< int >,std::allocator< int > >) –

rotate(self, to_z_axis, to_y_axis)[source]
Parameters

  • to_z_axis (std::array< double,3 >) –

  • to_y_axis (std::array< double,3 >) –

  • rotate(self –

  • alpha (double) –

  • beta (double) –

  • gamma) –

  • alpha –

  • beta –

  • gamma (double) –

setHamiltonianEntry(self, state_row, state_col, value)[source]
Parameters

  • state_row (StateOne const &) –

  • state_col (StateOne const &) –

  • value (double) –

setMinimalNorm(self, threshold)[source]
Parameters

threshold (double const &) –

property thisown

The membership flag

unitarize(self)[source]
class pairinteraction.binding._SystemStateTwoComplex(*args, **kwargs)[source]

Bases: object

Proxy of C++ SystemBase< std::complex< double >,StateTwo > class.

add(self, system)[source]
Parameters

system (SystemBase< std::complex< double >,StateTwo > &) –

addHamiltonianEntry(self, state_row, state_col, value)[source]
Parameters

  • state_row (StateTwo const &) –

  • state_col (StateTwo const &) –

  • value (std::complex< double >) –

addStates(self, s)[source]
Parameters

  • s (std::set< StateTwo,std::less< StateTwo >,std::allocator< StateTwo > > const &) –

  • addStates(self –

  • s) –

  • s –

applySchriefferWolffTransformation(self, system0)[source]
Parameters

system0 (SystemBase< std::complex< double >,StateTwo > &) –

buildBasis(self)[source]
buildHamiltonian(self)[source]
buildInteraction(self)[source]
canonicalize(self)[source]
constrainBasisvectors(self, indices_of_wanted_basisvectors)[source]
Parameters

indices_of_wanted_basisvectors (std::vector< size_t,std::allocator< size_t > >) –

diagonalize(self, energy_lower_bound, energy_upper_bound)[source]
Parameters

  • energy_lower_bound (double) –

  • energy_upper_bound (double) –

  • diagonalize(self –

  • energy_lower_bound –

  • energy_upper_bound –

  • threshold) –

  • energy_lower_bound –

  • energy_upper_bound –

  • threshold (double) –

  • diagonalize(self) –

  • diagonalize(self –

  • threshold) –

  • threshold –

forgetStatemixing(self)[source]
getBasisvectorIndex(self, searched_state) → size_t[source]
Parameters

  • searched_state (StateTwo const &) –

  • getBasisvectorIndex(self –

  • -> VectorSizeT (searched_states)) –

  • searched_states (std::vector< StateTwo,std::allocator< StateTwo > > const &) –

getBasisvectors(self) → Eigen::SparseMatrix< std::complex< double > > &[source]
getConnections(self, system_to, threshold) → ArrayVectorSizeTTwo[source]
Parameters

  • system_to (SystemBase< std::complex< double >,StateTwo > &) –

  • threshold (double) –

getHamiltonian(self) → Eigen::SparseMatrix< std::complex< double > > &[source]
getHamiltonianEntry(self, state_row, state_col) → std::complex< double >[source]
Parameters

  • state_row (StateTwo const &) –

  • state_col (StateTwo const &) –

getMainStates(self) → VectorStateTwo[source]
getNumBasisvectors(self) → size_t[source]
getNumStates(self) → size_t[source]
getOverlap(self, generalizedstate) → Eigen::VectorX< double >[source]
Parameters

  • generalizedstate (StateTwo const &) –

  • getOverlap(self –

  • -> Eigen::VectorX< double > (gamma)) –

  • generalizedstates (std::vector< StateTwo,std::allocator< StateTwo > > const &) –

  • getOverlap(self –

  • -> Eigen::VectorX< double > –

  • state_index (size_t const &) –

  • getOverlap(self –

  • -> Eigen::VectorX< double > –

  • states_indices (std::vector< size_t,std::allocator< size_t > > const &) –

  • getOverlap(self –

  • generalizedstate –

  • to_z_axis (std::array< double,3 >) –

  • -> Eigen::VectorX< double > –

  • generalizedstate –

  • to_z_axis –

  • to_y_axis (std::array< double,3 >) –

  • getOverlap(self –

  • generalizedstates –

  • to_z_axis –

  • -> Eigen::VectorX< double > –

  • generalizedstates –

  • to_z_axis –

  • to_y_axis –

  • getOverlap(self –

  • state_index –

  • to_z_axis –

  • -> Eigen::VectorX< double > –

  • state_index –

  • to_z_axis –

  • to_y_axis –

  • getOverlap(self –

  • states_indices –

  • to_z_axis –

  • -> Eigen::VectorX< double > –

  • states_indices –

  • to_z_axis –

  • to_y_axis –

  • getOverlap(self –

  • generalizedstate –

  • alpha (double) –

  • beta (double) –

  • -> Eigen::VectorX< double > –

  • generalizedstate –

  • alpha –

  • beta –

  • gamma (double) –

  • getOverlap(self –

  • state_index –

  • alpha –

  • beta –

  • -> Eigen::VectorX< double > –

  • state_index –

  • alpha –

  • beta –

  • gamma –

  • getOverlap(self –

  • generalizedstates –

  • alpha –

  • beta –

  • -> Eigen::VectorX< double > –

  • generalizedstates –

  • alpha –

  • beta –

  • gamma –

  • getOverlap(self –

  • states_indices –

  • alpha –

  • beta –

  • -> Eigen::VectorX< double > –

  • states_indices –

  • alpha –

  • beta –

  • gamma –

getStateIndex(self, searched_state) → size_t[source]
Parameters

  • searched_state (StateTwo const &) –

  • getStateIndex(self –

  • -> VectorSizeT (searched_states)) –

  • searched_states (std::vector< StateTwo,std::allocator< StateTwo > > const &) –

getStates(self) → VectorStateTwo[source]
getStatesMultiIndex(self) → states_set< StateTwo >::type const &[source]
restrictEnergy(self, e_min, e_max)[source]
Parameters

  • e_min (double) –

  • e_max (double) –

restrictJ(self, j_min, j_max)[source]
Parameters

  • j_min (float) –

  • j_max (float) –

  • restrictJ(self –

  • j) –

  • j (std::set< float,std::less< float >,std::allocator< float > >) –

restrictL(self, l_min, l_max)[source]
Parameters

  • l_min (int) –

  • l_max (int) –

  • restrictL(self –

  • l) –

  • l (std::set< int,std::less< int >,std::allocator< int > >) –

restrictM(self, m_min, m_max)[source]
Parameters

  • m_min (float) –

  • m_max (float) –

  • restrictM(self –

  • m) –

  • m (std::set< float,std::less< float >,std::allocator< float > >) –

restrictN(self, n_min, n_max)[source]
Parameters

  • n_min (int) –

  • n_max (int) –

  • restrictN(self –

  • n) –

  • n (std::set< int,std::less< int >,std::allocator< int > >) –

rotate(self, to_z_axis, to_y_axis)[source]
Parameters

  • to_z_axis (std::array< double,3 >) –

  • to_y_axis (std::array< double,3 >) –

  • rotate(self –

  • alpha (double) –

  • beta (double) –

  • gamma) –

  • alpha –

  • beta –

  • gamma (double) –

setHamiltonianEntry(self, state_row, state_col, value)[source]
Parameters

  • state_row (StateTwo const &) –

  • state_col (StateTwo const &) –

  • value (std::complex< double >) –

setMinimalNorm(self, threshold)[source]
Parameters

threshold (double const &) –

property thisown

The membership flag

unitarize(self)[source]
class pairinteraction.binding._SystemStateTwoReal(*args, **kwargs)[source]

Bases: object

Proxy of C++ SystemBase< double,StateTwo > class.

add(self, system)[source]
Parameters

system (SystemBase< double,StateTwo > &) –

addHamiltonianEntry(self, state_row, state_col, value)[source]
Parameters

  • state_row (StateTwo const &) –

  • state_col (StateTwo const &) –

  • value (double) –

addStates(self, s)[source]
Parameters

  • s (std::set< StateTwo,std::less< StateTwo >,std::allocator< StateTwo > > const &) –

  • addStates(self –

  • s) –

  • s –

applySchriefferWolffTransformation(self, system0)[source]
Parameters

system0 (SystemBase< double,StateTwo > &) –

buildBasis(self)[source]
buildHamiltonian(self)[source]
buildInteraction(self)[source]
canonicalize(self)[source]
constrainBasisvectors(self, indices_of_wanted_basisvectors)[source]
Parameters

indices_of_wanted_basisvectors (std::vector< size_t,std::allocator< size_t > >) –

diagonalize(self, energy_lower_bound, energy_upper_bound)[source]
Parameters

  • energy_lower_bound (double) –

  • energy_upper_bound (double) –

  • diagonalize(self –

  • energy_lower_bound –

  • energy_upper_bound –

  • threshold) –

  • energy_lower_bound –

  • energy_upper_bound –

  • threshold (double) –

  • diagonalize(self) –

  • diagonalize(self –

  • threshold) –

  • threshold –

forgetStatemixing(self)[source]
getBasisvectorIndex(self, searched_state) → size_t[source]
Parameters

  • searched_state (StateTwo const &) –

  • getBasisvectorIndex(self –

  • -> VectorSizeT (searched_states)) –

  • searched_states (std::vector< StateTwo,std::allocator< StateTwo > > const &) –

getBasisvectors(self) → Eigen::SparseMatrix< double > &[source]
getConnections(self, system_to, threshold) → ArrayVectorSizeTTwo[source]
Parameters

  • system_to (SystemBase< double,StateTwo > &) –

  • threshold (double) –

getHamiltonian(self) → Eigen::SparseMatrix< double > &[source]
getHamiltonianEntry(self, state_row, state_col) → double[source]
Parameters

  • state_row (StateTwo const &) –

  • state_col (StateTwo const &) –

getMainStates(self) → VectorStateTwo[source]
getNumBasisvectors(self) → size_t[source]
getNumStates(self) → size_t[source]
getOverlap(self, generalizedstate) → Eigen::VectorX< double >[source]
Parameters

  • generalizedstate (StateTwo const &) –

  • getOverlap(self –

  • -> Eigen::VectorX< double > (gamma)) –

  • generalizedstates (std::vector< StateTwo,std::allocator< StateTwo > > const &) –

  • getOverlap(self –

  • -> Eigen::VectorX< double > –

  • state_index (size_t const &) –

  • getOverlap(self –

  • -> Eigen::VectorX< double > –

  • states_indices (std::vector< size_t,std::allocator< size_t > > const &) –

  • getOverlap(self –

  • generalizedstate –

  • to_z_axis (std::array< double,3 >) –

  • -> Eigen::VectorX< double > –

  • generalizedstate –

  • to_z_axis –

  • to_y_axis (std::array< double,3 >) –

  • getOverlap(self –

  • generalizedstates –

  • to_z_axis –

  • -> Eigen::VectorX< double > –

  • generalizedstates –

  • to_z_axis –

  • to_y_axis –

  • getOverlap(self –

  • state_index –

  • to_z_axis –

  • -> Eigen::VectorX< double > –

  • state_index –

  • to_z_axis –

  • to_y_axis –

  • getOverlap(self –

  • states_indices –

  • to_z_axis –

  • -> Eigen::VectorX< double > –

  • states_indices –

  • to_z_axis –

  • to_y_axis –

  • getOverlap(self –

  • generalizedstate –

  • alpha (double) –

  • beta (double) –

  • -> Eigen::VectorX< double > –

  • generalizedstate –

  • alpha –

  • beta –

  • gamma (double) –

  • getOverlap(self –

  • state_index –

  • alpha –

  • beta –

  • -> Eigen::VectorX< double > –

  • state_index –

  • alpha –

  • beta –

  • gamma –

  • getOverlap(self –

  • generalizedstates –

  • alpha –

  • beta –

  • -> Eigen::VectorX< double > –

  • generalizedstates –

  • alpha –

  • beta –

  • gamma –

  • getOverlap(self –

  • states_indices –

  • alpha –

  • beta –

  • -> Eigen::VectorX< double > –

  • states_indices –

  • alpha –

  • beta –

  • gamma –

getStateIndex(self, searched_state) → size_t[source]
Parameters

  • searched_state (StateTwo const &) –

  • getStateIndex(self –

  • -> VectorSizeT (searched_states)) –

  • searched_states (std::vector< StateTwo,std::allocator< StateTwo > > const &) –

getStates(self) → VectorStateTwo[source]
getStatesMultiIndex(self) → states_set< StateTwo >::type const &[source]
restrictEnergy(self, e_min, e_max)[source]
Parameters

  • e_min (double) –

  • e_max (double) –

restrictJ(self, j_min, j_max)[source]
Parameters

  • j_min (float) –

  • j_max (float) –

  • restrictJ(self –

  • j) –

  • j (std::set< float,std::less< float >,std::allocator< float > >) –

restrictL(self, l_min, l_max)[source]
Parameters

  • l_min (int) –

  • l_max (int) –

  • restrictL(self –

  • l) –

  • l (std::set< int,std::less< int >,std::allocator< int > >) –

restrictM(self, m_min, m_max)[source]
Parameters

  • m_min (float) –

  • m_max (float) –

  • restrictM(self –

  • m) –

  • m (std::set< float,std::less< float >,std::allocator< float > >) –

restrictN(self, n_min, n_max)[source]
Parameters

  • n_min (int) –

  • n_max (int) –

  • restrictN(self –

  • n) –

  • n (std::set< int,std::less< int >,std::allocator< int > >) –

rotate(self, to_z_axis, to_y_axis)[source]
Parameters

  • to_z_axis (std::array< double,3 >) –

  • to_y_axis (std::array< double,3 >) –

  • rotate(self –

  • alpha (double) –

  • beta (double) –

  • gamma) –

  • alpha –

  • beta –

  • gamma (double) –

setHamiltonianEntry(self, state_row, state_col, value)[source]
Parameters

  • state_row (StateTwo const &) –

  • state_col (StateTwo const &) –

  • value (double) –

setMinimalNorm(self, threshold)[source]
Parameters

threshold (double const &) –

property thisown

The membership flag

unitarize(self)[source]
pairinteraction.binding._swig_add_metaclass(metaclass)[source]

Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass

pairinteraction.binding.computeComplex(config_name, output_name) → int[source]
Parameters

  • config_name (std::string const &) –

  • output_name (std::string const &) –

pairinteraction.binding.computeReal(config_name, output_name) → int[source]
Parameters

  • config_name (std::string const &) –

  • output_name (std::string const &) –

pairinteraction.binding.energy_level(species, n, l, j, database='') → double[source]
Parameters

  • species (std::string const &) –

  • n (int) –

  • l (int) –

  • j (double) –

  • database (std::string const &) –

pairinteraction.binding.g(qd, x) → double[source]
Parameters

  • qd (QuantumDefect const &) –

  • x (double) –

pairinteraction.binding.nstar(species, n, l, j, database='') → double[source]
Parameters

  • species (std::string const &) –

  • n (int) –

  • l (int) –

  • j (double) –

  • database (std::string const &) –

pairinteraction.binding.selectionRulesMomentumNew(state1, state2, q) → bool[source]
Parameters

  • state1 (StateOne const &) –

  • state2 (StateOne const &) –

  • q (int) –

  • selectionRulesMomentumNew(state1 –

  • -> bool (state2)) –

  • state1 –

  • state2 –

pairinteraction.binding.selectionRulesMultipoleNew(state1, state2, kappa, q) → bool[source]
Parameters

  • state1 (StateOne const &) –

  • state2 (StateOne const &) –

  • kappa (int) –

  • q (int) –

  • selectionRulesMultipoleNew(state1 –

  • state2 –

  • -> bool (kappa)) –

  • state1 –

  • state2 –

  • kappa –