def neighbour_list(quantities, a, cutoff): """ Compute a neighbour list for an atomic configuration. Parameters ---------- quantities : str Quantities to compute by the neighbor list algorithm. Each character in this string defines a quantity. They are returned in a tuple of the same order. Possible quantities are 'i' : first atom index 'j' : second atom index 'd' : absolute distance 'D' : distance vector 'S' : shift vector (number of cell boundaries crossed by the bond between atom i and j) a : ase.Atoms Atomic configuration. cutoff : float Cutoff for neighbour search. Returns ------- i, j, ... : array Tuple with arrays for each quantity specified above. """ return _matscipy.neighbour_list(quantities, a.cell, np.linalg.inv(a.cell.T), a.pbc, a.positions, cutoff)
def neighbour_list(quantities, a, cutoff): """ Compute a neighbour list for an atomic configuration. Parameters ---------- quantities : str Quantities to compute by the neighbor list algorithm. Each character in this string defines a quantity. They are returned in a tuple of the same order. Possible quantities are 'i' : first atom index 'j' : second atom index 'd' : absolute distance 'D' : distance vector 'S' : shift vector (number of cell boundaries crossed by the bond between atom i and j) a : ase.Atoms Atomic configuration. cutoff : float Cutoff for neighbour search. Returns ------- i, j, ... : array Tuple with arrays for each quantity specified above. """ return _matscipy.neighbour_list(quantities, a.cell, np.linalg.inv(a.cell.T), a.pbc, a.positions, cutoff)
def neighbour_list(quantities, a, cutoff): """ Compute a neighbor list for an atomic configuration. Atoms outside periodic boundaries are mapped into the box. Atoms outside nonperiodic boundaries are included in the neighbor list but complexity of neighbor list search for those can become n^2. The neighbor list is sorted by first atom index 'i', but not by second atom index 'j'. Parameters ---------- quantities : str Quantities to compute by the neighbor list algorithm. Each character in this string defines a quantity. They are returned in a tuple of the same order. Possible quantities are 'i' : first atom index 'j' : second atom index 'd' : absolute distance 'D' : distance vector 'S' : shift vector (number of cell boundaries crossed by the bond between atom i and j). With the shift vector S, the distances D between atoms can be computed from: D = a.positions[j]-a.positions[i]+S.dot(a.cell) a : ase.Atoms Atomic configuration. cutoff : float or dict Cutoff for neighbor search. It can be - A single float: This is a global cutoff for all elements. - A dictionary: This specifies cutoff values for element pairs. Specification accepts element numbers of symbols. Example: {(1, 6): 1.1, (1, 1): 1.0, ('C', 'C'): 1.85} - A list/array with a per atom value: This specifies the radius of an atomic sphere for each atoms. If spheres overlap, atoms are within each others neighborhood. Returns ------- i, j, ... : array Tuple with arrays for each quantity specified above. Indices in `i` are returned in ascending order 0..len(a), but the order of (i,j) pairs is not guaranteed. Examples -------- Examples assume Atoms object *a* and numpy imported as *np*. 1. Coordination counting: i = neighbor_list('i', a, 1.85) coord = np.bincount(i) 2. Coordination counting with different cutoffs for each pair of species i = neighbor_list('i', a, {('H', 'H'): 1.1, ('C', 'H'): 1.3, ('C', 'C'): 1.85}) coord = np.bincount(i) 3. Pair distribution function: d = neighbor_list('d', a, 10.00) h, bin_edges = np.histogram(d, bins=100) pdf = h/(4*np.pi/3*(bin_edges[1:]**3 - bin_edges[:-1]**3)) * a.get_volume()/len(a) 4. Pair potential: i, j, d, D = neighbor_list('ijdD', a, 5.0) energy = (-C/d**6).sum() pair_forces = (6*C/d**5 * (D/d).T).T forces_x = np.bincount(j, weights=pair_forces[:, 0], minlength=len(a)) - \ np.bincount(i, weights=pair_forces[:, 0], minlength=len(a)) forces_y = np.bincount(j, weights=pair_forces[:, 1], minlength=len(a)) - \ np.bincount(i, weights=pair_forces[:, 1], minlength=len(a)) forces_z = np.bincount(j, weights=pair_forces[:, 2], minlength=len(a)) - \ np.bincount(i, weights=pair_forces[:, 2], minlength=len(a)) 5. Dynamical matrix for a pair potential stored in a block sparse format: from scipy.sparse import bsr_matrix i, j, dr, abs_dr = neighbor_list('ijDd', atoms) energy = (dr.T / abs_dr).T dynmat = -(dde * (energy.reshape(-1, 3, 1) * energy.reshape(-1, 1, 3)).T).T \ -(de / abs_dr * (np.eye(3, dtype=energy.dtype) - \ (energy.reshape(-1, 3, 1) * energy.reshape(-1, 1, 3))).T).T dynmat_bsr = bsr_matrix((dynmat, j, first_i), shape=(3*len(a), 3*len(a))) dynmat_diag = np.empty((len(a), 3, 3)) for x in range(3): for y in range(3): dynmat_diag[:, x, y] = -np.bincount(i, weights=dynmat[:, x, y]) dynmat_bsr += bsr_matrix((dynmat_diag, np.arange(len(a)), np.arange(len(a) + 1)), shape=(3 * len(a), 3 * len(a))) i_n, j_n, dr_nc, abs_dr_n = neighbour_list('ijDd', atoms, dict) e_nc = (dr_nc.T/abs_dr_n).T D_ncc = -(dde_n * (e_nc.reshape(-1,3,1) * e_nc.reshape(-1,1,3)).T).T D_ncc += -(de_n/abs_dr_n * (np.eye(3, dtype=e_nc.dtype) - (e_nc.reshape(-1,3,1) * e_nc.reshape(-1,1,3))).T).T D = bsr_matrix((D_ncc, j_n, first_i), shape=(3*nat,3*nat)) Ddiag_icc = np.empty((nat,3,3)) for x in range(3): for y in range(3): Ddiag_icc[:,x,y] = -np.bincount(i_n, weights = D_ncc[:,x,y]) D += bsr_matrix((Ddiag_icc,np.arange(nat),np.arange(nat+1)), shape=(3*nat,3*nat)) return D """ if isinstance(cutoff, dict): maxel = np.max(a.numbers) _cutoff = np.zeros([maxel+1, maxel+1], dtype=float) for (el1, el2), c in cutoff.items(): try: el1 = atomic_numbers[el1] except: pass try: el2 = atomic_numbers[el2] except: pass if el1 < maxel+1 and el2 < maxel+1: _cutoff[el1, el2] = c _cutoff[el2, el1] = c else: _cutoff = cutoff return _matscipy.neighbour_list(quantities, a.cell, np.linalg.inv(a.cell.T), a.pbc, a.positions, _cutoff, a.numbers.astype(np.int32))
def neighbour_list(quantities, a, cutoff): """ Compute a neighbour list for an atomic configuration. Parameters ---------- quantities : str Quantities to compute by the neighbor list algorithm. Each character in this string defines a quantity. They are returned in a tuple of the same order. Possible quantities are 'i' : first atom index 'j' : second atom index 'd' : absolute distance 'D' : distance vector 'S' : shift vector (number of cell boundaries crossed by the bond between atom i and j). With the shift vector S, the distances d between can be computed as: D = a.positions[j]-a.positions[i]+S.dot(a.cell) a : ase.Atoms Atomic configuration. cutoff : float or dict Cutoff for neighbour search. If single float is given, a global cutoff is used for all elements. A dictionary specifies cutoff for element pairs. Specification accepts element numbers of symbols. Example: {(1, 6): 1.1, (1, 1): 1.0, ('C', 'C'): 1.85} Returns ------- i, j, ... : array Tuple with arrays for each quantity specified above. Indices in `i` are returned in ascending order 0..len(a), but the order of (i,j) pairs is not guaranteed. Examples -------- Examples assume Atoms object *a* and numpy imported as *np*. 1. Coordination counting: i = neighbour_list('i', a, 1.85) coord = np.bincount(i) 2. Coordination counting with different cutoffs for each pair of species i = neighbour_list('i', a, {('H', 'H'): 1.1, ('C', 'H'): 1.3, ('C', 'C'): 1.85}) coord = np.bincount(i) 3. Pair distribution function: d = neighbour_list('d', a, 10.00) h, bin_edges = np.histogram(d, bins=100) pdf = h/(4*np.pi/3*(bin_edges[1:]**3 - bin_edges[:-1]**3)) * a.get_volume()/len(a) 4. Pair potential: i, j, d, D = neighbour_list('ijdD', a, 5.0) energy = (-C/d**6).sum() pair_forces = (6*C/d**5 * (D/d).T).T forces_x = np.bincount(j, weights=pair_forces[:, 0], minlength=len(a)) - \ np.bincount(i, weights=pair_forces[:, 0], minlength=len(a)) forces_y = np.bincount(j, weights=pair_forces[:, 1], minlength=len(a)) - \ np.bincount(i, weights=pair_forces[:, 1], minlength=len(a)) forces_z = np.bincount(j, weights=pair_forces[:, 2], minlength=len(a)) - \ np.bincount(i, weights=pair_forces[:, 2], minlength=len(a)) """ if isinstance(cutoff, dict): maxel = np.max(a.numbers) _cutoff = np.zeros([maxel+1, maxel+1], dtype=float) for (el1, el2), c in cutoff.items(): try: el1 = atomic_numbers[el1] except: pass try: el2 = atomic_numbers[el2] except: pass if el1 < maxel+1 and el2 < maxel+1: _cutoff[el1, el2] = c _cutoff[el2, el1] = c else: _cutoff = cutoff return _matscipy.neighbour_list(quantities, a.cell, np.linalg.inv(a.cell.T), a.pbc, a.positions, _cutoff, a.numbers.astype(np.int32))
def neighbour_list(quantities, atoms=None, cutoff=None, positions=None, cell=None, pbc=None, numbers=None, cell_origin=None): """ Compute a neighbor list for an atomic configuration. Atoms outside periodic boundaries are mapped into the box. Atoms outside nonperiodic boundaries are included in the neighbor list but the complexity of neighbor list search for those can become n^2. The neighbor list is sorted by first atom index 'i', but not by second atom index 'j'. The neighbour list accepts either an ASE Atoms object or positions and cell vectors individually. Parameters ---------- quantities : str Quantities to compute by the neighbor list algorithm. Each character in this string defines a quantity. They are returned in a tuple of the same order. Possible quantities are 'i' : first atom index 'j' : second atom index 'd' : absolute distance 'D' : distance vector 'S' : shift vector (number of cell boundaries crossed by the bond between atom i and j). With the shift vector S, the distances D between atoms can be computed from: D = a.positions[j]-a.positions[i]+S.dot(a.cell) atoms : ase.Atoms Atomic configuration. (Default: None) cutoff : float or dict Cutoff for neighbor search. It can be - A single float: This is a global cutoff for all elements. - A dictionary: This specifies cutoff values for element pairs. Specification accepts element numbers of symbols. Example: {(1, 6): 1.1, (1, 1): 1.0, ('C', 'C'): 1.85} - A list/array with a per atom value: This specifies the radius of an atomic sphere for each atoms. If spheres overlap, atoms are within each others neighborhood. positions : array_like Atomic positions. (Default: None) cell : array_like Cell vectors as a 3x3 matrix. (Default: Shrink wrapped cell) pbc : array_like 3-vector containing periodic boundary conditions in all three directions. (Default: Nonperiodic box) numbers : array_like Array containing the atomic numbers. Returns ------- i, j, ... : array Tuple with arrays for each quantity specified above. Indices in `i` are returned in ascending order 0..len(a), but the order of (i,j) pairs is not guaranteed. Examples -------- Examples assume Atoms object *a* and numpy imported as *np*. 1. Coordination counting: i = neighbor_list('i', a, 1.85) coord = np.bincount(i) 2. Coordination counting with different cutoffs for each pair of species i = neighbor_list('i', a, {('H', 'H'): 1.1, ('C', 'H'): 1.3, ('C', 'C'): 1.85}) coord = np.bincount(i) 3. Pair distribution function: d = neighbor_list('d', a, 10.00) h, bin_edges = np.histogram(d, bins=100) pdf = h/(4*np.pi/3*(bin_edges[1:]**3 - bin_edges[:-1]**3)) * a.get_volume()/len(a) 4. Pair potential: i, j, d, D = neighbor_list('ijdD', a, 5.0) energy = (-C/d**6).sum() pair_forces = (6*C/d**5 * (D/d).T).T forces_x = np.bincount(j, weights=pair_forces[:, 0], minlength=len(a)) - \ np.bincount(i, weights=pair_forces[:, 0], minlength=len(a)) forces_y = np.bincount(j, weights=pair_forces[:, 1], minlength=len(a)) - \ np.bincount(i, weights=pair_forces[:, 1], minlength=len(a)) forces_z = np.bincount(j, weights=pair_forces[:, 2], minlength=len(a)) - \ np.bincount(i, weights=pair_forces[:, 2], minlength=len(a)) 5. Dynamical matrix for a pair potential stored in a block sparse format: from scipy.sparse import bsr_matrix i, j, dr, abs_dr = neighbor_list('ijDd', atoms) energy = (dr.T / abs_dr).T dynmat = -(dde * (energy.reshape(-1, 3, 1) * energy.reshape(-1, 1, 3)).T).T \ -(de / abs_dr * (np.eye(3, dtype=energy.dtype) - \ (energy.reshape(-1, 3, 1) * energy.reshape(-1, 1, 3))).T).T dynmat_bsr = bsr_matrix((dynmat, j, first_i), shape=(3*len(a), 3*len(a))) dynmat_diag = np.empty((len(a), 3, 3)) for x in range(3): for y in range(3): dynmat_diag[:, x, y] = -np.bincount(i, weights=dynmat[:, x, y]) dynmat_bsr += bsr_matrix((dynmat_diag, np.arange(len(a)), np.arange(len(a) + 1)), shape=(3 * len(a), 3 * len(a))) i_n, j_n, dr_nc, abs_dr_n = neighbour_list('ijDd', atoms, dict) e_nc = (dr_nc.T/abs_dr_n).T D_ncc = -(dde_n * (e_nc.reshape(-1,3,1) * e_nc.reshape(-1,1,3)).T).T D_ncc += -(de_n/abs_dr_n * (np.eye(3, dtype=e_nc.dtype) - (e_nc.reshape(-1,3,1) * e_nc.reshape(-1,1,3))).T).T D = bsr_matrix((D_ncc, j_n, first_i), shape=(3*nat,3*nat)) Ddiag_icc = np.empty((nat,3,3)) for x in range(3): for y in range(3): Ddiag_icc[:,x,y] = -np.bincount(i_n, weights = D_ncc[:,x,y]) D += bsr_matrix((Ddiag_icc,np.arange(nat),np.arange(nat+1)), shape=(3*nat,3*nat)) return D """ if cutoff is None: raise ValueError('Please provide a value for the cutoff radius.') if atoms is None: if positions is None: raise ValueError('You provided neither an ASE Atoms object nor ' 'a positions array.') if cell is None: # Shrink wrapped cell rmin = np.min(positions, axis=0) rmax = np.max(positions, axis=0) cell_origin = rmin cell = np.diag(rmax - rmin) if cell_origin is None: cell_origin = np.zeros(3) if pbc is None: pbc = np.zeros(3, dtype=bool) if numbers is None: numbers = np.ones(len(positions), dtype=np.int32) else: if positions is not None: raise ValueError( 'You cannot provide an ASE Atoms object and ' 'individual position atomic positions at the same ' 'time.') positions = atoms.positions if cell_origin is not None: raise ValueError('You cannot provide an ASE Atoms object and ' 'a cell origin at the same time.') cell_origin = np.zeros(3) if cell is not None: raise ValueError('You cannot provide an ASE Atoms object and ' 'cell vectors at the same time.') cell = atoms.cell if pbc is not None: raise ValueError('You cannot provide an ASE Atoms object and ' 'separate periodicity information at the same ' 'time.') pbc = atoms.pbc if numbers is not None: raise ValueError('You cannot provide an ASE Atoms object and ' 'separate atomic numbers at the same time.') numbers = atoms.numbers.astype(np.int32) if isinstance(cutoff, dict): maxel = np.max(numbers) _cutoff = np.zeros([maxel + 1, maxel + 1], dtype=float) for (el1, el2), c in cutoff.items(): try: el1 = atomic_numbers[el1] except: pass try: el2 = atomic_numbers[el2] except: pass if el1 < maxel + 1 and el2 < maxel + 1: _cutoff[el1, el2] = c _cutoff[el2, el1] = c else: _cutoff = cutoff return _matscipy.neighbour_list(quantities, cell_origin, cell, np.linalg.inv(cell.T), pbc, positions, _cutoff, numbers)
def neighbour_list(quantities, a, cutoff): """ Compute a neighbor list for an atomic configuration. Atoms outside periodic boundaries are mapped into the box. Atoms outside nonperiodic boundaries are included in the neighbor list but complexity of neighbor list search for those can become n^2. The neighbor list is sorted by first atom index 'i', but not by second atom index 'j'. Parameters ---------- quantities : str Quantities to compute by the neighbor list algorithm. Each character in this string defines a quantity. They are returned in a tuple of the same order. Possible quantities are 'i' : first atom index 'j' : second atom index 'd' : absolute distance 'D' : distance vector 'S' : shift vector (number of cell boundaries crossed by the bond between atom i and j). With the shift vector S, the distances D between atoms can be computed from: D = a.positions[j]-a.positions[i]+S.dot(a.cell) a : ase.Atoms Atomic configuration. cutoff : float or dict Cutoff for neighbor search. It can be - A single float: This is a global cutoff for all elements. - A dictionary: This specifies cutoff values for element pairs. Specification accepts element numbers of symbols. Example: {(1, 6): 1.1, (1, 1): 1.0, ('C', 'C'): 1.85} - A list/array with a per atom value: This specifies the radius of an atomic sphere for each atoms. If spheres overlap, atoms are within each others neighborhood. Returns ------- i, j, ... : array Tuple with arrays for each quantity specified above. Indices in `i` are returned in ascending order 0..len(a), but the order of (i,j) pairs is not guaranteed. Examples -------- Examples assume Atoms object *a* and numpy imported as *np*. 1. Coordination counting: i = neighbor_list('i', a, 1.85) coord = np.bincount(i) 2. Coordination counting with different cutoffs for each pair of species i = neighbor_list('i', a, {('H', 'H'): 1.1, ('C', 'H'): 1.3, ('C', 'C'): 1.85}) coord = np.bincount(i) 3. Pair distribution function: d = neighbor_list('d', a, 10.00) h, bin_edges = np.histogram(d, bins=100) pdf = h/(4*np.pi/3*(bin_edges[1:]**3 - bin_edges[:-1]**3)) * a.get_volume()/len(a) 4. Pair potential: i, j, d, D = neighbor_list('ijdD', a, 5.0) energy = (-C/d**6).sum() pair_forces = (6*C/d**5 * (D/d).T).T forces_x = np.bincount(j, weights=pair_forces[:, 0], minlength=len(a)) - \ np.bincount(i, weights=pair_forces[:, 0], minlength=len(a)) forces_y = np.bincount(j, weights=pair_forces[:, 1], minlength=len(a)) - \ np.bincount(i, weights=pair_forces[:, 1], minlength=len(a)) forces_z = np.bincount(j, weights=pair_forces[:, 2], minlength=len(a)) - \ np.bincount(i, weights=pair_forces[:, 2], minlength=len(a)) 5. Dynamical matrix for a pair potential stored in a block sparse format: from scipy.sparse import bsr_matrix i, j, dr, abs_dr = neighbor_list('ijDd', atoms) energy = (dr.T / abs_dr).T dynmat = -(dde * (energy.reshape(-1, 3, 1) * energy.reshape(-1, 1, 3)).T).T \ -(de / abs_dr * (np.eye(3, dtype=energy.dtype) - \ (energy.reshape(-1, 3, 1) * energy.reshape(-1, 1, 3))).T).T dynmat_bsr = bsr_matrix((dynmat, j, first_i), shape=(3*len(a), 3*len(a))) dynmat_diag = np.empty((len(a), 3, 3)) for x in range(3): for y in range(3): dynmat_diag[:, x, y] = -np.bincount(i, weights=dynmat[:, x, y]) dynmat_bsr += bsr_matrix((dynmat_diag, np.arange(len(a)), np.arange(len(a) + 1)), shape=(3 * len(a), 3 * len(a))) """ if isinstance(cutoff, dict): maxel = np.max(a.numbers) _cutoff = np.zeros([maxel+1, maxel+1], dtype=float) for (el1, el2), c in cutoff.items(): try: el1 = atomic_numbers[el1] except: pass try: el2 = atomic_numbers[el2] except: pass if el1 < maxel+1 and el2 < maxel+1: _cutoff[el1, el2] = c _cutoff[el2, el1] = c else: _cutoff = cutoff return _matscipy.neighbour_list(quantities, a.cell, np.linalg.inv(a.cell.T), a.pbc, a.positions, _cutoff, a.numbers.astype(np.int32))
def neigh_list_based_target_function(x, r=1.0, constraints=None, Dij=None): """Target function. Penalize dense packing for coordinates ||xi-xj||<ri+rj. Parameters ---------- x: (N,dim) ndarray particle coordinates r: float or (N,) ndarray, optional (default=1.0) steric radii of particles constraints: callable, returns (float, (N,dim) ndarray) constraint function value and gradien Dij: (N, N) ndarray, optional (default=None) pairwise minimum allowed distance matrix, overrides r Returns ------- (float, (N,dim) ndarray): target function value and gradient f: float, target (or penalty) function, value evaluates to sum_i sum_{j!=i} max(0,(r_i+r_j)^2-||xi-xj||^2)^2 without double-counting pairs, where r_i and r_j are the steric radii of coordinate points i and j df: (N,dim) ndarray of float, the gradient, evaluates to 4*si sj ((r_i'+r_j)^2-||xi-xj||^2)^2)*(xik'-xjk')*(kdi'j-kdi'i) for entry (i',k'), where i subscribes the coordinate point and k the spatial dimension. kd is Kronecker delta, si is sum over i """ logger = logging.getLogger(__name__) # # function: # # f(x) = sum_i sum_{j!=i} max(0,(r_i+r_j)^2-||xi-xj||^2)^2 # # gradient: # # dfdxi'k'=4*si sj ((r_i'+r_j)^2-||xi-xj||^2)^2)*(xik'-xjk')*(kdi'j-kdi'i) # # for all pairs i'j within ri'+rj cutoff # where k is the spatial direction x, y or z. assert x.ndim == 2, "2d array expected for x" n = x.shape[0] if not Dij: if not isinstance(r, np.ndarray) or r.shape != (n, ): r = r * np.ones(n) assert r.shape == (n, ) # compute minimum allowed pairwise distances Dij (NxN matrix) # r(Nx1) kron ones(1xN) = Ri(NxN) Ri = np.kron(r, np.ones((n, 1))) Rj = Ri.T Dij = Ri + Rj # TODO: allow for periodic boundaries, for now use shrink wrapped box box = np.array([x.min(axis=0), x.max(axis=0)]) cell_origin = box[0, :] cell = np.diag(box[1, :] - box[0, :]) # get all pairs within their allowed minimum distance # parameters are # _matscipy.neighbour_list(quantities, cell_origin, cell, # np.linalg.inv(cell.T), pbc, positions, # cutoff, numbers) # If thhe parameter 'cutoff' is a per-atom value, then it must be a # diamater, not a radius (as wrongly stated within the function's # docstring) i, j, dxijnorm, dxijvec = _matscipy.neighbour_list( 'ijdD', cell_origin, cell, np.linalg.inv(cell.T), [0, 0, 0], x, 2.0 * Ri, np.ones(len(x), dtype=np.int32)) # i, j are coordinate point indices, dxijnorm is pairwise distance, # dxvijvec is distance vector # nl contains redundnancies, i.e. ij AND ji # pairs = list(zip(i,j)) logger.debug( "Number of pairs within minimum allowed distance: {:d}".format(len(i))) # get minimum allowed pairwise distance for all pairs within this distance dij = Dij[i, j] # (r_i'+r_j)^2 dsq = np.square(dij) # ||xi-xj||^2 dxnormsq = np.square(dxijnorm) # (r_i+r_j)^2-||xi-xj||^2 sqdiff = dsq - dxnormsq # ((r_i+r_j)^2-||xi-xj||^2)^2 penaltysq = np.square(sqdiff) # correct for double counting due to redundancies f = 0.5 * np.sum(penaltysq) # 4*si sj ((r_i'+r_j)^2-||xi-xj||^2)^2)*(xik'-xjk')*(kdi'j-kdi'i) # (N x 1) column vector (a1 ... aN) * (N x dim) matrix ((d11,)) # Other than the formula above implicates, _matscipy.neighbour_list # returns the distance vector dxijvec = xj-xi (pointing from i to j), # thus positive sign in gradient below: gradij = 4 * np.atleast_2d( sqdiff).T * dxijvec # let's hope for proper broadcasting grad = np.zeros(x.shape) grad[i] += gradij # Since neighbour list always includes ij and ji, we only have to treat i, # not j. The following line is obsolete (otherwise we would introduce # double-counting again): # grad[j] -= gradij if constraints: logger.debug("Unconstrained penalty: {:10.5e}.".format(f)) logger.debug( DeferredMessage("Unconstrained gradient norm: {:10.5e}.", np.linalg.norm, grad)) g, g_grad = constraints(x) f += g grad += g_grad grad_1d = grad.reshape(np.product(grad.shape)) logger.debug("Total penalty: {:10.5e}.".format(f)) logger.debug( DeferredMessage("Gradient norm: {:10.5e}.", np.linalg.norm, grad_1d)) return f, grad_1d
def neighbour_list(quantities, a, cutoff, *args): """ Compute a neighbour list for an atomic configuration. Parameters ---------- quantities : str Quantities to compute by the neighbor list algorithm. Each character in this string defines a quantity. They are returned in a tuple of the same order. Possible quantities are 'i' : first atom index 'j' : second atom index 'd' : absolute distance 'D' : distance vector 'S' : shift vector (number of cell boundaries crossed by the bond between atom i and j). With the shift vector S, the distances d between can be computed as: D = a.positions[j]-a.positions[i]+S.dot(a.cell) a : ase.Atoms Atomic configuration. cutoff : float or array_like Cutoff for neighbour search. If square array is given, then different cutoffs will be used for individual bonds. Square array contains pair-wise cutoffs for a given species, given by the *numbers* parameter. numbers : array_like, optional Atomic numbers or similar identifiers for elements. Used for cutoff lookup. Returns ------- i, j, ... : array Tuple with arrays for each quantity specified above. Indices in `i` are returned in ascending order 0..len(a), but the order of (i,j) pairs is not guaranteed. Examples -------- Examples assume Atoms object *a* and numpy imported as *np*. 1. Coordination counting: i = neighbour_list('i', a, 1.85) coord = np.bincount(i) 2. Coordination counting with different cutoffs for each pair of species (Assumes that species are Carbon=6 and Hydrogen=1) i = neighbour_list('i', a, [[1.1, 1.3], [1.3, 1.85]], (a.numbers-1)//5) coord = np.bincount(i) 3. Pair distribution function: d = neighbour_list('d', a, 10.00) h, bin_edges = np.histogram(d, bins=100) pdf = h/(4*np.pi/3*(bin_edges[1:]**3 - bin_edges[:-1]**3)) * a.get_volume()/len(a) 4. Pair potential: i, j, d, D = neighbour_list('ijdD', a, 5.0) energy = (-C/d**6).sum() pair_forces = (6*C/d**5 * (D/d).T).T forces_x = np.bincount(j, weights=pair_forces[:, 0], minlength=len(a)) - \ np.bincount(i, weights=pair_forces[:, 0], minlength=len(a)) forces_y = np.bincount(j, weights=pair_forces[:, 1], minlength=len(a)) - \ np.bincount(i, weights=pair_forces[:, 1], minlength=len(a)) forces_z = np.bincount(j, weights=pair_forces[:, 2], minlength=len(a)) - \ np.bincount(i, weights=pair_forces[:, 2], minlength=len(a)) """ return _matscipy.neighbour_list(quantities, a.cell, np.linalg.inv(a.cell.T), a.pbc, a.positions, cutoff, *args)