def _norm_coeff(self, n1, l1, n2, l2):
""" Also extracted from Apendix D.1 of the thesis,
factor (1 / 2*pi^3) extracted."""
aux = fact(n1) + gamma_half_int(2*(n1 + l1) + 3)
aux += fact(n2) + gamma_half_int(2*(n2 + l2) + 3)
return np.exp(0.5 * aux)
def __sum_aux_denominator(self, n1, l1, n2, l2, p, k):
denominator = sum(
[fact(k), fact(n1 - k), fact(p - k), fact(n2 + k - p),
gamma_half_int(2*(k + l1) + 3),
gamma_half_int(2*(p - k + l2) + 3)] ## double factorial (n - 1)
)
return np.exp(denominator)
def _phiWF(self, n, l, r):
aux = 0.0 * r
for p in range(0, n + 1):
den = fact(p) + fact(n - p) + gamma_half_int(2 * (p + l) + 3)
aux += ((-1)**p) * (r**(2 * p + l)) / np.exp(den)
N = np.exp(0.5 * (fact(n) + gamma_half_int(2 *
(n + l) + 3) + np.log(2)))
return aux * N
def test_sumDiagonalB_coeffs(self):
""" If we integrate any sho function norm it must return 1
integral(|phi_(n,l)|^2) = c^2 sum B(nl,nl,p) Gamma(p + l + 3/2)/2
integral(r^2 * exp(-r/b^2) * r^(2(p + l))) = Gamma(p+l+3/2) / 2
"""
N_max = 8
Integrals_ = _RadialTwoBodyDecoupled()
print("\n==== TEST NORM SHO FUNCTION DECOUPLED B COEFFS ====\n")
for N in range(N_max + 1):
print("N =", N)
for n in range(N // 2 + 1):
l = N - 2 * n
aux = 0.0
for p in range(2 * n + 1):
B0 = Integrals_._B_coeff(n, l, n, l, p)
integ = np.exp(gamma_half_int(2 * (p + l) + 3)) / 2
aux += B0 * integ
print("\t* integral(|phi(n,l)=(", n, l, ")|^2) =", aux)
self.assertAlmostEqual(
1,
aux,
delta=1e-9,
msg="\nnorm of the function in terms of B decoupled "
"is not 1.0 for (n,l)={}".format((n, l)))
def _aCoeff_nlk(self, n, l, k):
"""
Access to the memorization object of the coefficient for the radial
Coefficient for the radial function evaluation in series.
Returns without the 1/sqrt(b^3) normalization factor,
"""
key_ = '({},{},{})'.format(n, l, k)
if key_ not in self._a_coeff_nkl_memo:
aux = 0.5*(fact(n) - gamma_half_int(2*(n+l+1))) # + 3*np.log(self.b_param)
aux += gamma_half_int(2*(n+l+1)) - (fact(n) + fact(n-k)
+ gamma_half_int(2*(k+l+1)))
self._a_coeff_nkl_memo[key_] = (-1)**k * np.exp(aux)
return self._a_coeff_nkl_memo.get(key_)
def _sho_series_coeff(sp_state, k):
""" return logarithmic value. (insert the -1^k phase from outside) """
n, l = sp_state.n, sp_state.l
# Suhonen_
#aux = ((fact(n) + gamma_half_int(2*(n + l) + 3))
# - (fact(k) + fact(n-k) + gamma_half_int(2*(k + l) + 3)))
# Moshinsky_ or Llarena_
aux = fact(k) + fact(n - k) + gamma_half_int(2*(k + l) + 3)
return _norm_sho(n, l) - aux #gamma_half_int(2*(n + l) + 3)
def _norm_sho(n, l):
""" return logarithmic value (increase precission for very large n values) """
#n, l = sp_state.n, sp_state.l
# Suhonen_
#aux = fact(n) - gamma_half_int(2*(n + l) + 3)
#return np.sqrt(2 * np.exp(aux) / ((np.pi**0.5) * b_length**3))
# Moshinsky_ or Llarena_
aux = fact(n) + gamma_half_int(2*(n + l) + 3)
#return 0.5 * (np.log(2 / (b_length**3)) + aux)
return 0.5 * (np.log(2) + aux)
def _baseIntegral(self, K):
"""
Access to the memorization object of the base integral
integral for Gogny: (r/b_param)^K * V(r)* exp(-2*(r/b)^2)
"""
# TODO: Extend for different self.PARAMS_FORCE
if K not in self._baseIntegrals_memo:
b = self.b_param
integral_ = (0.5/(b**3)) * np.exp(gamma_half_int(2*K+3))\
* talmiIntegral(K, PotentialForms.Gaussian, b, b)
self._baseIntegral_memo[K] = integral_
return self._baseIntegral_memo.get(K)
def _testNormalizationSingleRadialFunction(n, l, b_length=1):
sp_state = QN_1body_radial(n, l)
N_coeff2 = fact(n) + gamma_half_int(2*(n+l)+3)# / np.sqrt(np.pi)
#N_coeff_mine = _norm_sho(sp_state, b_length)
sum_ = 0.
sum_mine = 0.
for k1 in range(n +1):
aux1 = -(fact(k1) + fact(n-k1) + gamma_half_int(2*(k1+l)+3))
aux1_mine = _sho_series_coeff(sp_state, k1)
for k2 in range(n +1):
aux2 = -(fact(k2) + fact(n-k2) + gamma_half_int(2*(k2+l)+3))
aux2_mine = _sho_series_coeff(sp_state, k2)
aux = np.exp(N_coeff2 + aux1 + aux2 + gamma_half_int(2*(k1+k2+l) + 3))
aux_mine = np.exp(aux1_mine + aux2_mine + gamma_half_int(2*(k1+k2+l) + 3))
sum_ += aux * ((-1)**(k1 + k2))
sum_mine += 0.5 * aux_mine * ((-1)**(k1 + k2))
return sum_, sum_mine
def _r_dependentIntegral(self, No2):
""" Integral r^2*No2 exp(-r^2), b lengths extracted (b**6)
:No2 stands for N over 2, being N = 2*(p+p') + sum{l} (+2 opt.)"""
# l1 + l2 + l1_q + l2_q is even
return np.exp(gamma_half_int(2*No2 + 1) - ((No2 + 1.5)*np.log(2)))
def talmiIntegral(p, potential, b_param, mu_param, n_power=0, **kwargs):
"""
:p index order
:potential form of the potential, from Poten
:b_param SHO length parameter
:mu_param force proportional coefficient (by interaction definition)
:n_power auxiliary parameter for power dependent potentials
"""
if potential == PotentialForms.Gaussian:
return (b_param**3) / (1 + 2*(b_param/mu_param)**2)**(p+1.5)
elif potential == PotentialForms.Coulomb:
return (b_param**2) * np.exp(fact(p) - gamma_half_int(2*p + 3)) / (2**.5)
elif potential == PotentialForms.Gaussian_power:
aux = gamma_half_int(2*p + 3 - n_power) - gamma_half_int(2*p + 3)
aux = (b_param**3) * np.exp(aux)
x = (2**0.5) * b_param / mu_param
return aux / ((x**n_power) * ((1 + x**2)**(p + 1.5 - (n_power/2))))
elif potential == PotentialForms.Power:
if n_power == 0:
return b_param**3
aux = gamma_half_int(2*p + 3 + n_power) - gamma_half_int(2*p + 3)
aux += n_power * ((np.log(2)/2) - np.log(mu_param))
return np.exp(aux + ((n_power + 3)*np.log(b_param)))
elif potential == PotentialForms.Yukawa:
sum_ = 0.
cte_k = b_param / ((2**0.5) * mu_param)
cte_k_log = np.log(cte_k)
for k in range(0, 2*p + 1 +1):
aux = fact(2*p + 1) - fact(k) - fact(2*p + 1 - k)
aux += (2*p + 1 - k) * cte_k_log
aux += gamma_half_int(k + 1) ## normalization of gammaincc_
aux = np.exp(aux)
sum_ += (-1)**(2*p + 1 - k) * aux * gammaincc((k + 1)/2, cte_k**2)
#sum_ *= mu_param * (b_param**2) / np.exp(0.5 * ((b_param/mu_param)**2))
sum_ *= mu_param * (b_param**2) / np.exp(cte_k**2)
sum_ /= np.exp(gamma_half_int(2*p + 3)) * (2**0.5)
return sum_
elif potential == PotentialForms.Exponential:
sum_ = 0.
cte_k = b_param / ((2**0.5) * mu_param)
cte_k_log = np.log(cte_k)
for k in range(2*p + 2 +1):
aux = fact(2*p + 2) - fact(k) - fact(2*p + 2 - k)
aux += (2*p + 2 - k) * cte_k
aux += gamma_half_int(k + 1) ## normalization of gammaincc_
aux = np.exp(aux)
sum_ += (-1)**(2*p + 2 - k) * aux * gammaincc((k + 1)/2, cte_k**2)
sum_ *= (b_param**3) / np.exp(0.5 * ((b_param/mu_param)**2))
sum_ /= np.exp(gamma_half_int(2*p + 3))
return sum_
else:
raise IntegralException("Talmi integral [{}] is not defined, valid potentials: {}"
.format(potential, PotentialForms.members()))
