Ejemplo n.º 1
0
 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
Ejemplo n.º 2
0
 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)
Ejemplo n.º 3
0
 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)
Ejemplo n.º 4
0
 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
Ejemplo n.º 5
0
 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
Ejemplo n.º 6
0
 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
Ejemplo n.º 7
0
 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
Ejemplo n.º 8
0
 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