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)[source]
class pairinteraction.binding.MatrixElementCache(self, cachedir) → MatrixElementCache

Bases: object

Parameters:

cachedir (std::string const &)

__setstate_internal(self, sState)
Parameters:

sState (PyObject *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)[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

class pairinteraction.binding.PerturbativeInteraction(self, cache)[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 &)

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

  • 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)[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)[source]
class pairinteraction.binding.StateOne(self, species, n, l, j, m) → StateOne

Bases: object

Parameters:

  • species (std::string)

  • n (int)

  • l (int)

  • j (float)

  • m (float)

  • __init__(self

  • StateOne (label) ->)

  • label (std::string)

__setstate_internal(self, sState)
Parameters:

sState (PyObject *const)

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)[source]
class pairinteraction.binding.StateTwo(self, species, n, l, j, m) → StateTwo

Bases: object

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)

__setstate_internal(self, sState)
Parameters:

sState (PyObject *const)

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)[source]

Bases: object

property inversion
property permutation
property reflection
property rotation
property thisown

The membership flag

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

Bases: _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 &)

__setstate_internal(self, sState)
Parameters:

sState (PyObject *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

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

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

  • getOverlap(self

  • >

  • state_index (size_t const &)

  • getOverlap(self

  • >

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

  • getOverlap(self

  • generalizedstate

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

  • >

  • generalizedstate

  • to_z_axis

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

  • getOverlap(self

  • generalizedstates

  • to_z_axis

  • >

  • generalizedstates

  • to_z_axis

  • to_y_axis

  • getOverlap(self

  • state_index

  • to_z_axis

  • >

  • state_index

  • to_z_axis

  • to_y_axis

  • getOverlap(self

  • states_indices

  • to_z_axis

  • >

  • states_indices

  • to_z_axis

  • to_y_axis

  • getOverlap(self

  • generalizedstate

  • alpha (double)

  • beta (double)

  • >

  • generalizedstate

  • alpha

  • beta

  • gamma (double)

  • getOverlap(self

  • state_index

  • alpha

  • beta

  • >

  • state_index

  • alpha

  • beta

  • gamma

  • getOverlap(self

  • generalizedstates

  • alpha

  • beta

  • >

  • generalizedstates

  • alpha

  • beta

  • gamma

  • getOverlap(self

  • states_indices

  • alpha

  • beta

  • >

  • 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)[source]

Bases: _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 &)

__setstate_internal(self, sState)
Parameters:

sState (PyObject *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

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

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

  • getOverlap(self

  • >

  • state_index (size_t const &)

  • getOverlap(self

  • >

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

  • getOverlap(self

  • generalizedstate

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

  • >

  • generalizedstate

  • to_z_axis

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

  • getOverlap(self

  • generalizedstates

  • to_z_axis

  • >

  • generalizedstates

  • to_z_axis

  • to_y_axis

  • getOverlap(self

  • state_index

  • to_z_axis

  • >

  • state_index

  • to_z_axis

  • to_y_axis

  • getOverlap(self

  • states_indices

  • to_z_axis

  • >

  • states_indices

  • to_z_axis

  • to_y_axis

  • getOverlap(self

  • generalizedstate

  • alpha (double)

  • beta (double)

  • >

  • generalizedstate

  • alpha

  • beta

  • gamma (double)

  • getOverlap(self

  • state_index

  • alpha

  • beta

  • >

  • state_index

  • alpha

  • beta

  • gamma

  • getOverlap(self

  • generalizedstates

  • alpha

  • beta

  • >

  • generalizedstates

  • alpha

  • beta

  • gamma

  • getOverlap(self

  • states_indices

  • alpha

  • beta

  • >

  • 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)[source]

Bases: _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 &)

__setstate_internal(self, sState)
Parameters:

sState (PyObject *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

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

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

  • getOverlap(self

  • >

  • state_index (size_t const &)

  • getOverlap(self

  • >

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

  • getOverlap(self

  • generalizedstate

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

  • >

  • generalizedstate

  • to_z_axis

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

  • getOverlap(self

  • generalizedstates

  • to_z_axis

  • >

  • generalizedstates

  • to_z_axis

  • to_y_axis

  • getOverlap(self

  • state_index

  • to_z_axis

  • >

  • state_index

  • to_z_axis

  • to_y_axis

  • getOverlap(self

  • states_indices

  • to_z_axis

  • >

  • states_indices

  • to_z_axis

  • to_y_axis

  • getOverlap(self

  • generalizedstate

  • alpha (double)

  • beta (double)

  • >

  • generalizedstate

  • alpha

  • beta

  • gamma (double)

  • getOverlap(self

  • state_index

  • alpha

  • beta

  • >

  • state_index

  • alpha

  • beta

  • gamma

  • getOverlap(self

  • generalizedstates

  • alpha

  • beta

  • >

  • generalizedstates

  • alpha

  • beta

  • gamma

  • getOverlap(self

  • states_indices

  • alpha

  • beta

  • >

  • 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)[source]

Bases: _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 &)

__setstate_internal(self, sState)
Parameters:

sState (PyObject *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

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

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

  • getOverlap(self

  • >

  • state_index (size_t const &)

  • getOverlap(self

  • >

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

  • getOverlap(self

  • generalizedstate

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

  • >

  • generalizedstate

  • to_z_axis

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

  • getOverlap(self

  • generalizedstates

  • to_z_axis

  • >

  • generalizedstates

  • to_z_axis

  • to_y_axis

  • getOverlap(self

  • state_index

  • to_z_axis

  • >

  • state_index

  • to_z_axis

  • to_y_axis

  • getOverlap(self

  • states_indices

  • to_z_axis

  • >

  • states_indices

  • to_z_axis

  • to_y_axis

  • getOverlap(self

  • generalizedstate

  • alpha (double)

  • beta (double)

  • >

  • generalizedstate

  • alpha

  • beta

  • gamma (double)

  • getOverlap(self

  • state_index

  • alpha

  • beta

  • >

  • state_index

  • alpha

  • beta

  • gamma

  • getOverlap(self

  • generalizedstates

  • alpha

  • beta

  • >

  • generalizedstates

  • alpha

  • beta

  • gamma

  • getOverlap(self

  • states_indices

  • alpha

  • beta

  • >

  • 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)[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)

class pairinteraction.binding.WignerD(self)[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

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

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

  • getOverlap(self

  • >

  • state_index (size_t const &)

  • getOverlap(self

  • >

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

  • getOverlap(self

  • generalizedstate

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

  • >

  • generalizedstate

  • to_z_axis

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

  • getOverlap(self

  • generalizedstates

  • to_z_axis

  • >

  • generalizedstates

  • to_z_axis

  • to_y_axis

  • getOverlap(self

  • state_index

  • to_z_axis

  • >

  • state_index

  • to_z_axis

  • to_y_axis

  • getOverlap(self

  • states_indices

  • to_z_axis

  • >

  • states_indices

  • to_z_axis

  • to_y_axis

  • getOverlap(self

  • generalizedstate

  • alpha (double)

  • beta (double)

  • >

  • generalizedstate

  • alpha

  • beta

  • gamma (double)

  • getOverlap(self

  • state_index

  • alpha

  • beta

  • >

  • state_index

  • alpha

  • beta

  • gamma

  • getOverlap(self

  • generalizedstates

  • alpha

  • beta

  • >

  • generalizedstates

  • alpha

  • beta

  • gamma

  • getOverlap(self

  • states_indices

  • alpha

  • beta

  • >

  • 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

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

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

  • getOverlap(self

  • >

  • state_index (size_t const &)

  • getOverlap(self

  • >

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

  • getOverlap(self

  • generalizedstate

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

  • >

  • generalizedstate

  • to_z_axis

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

  • getOverlap(self

  • generalizedstates

  • to_z_axis

  • >

  • generalizedstates

  • to_z_axis

  • to_y_axis

  • getOverlap(self

  • state_index

  • to_z_axis

  • >

  • state_index

  • to_z_axis

  • to_y_axis

  • getOverlap(self

  • states_indices

  • to_z_axis

  • >

  • states_indices

  • to_z_axis

  • to_y_axis

  • getOverlap(self

  • generalizedstate

  • alpha (double)

  • beta (double)

  • >

  • generalizedstate

  • alpha

  • beta

  • gamma (double)

  • getOverlap(self

  • state_index

  • alpha

  • beta

  • >

  • state_index

  • alpha

  • beta

  • gamma

  • getOverlap(self

  • generalizedstates

  • alpha

  • beta

  • >

  • generalizedstates

  • alpha

  • beta

  • gamma

  • getOverlap(self

  • states_indices

  • alpha

  • beta

  • >

  • 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

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

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

  • getOverlap(self

  • >

  • state_index (size_t const &)

  • getOverlap(self

  • >

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

  • getOverlap(self

  • generalizedstate

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

  • >

  • generalizedstate

  • to_z_axis

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

  • getOverlap(self

  • generalizedstates

  • to_z_axis

  • >

  • generalizedstates

  • to_z_axis

  • to_y_axis

  • getOverlap(self

  • state_index

  • to_z_axis

  • >

  • state_index

  • to_z_axis

  • to_y_axis

  • getOverlap(self

  • states_indices

  • to_z_axis

  • >

  • states_indices

  • to_z_axis

  • to_y_axis

  • getOverlap(self

  • generalizedstate

  • alpha (double)

  • beta (double)

  • >

  • generalizedstate

  • alpha

  • beta

  • gamma (double)

  • getOverlap(self

  • state_index

  • alpha

  • beta

  • >

  • state_index

  • alpha

  • beta

  • gamma

  • getOverlap(self

  • generalizedstates

  • alpha

  • beta

  • >

  • generalizedstates

  • alpha

  • beta

  • gamma

  • getOverlap(self

  • states_indices

  • alpha

  • beta

  • >

  • 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

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

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

  • getOverlap(self

  • >

  • state_index (size_t const &)

  • getOverlap(self

  • >

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

  • getOverlap(self

  • generalizedstate

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

  • >

  • generalizedstate

  • to_z_axis

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

  • getOverlap(self

  • generalizedstates

  • to_z_axis

  • >

  • generalizedstates

  • to_z_axis

  • to_y_axis

  • getOverlap(self

  • state_index

  • to_z_axis

  • >

  • state_index

  • to_z_axis

  • to_y_axis

  • getOverlap(self

  • states_indices

  • to_z_axis

  • >

  • states_indices

  • to_z_axis

  • to_y_axis

  • getOverlap(self

  • generalizedstate

  • alpha (double)

  • beta (double)

  • >

  • generalizedstate

  • alpha

  • beta

  • gamma (double)

  • getOverlap(self

  • state_index

  • alpha

  • beta

  • >

  • state_index

  • alpha

  • beta

  • gamma

  • getOverlap(self

  • generalizedstates

  • alpha

  • beta

  • >

  • generalizedstates

  • alpha

  • beta

  • gamma

  • getOverlap(self

  • states_indices

  • alpha

  • beta

  • >

  • 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