def energy_derivative(self, n_elec, order=1):
# check n_elec argument
check_number_electrons(n_elec, self._n0 - 1, self._n0 + 1)
# check order
if not (isinstance(order, int) and order > 0):
raise ValueError(
"Argument order should be an integer greater than or equal to 1."
)
# Evaluate Derivative
if order == 1:
if n_elec == np.inf:
# The limit as N goes to infinity on the first order derivative is a2
return self._params[2]
deriv_value = self._params[2] + self._params[1] / (2. *
np.sqrt(n_elec))
else:
if n_elec == np.inf:
# Limit as N goes to infinity on the higher order derivative is zero
return 0
coefficient_factor = np.prod(2. * np.arange(1, order) -
1) * self._params[1]
coefficient_factor /= (2.**order * (-1)**(order - 1))
deriv_value = coefficient_factor * n_elec**(
-(order - 1)) * np.sqrt(n_elec**(-1))
return deriv_value
def energy(self, n_elec):
# check n_elec argument
check_number_electrons(n_elec, self._n0 - 1, self._n0 + 1)
# evaluate energy
value = self._params[
0] + self._params[1] * n_elec + self._params[2] * n_elec**2
return value
def population(self, n_elec):
# check n_elec argument
check_number_electrons(n_elec, self._n0 - 1, self._n0 + 1)
# compute density
pop = self.dict_population[self.n_ref].copy()
pop += self._ff0 * (n_elec - self._n0) + 0.5 * self._df0 * (
n_elec - self._n0)**2
return pop
def density(self, n_elec):
# check n_elec argument
check_number_electrons(n_elec, self._n0 - 1, self._n0 + 1)
# compute density
rho = self.dict_density[self.n0].copy()
rho += self._ff0 * (n_elec - self._n0) + 0.5 * self._df0 * (
n_elec - self._n0)**2
return rho
def energy(self, n_elec):
# check n_elec argument
check_number_electrons(n_elec, self._n0 - 1, self._n0 + 1)
# compute the change in the number of electrons w.r.t. N0
delta_n = n_elec - self._n0
# compute energy
result = self._params[0] + self._params[1] * delta_n + self._params[2] * delta_n ** 2
result += self._params[3] * delta_n ** 3.
return result
def energy(self, n_elec):
# check n_elec argument
check_number_electrons(n_elec, self._n0 - 1, self._n0 + 1)
# evaluate energy
if n_elec <= self._n0:
value = self._params[0] + n_elec * self._params[1]
else:
value = self._params[2] + n_elec * self._params[3]
return value
def density(self, n_elec):
# check n_elec argument
check_number_electrons(n_elec, self._n0 - 1, self._n0 + 1)
# compute density
rho = self.dict_density[self._n0].copy()
if n_elec < self._n0:
rho += self._ff_minus * (n_elec - self._n0)
elif n_elec > self._n0:
rho += self._ff_plus * (n_elec - self._n0)
return rho
def population(self, n_elec):
# check n_elec argument
check_number_electrons(n_elec, self._n0 - 1, self._n0 + 1)
# compute atomic populations
pop = self.dict_population[self._n0].copy()
if n_elec < self._n0:
pop += self._ff_minus * (n_elec - self._n0)
elif n_elec > self._n0:
pop += self._ff_plus * (n_elec - self._n0)
return pop
def energy(self, n_elec):
# check n_elec argument
check_number_electrons(n_elec, self._n0 - 1, self._n0 + 1)
# evaluate energy
if np.isinf(n_elec):
# limit of E(N) as N goes to infinity equals a1/b1
value = self._params[1] / self._params[2]
else:
value = (self._params[0] +
self._params[1] * n_elec) / (1 + self._params[2] * n_elec)
return value
def energy(self, n_elec):
# check n_elec argument
check_number_electrons(n_elec, self._n0 - 1, self._n0 + 1)
# Square Root Model goes to infinity as N goes to infinity.
output = self._params[0] + self._params[1] * np.sqrt(n_elec) + self._params[2] * n_elec
if np.isinf(n_elec):
if self.params[2] > 0.:
output = np.inf
else:
output = -np.inf
return output
def energy(self, n_elec):
# check n_elec argument
check_number_electrons(n_elec, self._n0 - 1, self._n0 + 1)
# evaluate energy
if np.isinf(n_elec):
# limit of E(N) as N goes to infinity equals B
value = self._params[2]
else:
dn = n_elec - self._n0
value = self._params[0] * math.exp(
-self._params[1] * dn) + self._params[2]
return value
def energy_derivative(self, n_elec, order=1):
# check n_elec argument
check_number_electrons(n_elec, self._n_min, self._n_max)
# check order
if not (isinstance(order, int) and order > 0):
raise ValueError(
"Argument order should be an integer greater than or equal to 1."
)
# obtain derivative expression
deriv = self._expr.diff(self._n_symb, order)
# evaluate derivative expression at n_elec
deriv = deriv.subs(self._n_symb, n_elec)
return deriv
def population_derivative(self, n_elec, order=1):
# check n_elec argument
check_number_electrons(n_elec, self._n0 - 1, self._n0 + 1)
# check order
if not (isinstance(order, int) and order > 0):
raise ValueError(
"Argument order should be an integer greater than or equal to 1."
)
if order == 1:
deriv = self._ff0 + self._df0 * (n_elec - self.n_ref)
elif order == 2:
deriv = self._df0
else:
deriv = 0.
return deriv
def energy_derivative(self, n_elec, order=1):
# check n_elec argument
check_number_electrons(n_elec, self._n0 - 1, self._n0 + 1)
# check order
if not (isinstance(order, int) and order > 0):
raise ValueError(
"Argument order should be an integer greater than or equal to 1."
)
# evaluate derivative
if order == 1:
deriv = self._params[1] + 2 * n_elec * self._params[2]
elif order == 2:
deriv = 2 * self._params[2]
else:
deriv = 0.
return deriv
def energy_derivative(self, n_elec, order=1):
# check n_elec argument
check_number_electrons(n_elec, self.n0 - 1., self.n0 + 1.)
# check order
if not (isinstance(order, int) and order > 0):
raise ValueError(
"Argument order should be an integer greater than or equal to 1."
)
deriv = 0
# Evaluate the derivative of each term of the energy model, evaluated at n_elec.
for term in range(order, self._nth_order + 1):
diff = term - order
deriv += n_elec**diff * self._params[term] * factorial(
term) / factorial(diff)
return deriv
def energy_derivative(self, n_elec, order=1):
# check n_elec argument
check_number_electrons(n_elec, self._n0 - 1, self._n0 + 1)
# check order
if not (isinstance(order, int) and order > 0):
raise ValueError(
"Argument order should be an integer greater than or equal to 1."
)
# evaluate derivative
if np.isinf(n_elec):
# limit of E(N) derivatives as N goes to infinity equals zero
deriv = 0.0
else:
dn = n_elec - self._n0
deriv = self._params[0] * (-self._params[1])**order * math.exp(
-self._params[1] * dn)
return deriv
def energy_derivative(self, n_elec, order=1):
# check n_elec argument
check_number_electrons(n_elec, self._n0 - 1, self._n0 + 1)
# check order
if not (isinstance(order, int) and order > 0):
raise ValueError(
"Argument order should be an integer greater than or equal to 1."
)
# evaluate derivative
if np.isinf(n_elec):
# limit of E(N) derivatives as N goes to infinity equals zero
deriv = 0.0
else:
deriv = (-self._params[2])**(order - 1)
deriv *= (self._params[1] - self._params[0] *
self._params[2]) * math.factorial(order)
deriv /= (1 + self._params[2] * n_elec)**(order + 1)
return deriv
def energy_derivative(self, n_elec, order=1):
# check n_elec argument
check_number_electrons(n_elec, self._n0 - 1, self._n0 + 1)
# check order
if not (isinstance(order, int) and order > 0):
raise ValueError("Argument order should be an integer greater than or equal to 1.")
# compute the change in the number of electrons w.r.t. N0
delta_n = n_elec - self._n0
# compute derivative of energy
if order == 1:
result = self._params[1] + 2. * self._params[2] * delta_n + \
3. * self._params[3] * delta_n ** 2.
elif order == 2:
result = 2. * self._params[2] + 6. * self._params[3] * delta_n
elif order == 3:
result = 6. * self._params[3]
else:
result = 0
return result
def population_derivative(self, n_elec, order=1):
# check n_elec argument
check_number_electrons(n_elec, self._n0 - 1, self._n0 + 1)
# check order
if not (isinstance(order, int) and order > 0):
raise ValueError(
"Argument order should be an integer greater than or equal to 1."
)
# compute derivative of atomic populations w.r.t. number of electrons
if order == 1:
if n_elec < self._n0:
deriv = self._ff_minus
elif n_elec > self._n0:
deriv = self._ff_plus
else:
deriv = self._ff_zero
else:
if n_elec == self._n0:
deriv = None
else:
deriv = 0.
return deriv
def energy(self, n_elec):
# check n_elec argument
check_number_electrons(n_elec, self._n_min, self._n_max)
# evaluate energy
value = self._expr.subs(self._n_symb, n_elec)
return value
