def fill_order(self, order):
if self.filled_for_order[order-1]:
return
#----------------------------------------#
tens = self.tensors[order]
if order <= self.max_analytic_order:
#TODO this will need to be significantly modified for hessians and higher, since the transformation to interal coordinates requires all lower derivatives as well...
tens[...] = self.base_molecule.get_property(
PropertyDerivative(self.molecular_property, order) if order > 0 else self.molecular_property,
details=self.displacement_manager.details
).value.in_representation(self.representation)
#----------------------------------------#
else:
for f_coords in symmetric_product(self.representation, order-self.max_analytic_order):
if self.max_analytic_order == 0 or isinstance(self.representation, CartesianRepresentation):
spread_val = FiniteDifferenceDerivative(
self.displacement_manager,
*f_coords,
target_robustness=self.robustness
).value
else:
spread_val = RepresentationDependentTensor(
FiniteDifferenceDerivative(
self.displacement_manager,
*f_coords,
target_robustness=self.robustness
).value,
representation=self.representation.molecule.cartesian_representation
)
spread_val = spread_val.in_representation(self.representation)
for perm in permutations(f_coords):
tens[perm] = spread_val
#----------------------------------------#
self.filled_for_order[order-1] = True
def all_computations(self):
all_comps = set()
for order in xrange(self.max_analytic_order + 1, self.max_order + 1):
for coords in symmetric_product(self.representation,
order - self.max_analytic_order):
fd = FiniteDifferenceDerivative(
self.displacement_manager,
*coords,
target_robustness=self.robustness)
for incs in fd.needed_increments:
increments = [0] * len(self.representation)
for coord, inc in zip(fd.variables, incs):
increments[coord.index] = inc
dmol = self.displacement_manager.displacement_for(
tuple(increments)).displaced_molecule
comp = dmol.get_computation_for_property(
self.computed_property,
self.displacement_manager.details)
if comp not in all_comps:
all_comps.add(comp)
if self.max_analytic_order == 1:
comp = self.base_molecule.get_computation_for_property(
self.computed_property, self.displacement_manager.details)
if comp not in all_comps:
all_comps.add(comp)
elif self.max_analytic_order > 2:
# TODO figure out how many analytic computations need to be done
raise NotImplementedError
return list(all_comps)
def all_computations(self):
all_comps = set()
for order in xrange(self.max_analytic_order+1, self.max_order+1):
for coords in symmetric_product(self.representation, order-self.max_analytic_order):
fd = FiniteDifferenceDerivative(
self.displacement_manager,
*coords,
target_robustness=self.robustness
)
for incs in fd.needed_increments:
increments = [0] * len(self.representation)
for coord, inc in zip(fd.variables, incs):
increments[coord.index] = inc
dmol = self.displacement_manager.displacement_for(tuple(increments)).displaced_molecule
comp = dmol.get_computation_for_property(
self.computed_property,
self.displacement_manager.details
)
if comp not in all_comps:
all_comps.add(comp)
if self.max_analytic_order == 1:
comp = self.base_molecule.get_computation_for_property(
self.computed_property,
self.displacement_manager.details
)
if comp not in all_comps:
all_comps.add(comp)
elif self.max_analytic_order > 2:
# TODO figure out how many analytic computations need to be done
raise NotImplementedError
return list(all_comps)
def finite_difference_b_tensor(
self,
order,
using_order=None,
robustness=None,
forward=False,
use_parent_indices=True):
""" Computes the B tensor for order `order` by finite difference
of B tensors of order `order-1`, taking into account permutational symmetry.
If `use_parent_indices` is `False`, a `Tensor` is returned that is indexed
by the coordinate's internal indices rather than the parent molecule's atom indices.
Otherwise, a `DerivativeTensor` is returned with its `representation` attribute set to the
coordinate's parent molecule's `cartesian_representation` attribute.
"""
if using_order is None:
using_order = order - 1
else:
raise NotImplementedError
robustness = robustness or self.b_tensor_finite_difference_rigor
if use_parent_indices:
ret_val = DerivativeTensor(
representation=self.molecule.cartesian_representation,
shape=(3*self.molecule.natoms,) * order
)
else:
ret_val = Tensor(
shape=(len(self.atoms) * 3,) * order
)
for coords_and_indices in symmetric_product(self.iter_cart_coords(with_index=True), order):
coords, indices = zip(*coords_and_indices)
val_to_spread = self.finite_difference_b_tensor_element(
*coords,
robustness=robustness,
forward=forward
)
if use_parent_indices:
for perm in permutations(indices):
ret_val[tuple(perm)] = val_to_spread
else:
for perm in permutations(coords):
perm_indices = self.internal_indices_for_coordinates(*perm)
ret_val[perm_indices] = val_to_spread
return ret_val
def fill_order(self, order):
if self.filled_for_order[order - 1]:
return
#----------------------------------------#
tens = self.tensors[order]
if order <= self.max_analytic_order:
#TODO this will need to be significantly modified for hessians and higher, since the transformation to interal coordinates requires all lower derivatives as well...
tens[...] = self.base_molecule.get_property(
PropertyDerivative(self.molecular_property, order)
if order > 0 else self.molecular_property,
details=self.displacement_manager.details
).value.in_representation(self.representation)
#----------------------------------------#
else:
for f_coords in symmetric_product(self.representation,
order - self.max_analytic_order):
if self.max_analytic_order == 0 or isinstance(
self.representation, CartesianRepresentation):
spread_val = FiniteDifferenceDerivative(
self.displacement_manager,
*f_coords,
target_robustness=self.robustness).value
else:
spread_val = RepresentationDependentTensor(
FiniteDifferenceDerivative(
self.displacement_manager,
*f_coords,
target_robustness=self.robustness).value,
representation=self.representation.molecule.
cartesian_representation)
spread_val = spread_val.in_representation(
self.representation)
for perm in permutations(f_coords):
tens[perm] = spread_val
#----------------------------------------#
self.filled_for_order[order - 1] = True
def analytic_b_tensor_for_order(self, order):
# First check the cache
cache_key = (self.__class__, order) + tuple(a.pos for a in self.atoms)
cache_resp = SimpleInternalCoordinate._check_b_tensor_cache(*cache_key)
if cache_resp is not None:
return cache_resp
#--------------------------------------------------------------------------------#
B = partial(SimpleInternalCoordinate.b_tensor_element_reindexed, self)
#--------------------------------------------------------------------------------#
# First order is already done elsewhere...
if order == 1:
# We can't use the `b_vector` attribute since that vector is indexed in the parent
# molecule's indexing scheme
my_b = Vector(self.__class__.b_vector_for_positions(*[a.pos for a in self.atoms]))
# Return now, to avoid double-caching
return my_b
#--------------------------------------------------------------------------------#
# TODO Explicit (matrix/tensor based) implementations of 2nd, 3rd, and 4th order to speed things up substantially
else:
# We only have general formulas for terminal atoms as of now...
# So we can save a little bit of time by computing these terms and
# then doing only finite difference for everything else
# Torsions are composed of 4 atoms (3 CartesianCoordinates each),
# so the output will be a 12x12x...x12 (`order`-dimensional) tensor
my_b = np.ndarray(shape=(12,)*order)
if sanity_checking_enabled:
my_b = np.ones(shape=(12,)*order) * float('inf')
# some precomputed values
#========================================#
# Helper function needed for derivative:
def Bsin2phi(phi, *idx_alphas):
# some precomputed values
twophi = 2.0*phi.value*phi.units.to(Radians)
sin2phi = sin(twophi)
cos2phi = cos(twophi)
def h_K(k):
if k % 2 == 1:
if ((k-1) / 2) % 2 == 0:
return cos2phi
else:
return -cos2phi
else: # k is even
if k/2 % 2 == 0:
return sin2phi
else:
return -sin2phi
cumsum = 0.0
n = len(idx_alphas)
for k in xrange(1, n + 1):
inner_sum = 0.0
for s in I_lubar(n, k, idx_alphas):
inner_prod = 1.0
for i in range(k):
inner_prod *= B(phi, *s[i])
inner_sum += inner_prod
cumsum += 2.0**k * h_K(k) * inner_sum
return cumsum
#========================================#
# The aaaa...bbbbb...cccc... terms
phis = []
rbcs = []
for a_idx, a in zip([0, 3], self.terminal_atoms):
# Determine whihc terminal atom we're handling
if a_idx == 0:
b_idx, c_idx, d_idx = 1, 2, 3
else: # a_idx == 3
b_idx, c_idx, d_idx = 2, 1, 0
#----------------------------------------#
phi_abc = self.get_coord(BondAngle,
self.atoms[a_idx],
self.atoms[b_idx],
self.atoms[c_idx],
)
# units of Radians
ang_conv = phi_abc.units.to(Radians)
# TODO figure out what 'units' should be here
rbc = self.get_coord(BondLength, self.atoms[b_idx], self.atoms[c_idx])
# Keep them for later
phis.append(phi_abc)
rbcs.append(rbc)
#----------------------------------------#
# some precomputed values
sin2phi = sin(2.0 * phi_abc.value * ang_conv)
#----------------------------------------#
for num_a, num_b, num_c in unlabeled_balls_in_labeled_boxes(order-1, [order-1]*3):
num_a += 1
alph_iter = product(*map(lambda n: symmetric_product([X,Y,Z], n), (num_a, num_b, num_c)))
for alphas_a, alphas_b, alphas_c in alph_iter:
a_alphas = tuple(3*a_idx + alpha for alpha in alphas_a)
b_alphas = tuple(3*b_idx + alpha for alpha in alphas_b)
c_alphas = tuple(3*c_idx + alpha for alpha in alphas_c)
all_alphas = a_alphas + b_alphas + c_alphas
cum_sum = 0.0
for t1, t2 in I_ll(num_b + num_c, 2, b_alphas + c_alphas):
bphi = LightVector([
B(phi_abc, 3*a_idx + sigma, *(a_alphas[1:] + t1))
for sigma in [X, Y, Z]
])
brbc = LightVector([
B(rbc, 3*c_idx + sigma, *t2) for sigma in [X, Y, Z]]
)
cum_sum += cross(bphi, brbc)[alphas_a[0]]
cum_sum *= 2.0
cum_sum -= B(self, a_alphas[0]) * Bsin2phi(phi_abc, *all_alphas[1:])
for s1, s2 in I_llbar(num_a - 1 + num_b + num_c, 2, all_alphas[1:]):
cum_sum -= Bsin2phi(phi_abc, *s1) * B(self, *((a_alphas[0],) + s2))
cum_sum /= sin2phi
for perm in permutations(all_alphas):
my_b[perm] = cum_sum
#========================================#
# Note that the terminal-atom cross-derivatives are 0
if sanity_checking_enabled:
# Fill in the explicity zeros now, since we had infinity there to make sure
# uncomputed values weren't being used for something else.
for a_idx, d_idx in permutations([0, 3]):
for remaining_idxs in product([0, 1, 2, 3], repeat=order-2):
for alphas in product([X, Y, Z], repeat=order):
idx_alphas = tuple(3*atom_idx + alpha
for atom_idx, alpha in zip((a_idx, d_idx) + remaining_idxs, alphas))
for perm in permutations(idx_alphas):
my_b[perm] = 0.0
#========================================#
# Arbitrary order bbbbb.... terms
a_idx, b_idx, c_idx, d_idx = 0, 1, 2, 3
phi_abc = phis[0]
phi_bcd = self.get_coord(BondAngle,
self.atoms[b_idx],
self.atoms[c_idx],
self.atoms[d_idx],
)
ang_conv = phi_bcd.units.to(Radians)
# TODO figure out what 'units' should be here
r_ba = self.get_coord(BondLength,
self.atoms[b_idx],
self.atoms[a_idx]
)
r_cd = self.get_coord(BondLength,
self.atoms[c_idx],
self.atoms[d_idx]
)
#----------------------------------------#
def Bcscphi(phi, *b_alphas):
phi_val = phi.value * phi.units.to(Radians)
sinphi = sin(phi_val)
cscphi = 1.0 / sinphi
if len(b_alphas) == 0:
return cscphi
cotphi = cos(phi_val) / sinphi
#------------------------------------#
def dcsc_n(n):
def t(n_t, k):
if k == 0:
return 1
elif k <= n_t//2:
return (2*k + 1) * t(n_t-1, k) + (n_t - 2*k + 1) * t(n_t-1, k-1)
else:
return 0
#--------------------------------#
ret_val = 0.0
for kk in xrange(n//2 + 1):
ret_val += t(n, kk) * cotphi**(n - 2*kk) * cscphi**(2*kk + 1)
if n % 2 == 1:
return -ret_val
else:
return ret_val
#------------------------------------#
outer_sum = 0.0
for k in xrange(1, len(b_alphas) + 1):
inner_sum = 0.0
for idx_sets in labeled_balls_in_unlabeled_boxes(len(b_alphas), [len(b_alphas)]*k):
if any(len(st) == 0 for st in idx_sets):
continue
b_idx_sets = tuple(tuple(b_alphas[i] for i in idxset) for idxset in idx_sets)
product = 1.0
for b_idxs in b_idx_sets:
product *= B(phi, *b_idxs)
inner_sum += product
outer_sum += dcsc_n(k) * inner_sum
return outer_sum
#----------------------------------------#
for alphas in symmetric_product([X, Y, Z], order):
# here we go...
term_sum = first_term = second_term = third_term = 0.0
iter_alphas = alphas[1:]
b_alphas = tuple(3*b_idx + alpha for alpha in alphas)
#----------------------------------------#
for b_alphas1, b_alphas2, b_alphas3 in I_ll(order-1, 3, b_alphas[1:]):
#----------------------------------------#
# preconstruct the vectors we need for the cross products
b_a_phi_abc = LightVector([
B(phi_abc, 3*a_idx + sigma, *b_alphas2) for sigma in [X, Y, Z]
])
b_c_phi_abc = LightVector([
B(phi_abc, 3*c_idx + sigma, *b_alphas2) for sigma in [X, Y, Z]
])
b_a_r_ba = LightVector([
B(r_ba, 3*a_idx + sigma, *b_alphas3) for sigma in [X, Y, Z]
])
#----------------------------------------#
# save a little bit of time by only computing this part once per iteration
Bcscphi_abc = Bcscphi(phi_abc, *b_alphas1)
#----------------------------------------#
# now add the contribution from this set of indices
first_term += Bcscphi_abc * cross(b_a_phi_abc, b_a_r_ba)[alphas[0]]
second_term += Bcscphi_abc * cross(b_c_phi_abc, b_a_r_ba)[alphas[0]]
#----------------------------------------#
term_sum -= first_term + second_term
b_d_r_cd = LightVector([
B(r_cd, 3*d_idx + sigma) for sigma in [X, Y, Z]
])
for b_alphas1, b_alphas2 in I_ll(order-1, 2, b_alphas[1:]):
#----------------------------------------#
b_b_phi_bcd = LightVector([
B(phi_bcd, 3*b_idx + sigma, *b_alphas2) for sigma in [X, Y, Z]
])
#----------------------------------------#
third_term += Bcscphi(phi_bcd, *b_alphas1) * cross(b_b_phi_bcd, b_d_r_cd)[alphas[0]]
term_sum += third_term
#----------------------------------------#
# and spread it across permutations
for perm in permutations(tuple(3*b_idx + alpha for alpha in alphas)):
my_b[perm] = term_sum
#========================================#
# and fill in the bbbb...cccc... derivatives by translational invariance
# Range from one c index to all
for num_c in xrange(1, order+1):
num_b = order - num_c
alph_iter = product(*map(lambda n: symmetric_product([X,Y,Z], n), (num_b, num_c)))
for alphas_b, alphas_c in alph_iter:
b_alphas = tuple(3*b_idx + alph for alph in alphas_b)
c_alphas = tuple(3*c_idx + alph for alph in alphas_c)
alphas_all = alphas_b + alphas_c
currsum = 0.0
for repl_atoms in product([a_idx, b_idx, d_idx], repeat=num_c):
repl_alphas = tuple(3*repl_atom + alph
for repl_atom, alph in zip(repl_atoms, alphas_c))
currsum += my_b[repl_alphas + b_alphas]
if sanity_checking_enabled and math.isinf(my_b[b_alphas + repl_alphas]):
raise IndexError("indices not filled in: {}, needed for {}".format(
b_alphas + repl_alphas,
b_alphas + c_alphas
))
if num_c % 2 == 1:
currsum *= -1.0
#----------------------------------------#
# and spread this value over all permutations...
for perm in permutations(b_alphas + c_alphas):
my_b[perm] = currsum
#--------------------------------------------------------------------------------#
# Cache the value we got
SimpleInternalCoordinate._set_b_tensor_cache_entry(my_b, *cache_key)
#--------------------------------------------------------------------------------#
return my_b
def analytic_b_tensor_for_order(self, order):
# First check the cache
cache_key = (self.__class__, order) + tuple(a.pos for a in self.atoms)
cache_resp = SimpleInternalCoordinate._check_b_tensor_cache(*cache_key)
if cache_resp is not None:
return cache_resp
#--------------------------------------------------------------------------------#
# Define a function that acts like the B tensor for getting lower-order terms
B = partial(SimpleInternalCoordinate.b_tensor_element_reindexed, self)
#--------------------------------------------------------------------------------#
# First order is trivial...
if order == 1:
# We can't use the `b_vector` attribute since that vector is indexed in the parent
# molecule's indexing scheme
my_b = Vector(
self.__class__.b_vector_for_positions(
*[a.pos for a in self.atoms]))
# return early to avoid double-caching, since b_vector_for_positions caches
# the result in the B tensor cache already
return my_b
#--------------------------------------------------------------------------------#
# Second order terms
elif order == 2:
# BondLengths are composed of 2 atoms (3 CartesianCoordinates each), and the
# order is 2, so the output Tensor will be a 6x6 Tensor
my_b = np.ndarray(shape=(6, ) * 2)
Rabinv = 1.0 / self.value
# This uses the itertools.product function, which acts like
# a nested loop (with depth given by the 'repeat' parameter).
# Mostly, I used this here just to keep the code indentation
# from getting out of hand (particularly in the case of the
# Torsion coordinate). Also, though, this is useful for the
# general coordinate formulas.
# First do the "same atom" derivatives
for a_idx, a in enumerate(self.atoms):
# Now iterate over the possible sets of cartesian coordinates
for alpha, beta in symmetric_product([X, Y, Z], 2):
a_alpha, a_beta = 3 * a_idx + alpha, 3 * a_idx + beta
if alpha != beta:
my_b[a_alpha, a_beta] = -Rabinv * (B(self, a_alpha) *
B(self, a_beta))
my_b[a_beta, a_alpha] = -Rabinv * (B(self, a_alpha) *
B(self, a_beta))
else:
my_b[a_alpha, a_beta] = -Rabinv * (
B(self, a_alpha) * B(self, a_beta) - 1)
# Now get the "different atom" derivatives from the "same atom ones"
for alpha in [X, Y, Z]:
for beta in [X, Y, Z]:
a_alpha = alpha
b_beta = 3 + beta
my_b[a_alpha,
b_beta] = my_b[b_beta,
a_alpha] = (-1) * my_b[alpha, beta]
#--------------------------------------------------------------------------------#
else:
# Behold, the general formula!
# BondLengths are composed of 2 atoms (3 CartesianCoordinates each),
# so the output Tensor will be a 6x6x...x6 (`order`-dimensional) Tensor
my_b = Tensor(indices=','.join('v' * order),
index_range_set=self.__class__._btens_idx_range_set)
# New, fancy way with einstein summation (if I can get it to work)
#B = self._btensor
#for o in xrange(1, order):
# t = B.for_order(o)
# if isinstance(t, ComputableTensor):
# t.fill()
# First do the "same atom" derivatives
#def idxs(letter, num): return tuple(letter + '_' + str(x) for x in xrange(num))
#aa = idxs('a', order)
#bb = idxs('b', order)
#for s in I_lubar(order, 2, aa):
# my_b[aa] += B[s[0]] * B[s[1]]
#for s in I_lubar(order, 2, bb):
# my_b[bb] += B[s[0]] * B[s[1]]
#Rabinv = 1.0 / self.value
#my_b[aa] *= -Rabinv
#my_b[bb] *= -Rabinv
## Now get the "different atom" derivatives from the "same atom ones"
#for nacarts in xrange(1, order):
# aprefactor = -1.0 if (order - nacarts) % 2 == 1 else 1.0
# for a_b_set in set(permutations("a"*nacarts + "b"*(order-nacarts))):
# ab = tuple(map(lambda x: x[0] + "_" + str(x[1]), zip(a_b_set, xrange(order))))
# my_b[ab] = aprefactor * my_b[aa]
# old way...
Rabinv = 1.0 / self.value
for a_idx, a in enumerate(self.atoms):
# Now iterate over the possible sets of cartesian coordinates
for alphas in symmetric_product([X, Y, Z], order):
a_alphas = tuple(3 * a_idx + alpha for alpha in alphas)
cumval = 0.0
for a_alps, a_bets in I_lubar(order, 2, a_alphas):
cumval += B(self, *a_alps) * B(self, *a_bets)
val_to_spread = -Rabinv * cumval
# and spread over permutations
for idxs in permutations(a_alphas):
my_b[idxs] = val_to_spread
# Now get the "different atom" derivatives from the "same atom ones"
# (From eq. 31 in Allen, et al. Mol. Phys. 89 (1996), 1213-1221)
for alphas in product([X, Y, Z], repeat=order):
for nacarts in xrange(1, order):
acoords = tuple(acart for acart in alphas[:nacarts])
bcoords = tuple(3 + bcart for bcart in alphas[nacarts:])
aprefactor = -1.0 if (order - nacarts) % 2 == 1 else 1.0
val_to_spread = my_b[alphas]
for perm in permutations(acoords + bcoords):
my_b[perm] = aprefactor * val_to_spread
#--------------------------------------------------------------------------------#
# Whew...that was tough. Let's cache the value we got
SimpleInternalCoordinate._set_b_tensor_cache_entry(my_b, *cache_key)
#--------------------------------------------------------------------------------#
return my_b
def analytic_b_tensor_for_order(self, order):
# First check the cache
cache_key = (self.__class__, order) + tuple(a.pos for a in self.atoms)
cache_resp = SimpleInternalCoordinate._check_b_tensor_cache(*cache_key)
if cache_resp is not None:
return cache_resp
#--------------------------------------------------------------------------------#
# Define a function that acts like the B tensor for getting lower-order terms
B = partial(SimpleInternalCoordinate.b_tensor_element_reindexed, self)
#--------------------------------------------------------------------------------#
# First order is trivial...
if order == 1:
# We can't use the `b_vector` attribute since that vector is indexed in the parent
# molecule's indexing scheme
my_b = Vector(self.__class__.b_vector_for_positions(*[a.pos for a in self.atoms]))
# return early to avoid double-caching, since b_vector_for_positions caches
# the result in the B tensor cache already
return my_b
#--------------------------------------------------------------------------------#
# Second order terms
elif order == 2:
# BondLengths are composed of 2 atoms (3 CartesianCoordinates each), and the
# order is 2, so the output Tensor will be a 6x6 Tensor
my_b = np.ndarray(shape=(6,)*2)
Rabinv = 1.0 / self.value
# This uses the itertools.product function, which acts like
# a nested loop (with depth given by the 'repeat' parameter).
# Mostly, I used this here just to keep the code indentation
# from getting out of hand (particularly in the case of the
# Torsion coordinate). Also, though, this is useful for the
# general coordinate formulas.
# First do the "same atom" derivatives
for a_idx, a in enumerate(self.atoms):
# Now iterate over the possible sets of cartesian coordinates
for alpha, beta in symmetric_product([X, Y, Z], 2):
a_alpha, a_beta = 3*a_idx + alpha, 3*a_idx + beta
if alpha != beta:
my_b[a_alpha, a_beta] = - Rabinv * (B(self, a_alpha) * B(self, a_beta))
my_b[a_beta, a_alpha] = - Rabinv * (B(self, a_alpha) * B(self, a_beta))
else:
my_b[a_alpha, a_beta] = - Rabinv * (B(self, a_alpha) * B(self, a_beta) - 1)
# Now get the "different atom" derivatives from the "same atom ones"
for alpha in [X, Y, Z]:
for beta in [X, Y, Z]:
a_alpha = alpha
b_beta = 3 + beta
my_b[a_alpha, b_beta] = my_b[b_beta, a_alpha] = (-1) * my_b[alpha, beta]
#--------------------------------------------------------------------------------#
else:
# Behold, the general formula!
# BondLengths are composed of 2 atoms (3 CartesianCoordinates each),
# so the output Tensor will be a 6x6x...x6 (`order`-dimensional) Tensor
my_b = Tensor(
indices=','.join('v'*order),
index_range_set=self.__class__._btens_idx_range_set
)
# New, fancy way with einstein summation (if I can get it to work)
#B = self._btensor
#for o in xrange(1, order):
# t = B.for_order(o)
# if isinstance(t, ComputableTensor):
# t.fill()
# First do the "same atom" derivatives
#def idxs(letter, num): return tuple(letter + '_' + str(x) for x in xrange(num))
#aa = idxs('a', order)
#bb = idxs('b', order)
#for s in I_lubar(order, 2, aa):
# my_b[aa] += B[s[0]] * B[s[1]]
#for s in I_lubar(order, 2, bb):
# my_b[bb] += B[s[0]] * B[s[1]]
#Rabinv = 1.0 / self.value
#my_b[aa] *= -Rabinv
#my_b[bb] *= -Rabinv
## Now get the "different atom" derivatives from the "same atom ones"
#for nacarts in xrange(1, order):
# aprefactor = -1.0 if (order - nacarts) % 2 == 1 else 1.0
# for a_b_set in set(permutations("a"*nacarts + "b"*(order-nacarts))):
# ab = tuple(map(lambda x: x[0] + "_" + str(x[1]), zip(a_b_set, xrange(order))))
# my_b[ab] = aprefactor * my_b[aa]
# old way...
Rabinv = 1.0 / self.value
for a_idx, a in enumerate(self.atoms):
# Now iterate over the possible sets of cartesian coordinates
for alphas in symmetric_product([X, Y, Z], order):
a_alphas = tuple(3*a_idx + alpha for alpha in alphas)
cumval = 0.0
for a_alps, a_bets in I_lubar(order, 2, a_alphas):
cumval += B(self, *a_alps) * B(self, *a_bets)
val_to_spread = -Rabinv * cumval
# and spread over permutations
for idxs in permutations(a_alphas):
my_b[idxs] = val_to_spread
# Now get the "different atom" derivatives from the "same atom ones"
# (From eq. 31 in Allen, et al. Mol. Phys. 89 (1996), 1213-1221)
for alphas in product([X, Y, Z], repeat=order):
for nacarts in xrange(1, order):
acoords = tuple(acart for acart in alphas[:nacarts])
bcoords = tuple(3 + bcart for bcart in alphas[nacarts:])
aprefactor = -1.0 if (order - nacarts) % 2 == 1 else 1.0
val_to_spread = my_b[alphas]
for perm in permutations(acoords + bcoords):
my_b[perm] = aprefactor * val_to_spread
#--------------------------------------------------------------------------------#
# Whew...that was tough. Let's cache the value we got
SimpleInternalCoordinate._set_b_tensor_cache_entry(my_b, *cache_key)
#--------------------------------------------------------------------------------#
return my_b
