def __call__(self, gradients = None, force_constants = None, small_change=0): self.checkUniverseVersion() args = [self.configuration.array] if ParticleProperties.isParticleProperty(gradients): args.append(gradients.array) elif type(gradients) == Numeric.arraytype: gradients = \ ParticleProperties.ParticleVector(self.universe, gradients) args.append(gradients.array) elif gradients: gradients = ParticleProperties.ParticleVector(self.universe, None) args.append(gradients.array) else: args.append(None) if ParticleProperties.isParticleProperty(force_constants): args.append(force_constants.array) elif type(force_constants) == Numeric.arraytype: force_constants = \ ParticleProperties.SymmetricPairTensor(self.universe, force_constants) args.append(force_constants.array) else: sparse_type = None try: from MMTK_forcefield import SparseForceConstants sparse_type = type(SparseForceConstants(2, 2)) except ImportError: pass if type(force_constants) == sparse_type: args.append(force_constants) elif force_constants: force_constants = \ ParticleProperties.SymmetricPairTensor(self.universe, None) args.append(force_constants.array) else: args.append(None) args.append(small_change) self.universe.acquireReadStateLock() try: energy = apply(self.evaluator, tuple(args)) finally: self.universe.releaseReadStateLock() if force_constants: return energy, gradients, force_constants elif gradients: return energy, gradients else: return energy
def __init__(self, universe, rigid_bodies): """ :param universe: the universe for which the subspace is created :type universe: :class:~MMTK.Universe.Universe :param rigid_bodies: a list or set of rigid bodies with some common atoms """ ex_ey_ez = [Vector(1.,0.,0.), Vector(0.,1.,0.), Vector(0.,0.,1.)] # Constructs # 1) a list of vectors describing the rigid-body motions of each # rigid body as if it were independent. # 2) a list of pair-distance constraint vectors for all pairs of # atoms inside a rigid body. # The LRB subspace is constructed from the projections of the # first set of vectors onto the orthogonal complement of the # subspace generated by the second set of vectors. vectors = [] c_vectors = [] for rb in rigid_bodies: atoms = rb.atomList() for d in ex_ey_ez: v = ParticleProperties.ParticleVector(universe) for a in atoms: v[a] = d vectors.append(v) if len(atoms) > 1: center = rb.centerOfMass() iv = len(vectors)-3 for d in ex_ey_ez: v = ParticleProperties.ParticleVector(universe) for a in atoms: v[a] = d.cross(a.position()-center) for vt in vectors[iv:]: v -= v.dotProduct(vt)*vt if v.dotProduct(v) > 0.: vectors.append(v) for a1, a2 in Utility.pairs(atoms): distance = universe.distanceVector(a1.position(), a2.position()) v = ParticleProperties.ParticleVector(universe) v[a1] = distance v[a2] = -distance c_vectors.append(v) if c_vectors: constraints = Subspace(universe, c_vectors) vectors = [constraints.projectionComplementOf(v) for v in vectors] Subspace.__init__(self, universe, vectors)
def EISF(self, q_range=(0., 15.), subset=None, weights=None, random_vectors=15, first_mode=6): if subset is None: subset = self.universe if weights is None: weights = self.universe.getParticleScalar('b_incoherent') weights = weights * weights weights = weights * subset.booleanMask() total = weights.sumOverParticles() weights = weights / total first, last, step = (q_range + (None, ))[:3] if step is None: step = (last - first) / 50. q = N.arange(first, last, step) f = ParticleProperties.ParticleTensor(self.universe) for i in range(first_mode, self.nmodes): mode = self.rawMode(i) f = f + (1. / mode.inv_relaxation_time) * mode.dyadicProduct(mode) f = Units.k_B * self.temperature * f / self.friction eisf = N.zeros(q.shape, N.Float) random_vectors = Random.randomDirections(random_vectors) for v in random_vectors: for a in subset.atomList(): exp = N.exp(-v * (f[a] * v)) N.add(eisf, weights[a] * exp**(q * q), eisf) return InterpolatingFunction((q, ), eisf / len(random_vectors))
def __call__(self, vector): conf = self.universe.configuration() r = ParticleProperties.ParticleScalar(self.universe) l = deformation(conf.array, vector.array, self.pairs, None, r.array, self.cutoff, self.fc_length, self.factor, self.normalize, 0, self.version) return r
def particleValues(self): """ :returns: the values of the field at the positions of the atoms :rtype: :class:~MMTK.ParticleProperties.ParticleProperty """ universe = self.system.universe() rank = self.field.rank if rank == 0: v = ParticleProperties.ParticleScalar(universe) elif rank == 1: v = ParticleProperties.ParticleVector(universe) else: raise ValueError("no appropriate return type") for a in self.system.atomList(): v[a] = self.field(a.position()) return v
def charges(self, universe): q = ParticleProperties.ParticleScalar(universe) for object in universe: for atom in object.atomList(): q[atom] = object.getAtomProperty(atom, self.dataset.charge_property) return q
def fluctuations(self, first_mode=6): f = ParticleProperties.ParticleScalar(self.universe) for i in range(first_mode, self.nmodes): mode = self.rawMode(i) f += (mode * mode) / mode.inv_relaxation_time f = Units.k_B * self.temperature * f / self.friction return f
def fluctuations(self, first_mode=6): f = ParticleProperties.ParticleScalar(self.universe) for i in range(first_mode, self.nmodes): mode = self.rawMode(i) f += (mode * mode) / mode.force_constant if self.temperature is not None: f.array *= Units.k_B * self.temperature return f
def fluctuations(self, first_mode=6): """Returns a Class:MMTK.ParticleScalar containing the thermal fluctuations for each atom in the universe.""" f = ParticleProperties.ParticleScalar(self.universe) for i in range(first_mode, self.nmodes): mode = self.rawMode(i) f += (mode * mode) / mode.force_constant f.array *= Units.k_B * self.temperature return f
def fluctuations(self, first_mode=6): """Returns a Class:MMTK.ParticleScalar containing the thermal fluctuations for each atom in the universe.""" f = ParticleProperties.ParticleScalar(self.universe) for i in range(first_mode, self.nmodes): mode = self.rawMode(i) f += (mode * mode) / mode.inv_relaxation_time f = Units.k_B * self.temperature * f / self.friction return f
def anisotropicFluctuations(self, first_mode=6): f = ParticleProperties.ParticleTensor(self.universe) for i in range(first_mode, self.nmodes): mode = self.rawMode(i) array = mode.array f.array += (array[:, :, N.NewAxis]*array[:, N.NewAxis, :]) \ / mode.force_constant if self.temperature is not None: f.array *= Units.k_B * self.temperature return f
def fluctuations(self, first_mode=6): """Returns a Class:MMTK.ParticleScalar containing the thermal fluctuations for each atom in the universe.""" f = ParticleProperties.ParticleScalar(self.universe) for i in range(first_mode, self.nmodes): mode = self.rawMode(i) f += (mode * mode) / mode.frequency**2 f.array /= self.weights[:, 0]**2 f.array *= Units.k_B * self.temperature / (2. * N.pi)**2 return f
def anisotropicFluctuations(self, first_mode=6): """Returns a Class:MMTK.ParticleTensor containing the thermal fluctuations for each atom in the universe.""" f = ParticleProperties.ParticleTensor(self.universe) for i in range(first_mode, self.nmodes): mode = self.rawMode(i) array = mode.array f.array += (array[:, :, N.NewAxis]*array[:, N.NewAxis, :]) \ / mode.force_constant f.array *= Units.k_B * self.temperature return f
def fluctuations(self, first_mode=6): f = ParticleProperties.ParticleScalar(self.universe) for i in range(first_mode, self.nmodes): mode = self.rawMode(i) f += (mode * mode) / mode.frequency**2 f.array /= self.weights[:, 0]**2 s = 1. / (2. * N.pi)**2 if self.temperature is not None: s *= Units.k_B * self.temperature f.array *= s return f
def complement(self): """ :returns: the orthogonal complement subspace :rtype: :class:~MMTK.Subspace.Subspace """ basis = [] for i in range(self.universe.numberOfAtoms()): for e in [ex, ey, ez]: p = ParticleProperties.ParticleVector(self.universe) p[i] = e basis.append(self.projectionComplementOf(p)) return Subspace(self.universe, basis)
def projectionOf(self, vector): """ :param vector: a particle vector :type vector: :class:~MMTK.ParticleProperties.ParticleVector :returns: the projection of the vector onto the subspace. """ vector = vector.array basis = self.getBasis().array p = N.zeros(vector.shape, N.Float) for bv in basis: N.add(N.add.reduce(N.ravel(bv*vector))*bv, p, p) return ParticleProperties.ParticleVector(self.universe, p)
def EISF(self, q_range=(0., 15.), subset=None, weights=None, random_vectors=15, first_mode=6): """ :param q_range: the range of angular wavenumber values :type q_range: tuple :param subset: the subset of the universe used in the calculation (default: the whole universe) :type subset: :class:~MMTK.Collections.GroupOfAtoms :param weights: the weight to be given to each atom in the average (default: incoherent scattering lengths) :type weights: :class:~MMTK.ParticleProperties.ParticleScalar :param random_vectors: the number of random direction vectors used in the orientational average :type random_vectors: int :param first_mode: the first mode to be taken into account for the fluctuation calculation. The default value of 6 is right for molecules in vacuum. :type first_mode: int :returns: the Elastic Incoherent Structure Factor (EISF) as a function of angular wavenumber :rtype: Scientific.Functions.Interpolation.InterpolatingFunction """ if subset is None: subset = self.universe if weights is None: weights = self.universe.getParticleScalar('b_incoherent') weights = weights * weights weights = weights * subset.booleanMask() total = weights.sumOverParticles() weights = weights / total first, last, step = (q_range + (None, ))[:3] if step is None: step = (last - first) / 50. q = N.arange(first, last, step) f = ParticleProperties.ParticleTensor(self.universe) for i in range(first_mode, self.nmodes): mode = self.rawMode(i) f = f + (1. / mode.inv_relaxation_time) * mode.dyadicProduct(mode) f = Units.k_B * self.temperature * f / self.friction eisf = N.zeros(q.shape, N.Float) random_vectors = Random.randomDirections(random_vectors) for v in random_vectors: for a in subset.atomList(): exp = N.exp(-v * (f[a] * v)) N.add(eisf, weights[a] * exp**(q * q), eisf) return InterpolatingFunction((q, ), eisf / len(random_vectors))
def randomParticleVector(universe, width): """ :param universe: a universe :type universe: :class:`~MMTK.Universe.Universe` :param width: the width (standard deviation) of a Gaussian distribution :type width: float :returns: a set of vectors drawn from a Gaussian distribution with a given width centered around zero. :rtype: :class:`~MMTK.ParticleProperties.ParticleVector` """ data = gaussian(0., 0.577350269189 * width, (universe.numberOfPoints(), 3)) return ParticleProperties.ParticleVector(universe, data)
def __call__(self, vector, gradients = None): conf = self.universe.configuration() g = None if gradients is not None: if ParticleProperties.isParticleProperty(gradients): g = gradients elif isinstance(gradients, N.array_type): g = ParticleProperties.ParticleVector(self.universe, gradients) elif gradients: g = ParticleProperties.ParticleVector(self.universe) if g is None: g_array = None else: g_array = g.array l = deformation(conf.array, vector.array, self.pairs, g_array, None, self.cutoff, self.fc_length, self.factor, 0, 1, self.version) if g is None: return l else: return l, g
def anisotropicFluctuations(self, first_mode=6): f = ParticleProperties.ParticleTensor(self.universe) for i in range(first_mode, self.nmodes): mode = self.rawMode(i) array = mode.array f.array += (array[:, :, N.NewAxis]*array[:, N.NewAxis, :]) \ / mode.frequency**2 s = (2. * N.pi)**2 if self.temperature is not None: s /= Units.k_B * self.temperature f.array /= s * self.universe.masses().array[:, N.NewAxis, N.NewAxis] return f
def __call__(self, **options): # Process the keyword arguments self.setCallOptions(options) # Check if the universe has features not supported by the integrator Features.checkFeatures(self, self.universe) # Get the universe variables needed by the integrator configuration = self.universe.configuration() masses = self.universe.masses() velocities = self.universe.velocities() if velocities is None: raise ValueError("no velocities") # Get the friction coefficients. First check if a keyword argument # 'friction' was given to the integrator. Its value can be a # ParticleScalar or a plain number (used for all atoms). If no # such argument is given, collect the values of the attribute # 'friction' from all atoms (default is zero). try: friction = self.getOption('friction') except KeyError: friction = self.universe.getParticleScalar('friction') if not ParticleProperties.isParticleProperty(friction): var = ParticleProperties.ParticleScalar(self.universe) var.array[:] = friction friction = var # Construct a C evaluator object for the force field, using # the specified number of threads or the default value nt = self.getOption('threads') evaluator = self.universe.energyEvaluator(threads=nt).CEvaluator() # Run the C integrator MMTK_langevin.integrateLD(self.universe, configuration.array, velocities.array, masses.array, friction.array, evaluator, self.getOption('temperature'), self.getOption('delta_t'), self.getOption('steps'), self.getActions())
def displacementUnderTransformation(self, t): """ :param t: the transformation to be applied :type t: Scientific.Geometry.Transformation :returns: the displacement vectors for the atoms in the object that correspond to the transformation t. :rtype: :class:~MMTK.ParticleProperties.ParticleVector """ d = ParticleProperties.ParticleVector(self.universe()) for a in self.atomIterator(): r = a.position() d[a] = t(r) - r return d
def __init__(self, universe, atom_pairs): """ :param universe: the universe for which the subspace is created :type universe: :class:~MMTK.Universe.Universe :param atom_pairs: a sequence of atom pairs whose distance-vector motion is included in the subspace """ vectors = [] for atom1, atom2 in atom_pairs: v = ParticleProperties.ParticleVector(universe) distance = atom1.position()-atom2.position() v[atom1] = distance v[atom2] = -distance vectors.append(v) Subspace.__init__(self, universe, vectors)
def booleanMask(self): """ :returns: a ParticleScalar object that contains a value of 1 for each atom that is in the object and a value of 0 for all other atoms in the universe :rtype: :class:~MMTK.ParticleProperties.ParticleScalar """ universe = self.universe() if universe is None: raise ValueError("object not in a universe") array = N.zeros((universe.numberOfAtoms(), ), N.Int) mask = ParticleProperties.ParticleScalar(universe, array) for a in self.atomIterator(): mask[a] = 1 return mask
def __call__(self, gradients=None, force_constants=None, small_change=False): self.checkUniverseVersion() args = [self.configuration.array] if ParticleProperties.isParticleProperty(gradients): args.append(gradients.array) elif isinstance(gradients, N.array_type): gradients = \ ParticleProperties.ParticleVector(self.universe, gradients) args.append(gradients.array) elif gradients: gradients = ParticleProperties.ParticleVector(self.universe, None) args.append(gradients.array) else: args.append(None) if ParticleProperties.isParticleProperty(force_constants): args.append(force_constants.array) elif isinstance(force_constants, N.array_type): force_constants = \ ParticleProperties.SymmetricPairTensor(self.universe, force_constants) args.append(force_constants.array) else: sparse_type = None try: from MMTK_forcefield import SparseForceConstants sparse_type = type(SparseForceConstants(2, 2)) except ImportError: pass if isinstance(force_constants, sparse_type): args.append(force_constants) elif force_constants: force_constants = \ ParticleProperties.SymmetricPairTensor(self.universe, None) args.append(force_constants.array) else: args.append(None) args.append(small_change) self.universe.acquireReadStateLock() try: energy = apply(self.evaluator, tuple(args)) finally: self.universe.releaseReadStateLock() if force_constants: return energy, gradients, force_constants elif gradients: return energy, gradients else: return energy
def __init__(self, universe, cutoff): """ :param universe: the universe for which the basis will be used :type universe: :class:~MMTK.Universe.Universe :param cutoff: the wavelength cutoff. A smaller value yields a larger basis. :type cutoff: float """ p1, p2 = universe.boundingBox() p2 = p2 + Vector(cutoff, cutoff, cutoff) l = (p2 - p1).array n_max = (0.5 * l / cutoff + 0.5).astype(N.Int) wave_numbers = [(nx, ny, nz) for nx in range(-n_max[0], n_max[0]+1) for ny in range(-n_max[1], n_max[1]+1) for nz in range(-n_max[2], n_max[2]+1) if (nx/l[0])**2 + (ny/l[1])**2 + (nz/l[2])**2 \ < 0.25/cutoff**2] atoms = universe.atomList() natoms = len(atoms) basis = N.zeros((3 * len(wave_numbers) + 3, natoms, 3), N.Float) cm = universe.centerOfMass() i = 0 for rotation in [ Vector(1., 0., 0.), Vector(0., 1., 0.), Vector(0., 0., 1.) ]: v = ParticleProperties.ParticleVector(universe, basis[i]) for a in atoms: v[a] = rotation.cross(a.position() - cm) i += i conf = universe.configuration().array - p1.array for n in wave_numbers: k = 2. * N.pi * N.array(n) / l w = self._w(conf[:, 0], k[0]) * self._w(conf[:, 1], k[1]) * \ self._w(conf[:, 2], k[2]) basis[i, :, 0] = w basis[i + 1, :, 1] = w basis[i + 2, :, 2] = w i += 3 self.array = basis self.universe = universe
def __call__(self, vector, gradients = None): conf = self.universe.configuration() g = None if gradients is not None: if ParticleProperties.isParticleProperty(gradients): g = gradients elif isinstance(gradients, N.array_type): g = ParticleProperties.ParticleVector(self.universe, gradients) elif gradients: g = ParticleProperties.ParticleVector(self.universe) if g is None: g_array = None else: g_array = g.array l = deformation(conf.array, vector.array, self.pairs, g_array, None, self.cutoff, self.fc_length, self.factor, 0, 1, self.version) if g is None: return l else: return l, g
def __getitem__(self, item): return ParticleProperties.ParticleVector(self.universe, self.array[item])
def __init__(self, universe, objects): """ :param universe: the universe for which the subspace is created :type universe: :class:~MMTK.Universe.Universe :param objects: a sequence of objects whose rigid-body motion is included in the subspace """ if not Utility.isSequenceObject(objects): objects = [objects] else: objects = copy.copy(objects) # Identify connected sets of linked rigid bodies and remove # them from the plain rigid body list. atom_map = {} for o in objects: for a in o.atomIterator(): am = atom_map.get(a, []) am.append(o) atom_map[a] = am rb_map = {} for rbs in atom_map.values(): if len(rbs) > 1: for rb in rbs: rb_map[rb] = rb_map.get(rb, frozenset()) \ .union(frozenset(rbs)) for rb in rb_map.keys(): objects.remove(rb) while True: changed = False for rbs in rb_map.values(): for rb in rbs: s = rb_map[rb] rb_map[rb] = s.union(rbs) if s != rb_map[rb]: changed = True if not changed: break lrbs = frozenset(rb_map.values()) # Generate the subspace vectors for the isolated rigid bodies. ex_ey_ez = [Vector(1.,0.,0.), Vector(0.,1.,0.), Vector(0.,0.,1.)] vectors = [] for o in objects: rb_atoms = o.atomList() for d in ex_ey_ez: v = ParticleProperties.ParticleVector(universe) for a in rb_atoms: v[a] = d vectors.append(v/N.sqrt(len(rb_atoms))) if len(rb_atoms) > 1: center = o.centerOfMass() iv = len(vectors)-3 for d in ex_ey_ez: v = ParticleProperties.ParticleVector(universe) for a in rb_atoms: v[a] = d.cross(a.position()-center) for vt in vectors[iv:]: v -= v.dotProduct(vt)*vt norm_sq = N.sqrt(v.dotProduct(v)) if norm_sq > 0.: vectors.append(v/norm_sq) # Generate the subspace vectors for the linked rigid bodies. for lrb in lrbs: lrb_ss = LinkedRigidBodyMotionSubspace(universe, lrb) for v in lrb_ss.getBasis(): vectors.append(v) Subspace.__init__(self, universe, vectors) # The vector set is already orthonormal by construction, # so we can skip the lengthy SVD procedure. self._basis = ParticleVectorSet(universe, len(vectors)) for i in range(len(vectors)): self._basis.array[i] = vectors[i].array
def __getitem__(self, i): if i >= self.n: raise IndexError return ParticleProperties.ParticleVector(self.universe, self.array[i])