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