def mouseReleaseEvent(self, event):
     button = event.button()
     self.setCursor(Qt.arrowCursor)
     if button == Qt.LeftButton:
         try:
             dx = event.x() - self.click1x
             dy = event.y() - self.click1y
         except AttributeError:
             return
         if dx != 0 or dy != 0:
             normal = Vector(self.axis)
             move = Vector(-dx*self.plane[:,0]+dy*self.plane[:,1])
             axis = normal.cross(move) / \
                    N.minimum.reduce(N.fabs(self.plotbox_size))
             rot = Rotation(axis.normal(), axis.length())
             self.axis = rot(normal).array
             self.plane[:,0] = rot(Vector(self.plane[:,0])).array
             self.plane[:,1] = rot(Vector(self.plane[:,1])).array
     elif button == Qt.MidButton:
         try:
             dx = event.x() - self.click2x
             dy = event.y() - self.click2y
         except AttributeError:
             return
         if dx != 0 or dy != 0:
             self.translate = self.translate + N.array([dx, dy])
     else:
         try:
             dy = event.y() - self.click3y
         except AttributeError:
             return
         if dy != 0:
             ratio = -dy/self.plotbox_size[1]
             self.scale = self.scale * (1.+ratio)
     self.update()
Пример #2
0
def evaluationPoints(object, n, smallest=0.3, largest=0.5):
    """Returns a list of |n| points suitable for the evaluation of
    the electrostatic potential around |object|. The points are chosen
    at random and uniformly in a shell around the object such that
    no point has a distance larger than |largest| from any atom or
    smaller than |smallest| from any non-hydrogen atom.
    """
    atoms = object.atomList()
    p1, p2 = object.boundingBox()
    margin = Vector(largest, largest, largest)
    p1 = p1 - margin
    p2 = p2 + margin
    a, b, c = tuple(p2 - p1)
    offset = 0.5 * Vector(a, b, c)
    points = []
    while len(points) < n:
        p = p1 + Random.randomPointInBox(a, b, c) + offset
        m = 2 * largest
        ok = 1
        for atom in atoms:
            d = (p - atom.position()).length()
            m = min(m, d)
            if d < smallest and atom.symbol != 'H':
                ok = 0
            if not ok: break
        if ok and m <= largest:
            points.append(p)
    return points
Пример #3
0
    def _userdefined_qvectors(self):

        hkls = self._generate_hkls()

        if self.universe.reciprocalBasisVectors() is None:

            qVects = [Vector(v) for v in hkls]

        else:

            qVects = [self.transRecBasis * Vector(hkl) for hkl in hkls]

        qVectsDict = {}

        for i in range(len(qVects)):

            qVect = qVects[i]
            hkl = Vector(hkls[i])

            qLength = round(qVect.length(), 3)

            if qVectsDict.has_key(qLength):
                qVectsDict[qLength]["qvect"].append(qVect)
                qVectsDict[qLength]["hkl"].append(hkl)

            else:
                qVectsDict[qLength] = {"qvect": [qVect], "hkl": [hkl]}

        for q in sorted(qVectsDict.keys()):
            self.qRadii.append(q)
            self.qVectors.append(qVectsDict[q]["qvect"])
            self.hkls.append(qVectsDict[q]["hkl"])
Пример #4
0
    def _explicit_qvectors(self, qMin, qMax, indRange):

        qVects = []
        hkls = []

        dimen = len(self.qDirections)

        for ind in indRange:

            qVect = Vector()
            for i in range(dimen):
                qVect += ind[i] * self.qDirections[i]

            if qMin < qVect.length() <= qMax:

                if not qVect in qVects:

                    qVects.append(qVect)

                    hkl = Vector([0, 0, 0])
                    for i in range(dimen):
                        hkl += ind[i] * self.hkl_dir[i]

                    hkls.append(hkl)

                    if len(qVects) >= self.qVectorsPerShell:
                        break

        LogMessage(
            'info', '%d explicit Q vectors generated for shell [%s,%s].' %
            (len(qVects), qMin, qMax), ['file', 'console'])

        return qVects, hkls
Пример #5
0
    def __init__(self, cellsize, cells, function=None, base=None):
        """
        @param cellsize: the edge length of the cubic elementary cell
        @type cellsize: C{float}
        
        @param cells: a tuple of three integers, indicating how often the
                      elementary cell should be replicated along each
                      lattice vector
        @param cells: C{tuple} of C{int}

        @param function: the function to be applied to each point in the
                         lattice in order to obtain the value stored in the
                         lattice. If no function is specified, the point
                         itself becomes the value stored in the lattice.
        @type function: callable
        
        @param base: an offset added to all lattice points
        @type base: L{Scientific.Geometry.Vector}
        """
        lattice_vectors = (cellsize * Vector(1., 0., 0.),
                           cellsize * Vector(0., 1., 0.),
                           cellsize * Vector(0., 0., 1.))
        if type(cells) != type(()):
            cells = 3 * (cells, )
        BravaisLattice.__init__(self, lattice_vectors, cells, function, base)
    def __init__(self, cellsize, cells, function=None, base=None):
	lattice_vectors = (cellsize*Vector(1., 0., 0.),
                           cellsize*Vector(0., 1., 0.),
                           cellsize*Vector(0., 0., 1.))
	if type(cells) != type(()):
	    cells = 3*(cells,)
	BravaisLattice.__init__(self, lattice_vectors, cells, function, base)
Пример #7
0
def basisVectors(parameters):
    """Returns the basis vectors for the simulation cell from the six crystallographic parameters.
    
    @param parameters: the a, b, c, alpha, bete and gamma of the simulation cell.
    @type: parameters: list of 6 floats
    
    @return: a list of three Scientific.Geometry.Vector objects representing respectively a, b and c 
        basis vectors.
    @rtype: list
    """

    # The simulation cell parameters.
    a, b, c, alpha, beta, gamma = parameters

    # By construction the a vector is aligned with the x axis.
    e1 = Vector(a, 0.0, 0.0)

    # By construction the b vector is in the xy plane.
    e2 = b * Vector(N.cos(gamma), N.sin(gamma), 0.0)

    e3_x = N.cos(beta)
    e3_y = (N.cos(alpha) - N.cos(beta) * N.cos(gamma)) / N.sin(gamma)
    e3_z = N.sqrt(1.0 - e3_x**2 - e3_y**2)
    e3 = c * Vector(e3_x, e3_y, e3_z)

    return (e1, e2, e3)
Пример #8
0
 def asuToUnitCell(self, asu_contents, compact=True):
     """
     :param asu_contents: the molecules in the asymmetric unit, usually
                          obtained from :func:~MMTK.PDB.PDBConfiguration.createAll().
     :param compact: if True, all molecules images are shifted such that
                     their centers of mass lie inside the unit cell.
     :type compact: bool
     :returns: a collection containing all molecules in the unit cell,
               obtained by copying and moving the molecules from the
               asymmetric unit according to the crystallographic
               symmetry operations.
     :rtype: :class:~MMTK.Collections.Collection
     """
     unit_cell_contents = Collections.Collection()
     for symop in self.cs_transformations:
         transformation = symop.asLinearTransformation()
         rotation = transformation.tensor
         translation = transformation.vector
         image = copy.deepcopy(asu_contents)
         for atom in image.atomList():
             atom.setPosition(symop(atom.position()))
         if compact:
             cm = image.centerOfMass()
             cm_fr = self.to_fractional(cm)
             cm_fr = Vector(cm_fr[0] % 1., cm_fr[1] % 1., cm_fr[2] % 1.) \
                     - Vector(0.5, 0.5, 0.5)
             cm = self.from_fractional(cm_fr)
             image.translateTo(cm)
         unit_cell_contents.addObject(image)
     return unit_cell_contents
Пример #9
0
def anchor(universe):
	"""Anchor a universe"""
	if(universe.numberOfAtoms() >=3):
		#set anchor atoms indexes	
		a1i	= 0
		for i in range(len(universe.atomList()[a1i].bondedTo())):
			for j in range(len(universe.atomList()[a1i].bondedTo()[i].bondedTo())):
				if universe.atomList()[a1i] is not \
					universe.atomList()[a1i].bondedTo()[i].bondedTo()[j] :
					a2i = i;
					a3i = j;
					break
		print 'anchor using: ', a1i, a2i, a3i
		
		v1 = universe.atomList()[a1i].position();
		v2 = universe.atomList()[a1i].bondedTo()[a2i].position();
		v3 = universe.atomList()[a1i].bondedTo()[a2i].bondedTo()[a3i].position();
	
		vT01 = -v1;
		tra01 = Translation(vT01);
		universe.applyTransformation(tra01);
	
	
		x = universe.atomList()[a1i].bondedTo()[a2i].position().x();
		y = 0;
		z = universe.atomList()[a1i].bondedTo()[a2i].position().z();
		vR01 = Vector(x,y,z);
		vR02 = Vector(1,0,0);
	
		sign = 1.0
		if ((z > 0) and (x > 0)) or ((z < 0) and (x < 0)):
			sign = -1.0
		
		rot01 = Rotation(Vector(0,1,0), sign*vR01.angle(vR02));
		universe.applyTransformation(rot01);
	
		v4 = universe.atomList()[a1i].bondedTo()[a2i].position();
	
		sign = -1.0
		if ((x > 0) and (y > 0)) or ((x < 0) and (y < 0)):
			sign = 1.0
		rot02 = Rotation(Vector(0,0,1), sign*v4.angle(Vector(1,0,0)));
		universe.applyTransformation(rot02);
	
		x = 0;
		y = universe.atomList()[a1i].bondedTo()[a2i].bondedTo()[a3i].position().y();
		z = universe.atomList()[a1i].bondedTo()[a2i].bondedTo()[a3i].position().z();
	
		sign = 1.0
		if ((z > 0) and (y > 0)) or ((z < 0) and (y < 0)):
			sign = -1.0
	
		vR03 = Vector(x,y,z);
		vR04 = Vector(0,1,0);
		rot03 = Rotation(Vector(1,0,0), sign*vR03.angle(vR04));
		universe.applyTransformation(rot03);
	
	else:
		print "Molecule too little to be anchored";
Пример #10
0
def superpositionFit(confs):
    """
    :param confs: the weight, reference position, and alternate
                  position for each atom
    :type confs: sequence of (float, Vector, Vector)
    :returns: the quaternion representing the rotation,
              the center of mass in the reference configuration,
              the center of mass in the alternate configuraton,
              and the RMS distance after the optimal superposition
    """
    w_sum = 0.
    wr_sum = N.zeros((3, ), N.Float)
    for w, r_ref, r in confs:
        w_sum += w
        wr_sum += w * r_ref.array
    ref_cms = wr_sum / w_sum
    pos = N.zeros((3, ), N.Float)
    possq = 0.
    cross = N.zeros((3, 3), N.Float)
    for w, r_ref, r in confs:
        w = w / w_sum
        r_ref = r_ref.array - ref_cms
        r = r.array
        pos = pos + w * r
        possq = possq + w*N.add.reduce(r*r) \
                      + w*N.add.reduce(r_ref*r_ref)
        cross = cross + w * r[:, N.NewAxis] * r_ref[N.NewAxis, :]
    k = N.zeros((4, 4), N.Float)
    k[0, 0] = -cross[0, 0] - cross[1, 1] - cross[2, 2]
    k[0, 1] = cross[1, 2] - cross[2, 1]
    k[0, 2] = cross[2, 0] - cross[0, 2]
    k[0, 3] = cross[0, 1] - cross[1, 0]
    k[1, 1] = -cross[0, 0] + cross[1, 1] + cross[2, 2]
    k[1, 2] = -cross[0, 1] - cross[1, 0]
    k[1, 3] = -cross[0, 2] - cross[2, 0]
    k[2, 2] = cross[0, 0] - cross[1, 1] + cross[2, 2]
    k[2, 3] = -cross[1, 2] - cross[2, 1]
    k[3, 3] = cross[0, 0] + cross[1, 1] - cross[2, 2]
    for i in range(1, 4):
        for j in range(i):
            k[i, j] = k[j, i]
    k = 2. * k
    for i in range(4):
        k[i, i] = k[i, i] + possq - N.add.reduce(pos * pos)
    from Scientific import LA
    e, v = LA.eigenvectors(k)
    i = N.argmin(e)
    v = v[i]
    if v[0] < 0: v = -v
    if e[i] <= 0.:
        rms = 0.
    else:
        rms = N.sqrt(e[i])
    from Scientific.Geometry import Quaternion
    return Quaternion.Quaternion(v), Vector(ref_cms), \
           Vector(pos), rms
Пример #11
0
 def partitions(self):
     """Returns a list of cubic partitions. Each partition is specified
     by a tuple containing two vectors (describing the diagonally
     opposite corners) and the list of objects in the partition."""
     list = []
     for index, objects in self.partition.items():
         min = Vector(index) * self.partition_size
         max = min + Vector(3 * [self.partition_size])
         list.append((min, max, objects))
     return list
Пример #12
0
 def findTransformationAsQuaternion(self, conf1, conf2=None):
     universe = self.universe()
     if conf1.universe != universe:
         raise ValueError("conformation is for a different universe")
     if conf2 is None:
         conf1, conf2 = conf2, conf1
     else:
         if conf2.universe != universe:
             raise ValueError("conformation is for a different universe")
     ref = conf1
     conf = conf2
     weights = universe.masses()
     weights = weights / self.mass()
     ref_cms = self.centerOfMass(ref).array
     pos = Numeric.zeros((3, ), Numeric.Float)
     possq = 0.
     cross = Numeric.zeros((3, 3), Numeric.Float)
     for a in self.atomList():
         r = a.position(conf).array
         r_ref = a.position(ref).array - ref_cms
         w = weights[a]
         pos = pos + w * r
         possq = possq + w*Numeric.add.reduce(r*r) \
                       + w*Numeric.add.reduce(r_ref*r_ref)
         cross = cross + w * r[:,
                               Numeric.NewAxis] * r_ref[Numeric.NewAxis, :]
     k = Numeric.zeros((4, 4), Numeric.Float)
     k[0, 0] = -cross[0, 0] - cross[1, 1] - cross[2, 2]
     k[0, 1] = cross[1, 2] - cross[2, 1]
     k[0, 2] = cross[2, 0] - cross[0, 2]
     k[0, 3] = cross[0, 1] - cross[1, 0]
     k[1, 1] = -cross[0, 0] + cross[1, 1] + cross[2, 2]
     k[1, 2] = -cross[0, 1] - cross[1, 0]
     k[1, 3] = -cross[0, 2] - cross[2, 0]
     k[2, 2] = cross[0, 0] - cross[1, 1] + cross[2, 2]
     k[2, 3] = -cross[1, 2] - cross[2, 1]
     k[3, 3] = cross[0, 0] + cross[1, 1] - cross[2, 2]
     for i in range(1, 4):
         for j in range(i):
             k[i, j] = k[j, i]
     k = 2. * k
     for i in range(4):
         k[i, i] = k[i, i] + possq - Numeric.add.reduce(pos * pos)
     from Scientific import LA
     e, v = LA.eigenvectors(k)
     i = Numeric.argmin(e)
     v = v[i]
     if v[0] < 0: v = -v
     if e[i] <= 0.:
         rms = 0.
     else:
         rms = Numeric.sqrt(e[i])
     return Quaternion.Quaternion(v), Vector(ref_cms), \
            Vector(pos), rms
Пример #13
0
def rigidMovement(atoms, vector):
    a = N.zeros((len(atoms), 3, 2, 3), N.Float)
    b = N.zeros((len(atoms), 3), N.Float)
    for i in range(len(atoms)):
        a[i, :, 0, :] = delta.array
        a[i, :, 1, :] = (epsilon * atoms[i].position()).array
        b[i] = vector[atoms[i]].array
    a.shape = (3 * len(atoms), 6)
    b.shape = (3 * len(atoms), )
    vo = N.dot(LA.generalized_inverse(a), b)
    return Vector(vo[:3]), Vector(vo[3:])
Пример #14
0
    def __init__(self,atoms,outfile=None):
        
        unitcell = atoms.get_cell()
        A = Vector(unitcell[0])
        B = Vector(unitcell[1])
        C = Vector(unitcell[2])

        # lengths of the vectors
        a = A.length()#*angstroms2bohr
        b = B.length()#*angstroms2bohr
        c = C.length()#*angstroms2bohr

        # angles between the vectors
        rad2deg = 360./(2.*math.pi)
        alpha = B.angle(C)*rad2deg
        beta = A.angle(C)*rad2deg
        gamma = A.angle(B)*rad2deg

        scaledpositions = atoms.get_scaled_positions()
        chemicalsymbols = [atom.get_symbol() for atom in atoms]

        input = ''

        input += 'title \n'
        input += '0    tolerance\n'
        input += '2        lattice parameters in lengths and angles\n'
        input += '%1.3f %1.3f %1.3f %1.3f %1.3f %1.3f\n' % (a,b,c,
                                                            alpha,beta,gamma)
        input += '1  3 basis vectors for unit cell\n'

        input += '1.00 0.00 0.00\n'
        input += '0.00 1.00 0.00\n'
        input += '0.00 0.00 1.00\n'

        input += '%i   number of atoms\n' % len(atoms)

        types = ''
        for atom in atoms:
            types += str(atom.get_atomic_number()) + ' '

        input += types + '\n'

        for i,atom in enumerate(atoms):
            input += '%1.3f %1.3f %1.3f\n' % tuple(scaledpositions[i])

        pin,pout = os.popen2('findsym')
        pin.writelines(input)
        pin.close()
        self.output = pout.readlines()
        pout.close()

        if outfile:
            f = open(outfile,'w')
            f.writelines(self.output)
            f.close()

        if os.path.exists('findsym.log'):
            os.remove('findsym.log')
Пример #15
0
 def boundingBox(self, conf=None):
     """Returns two opposite corners of a bounding box around the
     object. The bounding box is the smallest rectangular bounding box
     with edges parallel to the coordinate axes."""
     atoms = self.atomList()
     min = atoms[0].position(conf).array
     max = min
     for a in atoms[1:]:
         r = a.position(conf).array
         min = Numeric.minimum(min, r)
         max = Numeric.maximum(max, r)
     return Vector(min), Vector(max)
Пример #16
0
 def evaluatorParameters(self, universe, subset1, subset2, global_data):
     rsum = not self.options.get('no_reciprocal_sum', 0)
     if not universe.is_periodic and rsum:
         raise ValueError("Ewald method accepts only periodic universes")
     if not universe.is_orthogonal and rsum:
         raise ValueError("Ewald method implemented only for orthogonal universes")
     n = universe.numberOfPoints()
     charge = N.zeros((n,), N.Float)
     for o in universe:
         for a in o.atomList():
             charge[a.index] = self._charge(o, a, global_data)
     charge = charge*N.sqrt(self.scale_factor)
     precision = self.options.get('ewald_precision', 1.e-6)
     p = N.sqrt(-N.log(precision))
     if rsum:
         beta_opt = N.sqrt(N.pi) * \
             (5.*universe.numberOfAtoms()/universe.cellVolume()**2)**(1./6.)
         max_cutoff = universe.largestDistance()
         beta_opt = max(p/max_cutoff, beta_opt)
     else:
         beta_opt = 0.01
     options = {}
     options['beta'] = beta_opt
     options['real_cutoff'] = p/beta_opt
     options['reciprocal_cutoff'] = N.pi/(beta_opt*p)
     options['no_reciprocal_sum'] = 0
     for key, value in self.options.items():
         options[key] = value
     lx = universe.boxToRealCoordinates(Vector(1., 0., 0.)).length()
     ly = universe.boxToRealCoordinates(Vector(0., 1., 0.)).length()
     lz = universe.boxToRealCoordinates(Vector(0., 0., 1.)).length()
     kmax = N.array([lx,ly,lz])/options['reciprocal_cutoff']
     kmax = N.ceil(kmax).astype(N.Int)
     excluded_pairs, one_four_pairs, atom_subset = \
                          self.excludedPairs(subset1, subset2, global_data)
     if atom_subset is not None:
         raise ValueError("Ewald summation not available for subsets")
     if options['no_reciprocal_sum']:
         kcutoff = 0.
     else:
         kcutoff = (2.*N.pi/options['reciprocal_cutoff'])**2
     return {'electrostatic': {'algorithm': 'ewald',
                               'charge': charge,
                               'real_cutoff': options['real_cutoff'],
                               'reciprocal_cutoff': kcutoff,
                               'beta': options['beta'],
                               'k_max': kmax,
                               'one_four_factor': self.es_14_factor},
             'nonbonded': {'excluded_pairs': excluded_pairs,
                           'one_four_pairs': one_four_pairs,
                           'atom_subset': atom_subset}
            }
Пример #17
0
    def _convertUnits(self):
        for residue in self.residues:
            for atom in residue:
                atom.position = atom.position * Units.Ang
                try:
                    b = atom.properties['temperature_factor']
                    atom.properties['temperature_factor'] = b * Units.Ang**2
                except KeyError:
                    pass
                try:
                    u = atom.properties['u']
                    atom.properties['u'] = u * Units.Ang**2
                except KeyError:
                    pass

        # All these attributes exist only if ScientificPython >= 2.7.5 is used.
        # The Scaling transformation was introduced with the same version,
        # so if it exists, the rest should work as well.
        try:
            from Scientific.Geometry.Transformation import Scaling
        except ImportError:
            return
        for attribute in ['a', 'b', 'c']:
            value = getattr(self, attribute)
            if value is not None:
                setattr(self, attribute, value * Units.Ang)
        for attribute in ['alpha', 'beta', 'gamma']:
            value = getattr(self, attribute)
            if value is not None:
                setattr(self, attribute, value * Units.deg)
        if self.to_fractional is not None:
            self.to_fractional = self.to_fractional * Scaling(1. / Units.Ang)
            v1 = self.to_fractional(Vector(1., 0., 0.))
            v2 = self.to_fractional(Vector(0., 1., 0.))
            v3 = self.to_fractional(Vector(0., 0., 1.))
            self.reciprocal_basis = (Vector(v1[0], v2[0], v3[0]),
                                     Vector(v1[1], v2[1], v3[1]),
                                     Vector(v1[2], v2[2], v3[2]))
        else:
            self.reciprocal_basis = None
        if self.from_fractional is not None:
            self.from_fractional = Scaling(Units.Ang) * self.from_fractional
            self.basis = (self.from_fractional(Vector(1., 0., 0.)),
                          self.from_fractional(Vector(0., 1., 0.)),
                          self.from_fractional(Vector(0., 0., 1.)))
        else:
            self.basis = None
        for i in range(len(self.ncs_transformations)):
            tr = self.ncs_transformations[i]
            tr_new = Scaling(Units.Ang) * tr * Scaling(1. / Units.Ang)
            tr_new.given = tr.given
            tr_new.serial = tr.serial
            self.ncs_transformations[i] = tr_new
        for i in range(len(self.cs_transformations)):
            tr = self.cs_transformations[i]
            tr_new = Scaling(Units.Ang) * tr * Scaling(1. / Units.Ang)
            self.cs_transformations[i] = tr_new
Пример #18
0
 def findPositions(self):
     # First atom at origin
     self.coordinates[self.data[0][0]] = Vector(0, 0, 0)
     # Second atom along x-axis
     self.coordinates[self.data[1][0]] = Vector(self.data[1][2], 0, 0)
     # Third atom in xy-plane
     try:
         pos1 = self.coordinates[self.data[2][1]]
     except KeyError:
         raise ValueError("atom %d has no defined position" %
                          self.data[2][1].number)
     try:
         pos2 = self.coordinates[self.data[2][3]]
     except KeyError:
         raise ValueError("atom %d has no defined position" %
                          self.data[2][3].number)
     sphere = Sphere(pos1, self.data[2][2])
     cone = Cone(pos1, pos2 - pos1, self.data[2][4])
     plane = Plane(Vector(0, 0, 0), Vector(0, 0, 1))
     points = sphere.intersectWith(cone).intersectWith(plane)
     self.coordinates[self.data[2][0]] = points[0]
     # All following atoms defined by distance + angle + dihedral
     for entry in self.data[3:]:
         try:
             pos1 = self.coordinates[entry[1]]
         except KeyError:
             raise ValueError("atom %d has no defined position" %
                              entry[1].number)
         try:
             pos2 = self.coordinates[entry[3]]
         except KeyError:
             raise ValueError("atom %d has no defined position" %
                              entry[3].number)
         try:
             pos3 = self.coordinates[entry[5]]
         except KeyError:
             raise ValueError("atom %d has no defined position" %
                              entry[5].number)
         distance = entry[2]
         angle = entry[4]
         dihedral = entry[6]
         sphere = Sphere(pos1, distance)
         cone = Cone(pos1, pos2 - pos1, angle)
         plane123 = Plane(pos3, pos2, pos1)
         points = sphere.intersectWith(cone).intersectWith(plane123)
         for p in points:
             if Plane(pos2, pos1, p).normal * plane123.normal > 0:
                 break
         p = rotatePoint(p, Line(pos1, pos2 - pos1), dihedral)
         self.coordinates[entry[0]] = p
Пример #19
0
    def test_P1(self):
        cell = UnitCell(Vector(1., 0., 0.), Vector(0., 1., 0.),
                        Vector(0., 0., 1.))
        res_max = 0.5
        res_min = 10.
        reflections = ReflectionSet(cell,
                                    space_groups['P 1'],
                                    res_max,
                                    res_min,
                                    compact=self.compact)
        self.assert_(reflections.isComplete())
        nr = sum([r.n_symmetry_equivalents for r in reflections]) + \
             sum([r.n_symmetry_equivalents
                  for r in reflections.systematic_absences])
        self.assertEqual(reflections.totalReflectionCount(), nr)
        self.assert_(reflections.totalReflectionCount() == 2 *
                     len(reflections.minimal_reflection_list))
        for r in reflections:
            self.assert_(len(r.symmetryEquivalents()) == 2)
            self.assert_(res_max <= r.resolution() <= res_min)
            self.assert_(not r.isCentric())
            self.assert_(r.symmetryFactor() == 1)
        self._shellTest(reflections)
        self._subsetTest(reflections)
        self._symmetryTest(reflections)
        self._intersectionTest(reflections)
        self._equalityTest(reflections)

        frozen = reflections.freeze()
        self.assert_(frozen is reflections.freeze())
        self.assert_(frozen is frozen.freeze())
        self.assert_(frozen.isComplete())
        self.assert_(frozen.totalReflectionCount() == 2 *
                     len(frozen._reflections))
        for r in frozen:
            self.assert_(reflections.hasReflection(r.h, r.k, r.l))
            self.assert_(len(r.symmetryEquivalents()) == 2)
            self.assert_(res_max <= r.resolution() <= res_min)
            self.assert_(not r.isCentric())
            self.assert_(r.symmetryFactor() == 1)
        for r in reflections:
            self.assert_(frozen.hasReflection(r.h, r.k, r.l))
            self.assert_(r.index == frozen[(r.h, r.k, r.l)].index)
        self._shellTest(frozen)
        self._subsetTest(frozen)
        self._symmetryTest(frozen)
        self._intersectionTest(frozen)
        self._equalityTest(frozen)
Пример #20
0
 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)
Пример #21
0
 def getPosition(self, atom_id):
     """
     :param atom_id: id of the atom whose position is requested
     :return: the position of the atom
     :rtype: Scientific.Geometry.Vector
     """
     return Vector(self.positions[self.id_dict[atom_id]])
Пример #22
0
    def initialize(self):
        """Initializes the analysis (e.g. parses and checks input parameters, set some variables ...).
        """

        # The input parameters are parsed.
        self.interpreteInputParameters()

        self.bondNames = {}

        for aIndexes in self.group:

            for at in self.universe.atomList():

                if at.index == aIndexes[0]:

                    if isinstance(at.topLevelChemicalObject(),
                                  (Protein, PeptideChain, NucleotideChain)):
                        self.bondNames[tuple(
                            aIndexes)] = at.parent.parent.sequence_number

                    else:
                        self.bondNames[tuple(aIndexes)] = at.index

                    break

        self.referenceDirection = Vector(0.0, 0.0, 1.0)

        # The results are stored in dictionnary because the order in which the bonds are treated does not
        # always follow the structure.
        self.P2 = {}
        self.S2 = {}
Пример #23
0
 def writeSpecification(self, file):
     d = 0.5 * self.edge
     semi_diag = Vector(d, d, d)
     file.writeString('.box')
     file.writeVector((self.center - semi_diag) * file.scale)
     file.writeVector((self.center + semi_diag) * file.scale)
     file.writeString('\n')
Пример #24
0
 def __init__(self,
              elementary_cell,
              lattice_vectors,
              cells,
              function=None,
              base=None):
     """
     :param elementary_cell: a list of points in the elementary cell
     :param lattice_vectors: a list of lattice vectors. Each lattice
                             vector defines a lattice dimension (only
                             values from one to three make sense) and
                             indicates the displacement along this
                             dimension from one cell to the next.
     :param cells: a list of integers, whose length must equal the number
                   of dimensions. Each entry specifies how often a cell is
                   repeated along this dimension.
     :param function: a function that is called for every lattice point with
                      the vector describing the point as argument. The return
                      value of this function is stored in the lattice object.
                      If the function is 'None', the vector is directly
                      stored in the lattice object.
     """
     if len(lattice_vectors) != len(cells):
         raise TypeError('Inconsistent dimension specification')
     if base is None:
         base = Vector(0, 0, 0)
     self.dimension = len(lattice_vectors)
     self.elements = []
     self.makeLattice(elementary_cell, lattice_vectors, cells, base)
     Lattice.__init__(self, function)
Пример #25
0
def cell_parameters(atoms, weight=1.0, cells=None):
    '''
    adds entries to CELL PARAMETERS for the unit cell geometry of the
    atoms object.
    '''

    description = reax_hash(atoms)

    # get all the parameters needed for a cell parameters block
    uc = atoms.get_cell()
    a, b, c = [Vector(x) for x in uc]
    A = a.length()
    B = b.length()
    C = c.length()

    rad2deg = 360. / (2 * math.pi)
    alpha = b.angle(c) * rad2deg
    beta = a.angle(c) * rad2deg
    gamma = a.angle(b) * rad2deg

    cells['CELL PARAMETERS'].append('# created by reax.trainset')
    # this is an org-link to the geo file
    #cells['CELL PARAMETERS'].append('# file:geo::%s' % description)
    for key, val in [('a', A), ('b', B), ('c', C), ('alpha', alpha),
                     ('beta', beta), ('gamma', gamma)]:
        s = '%(description)s %(weight)f %(key)s %(val)s' % locals()
        if s not in cells['CELL PARAMETERS']:
            cells['CELL PARAMETERS'].append(s)

    return cells
Пример #26
0
def gradientTest(universe, atoms=None, delta=0.0001):
    """
    Test gradients by comparing to numerical derivatives of the energy.

    :param universe: the universe on which the test is performed
    :type universe: :class:`~MMTK.Universe.Universe`
    :param atoms: the atoms of the universe for which the gradient
                  is tested (default: all atoms)
    :type atoms: list
    :param delta: the step size used in calculating the numerical derivatives
    :type delta: float
    """
    e0, grad = universe.energyAndGradients()
    print 'Energy: ', e0
    if atoms is None:
        atoms = universe.atomList()
    for a in atoms:
        print a
        print grad[a]
        num_grad = []
        for v in [ex, ey, ez]:
            x = a.position()
            a.setPosition(x + delta * v)
            eplus = universe.energy()
            a.setPosition(x - delta * v)
            eminus = universe.energy()
            a.setPosition(x)
            num_grad.append(0.5 * (eplus - eminus) / delta)
        print Vector(num_grad)
Пример #27
0
 def parseAtom(self, element):
     atom_spec = {
         'atom_id':
         element.get('id', None),
         'element':
         element.find(self.prefix + 'type_symbol').text,
         'name':
         element.find(self.prefix + 'label_atom_id').text,
         'alt_id':
         element.find(self.prefix + 'label_alt_id').text,
         'model':
         int(element.find(self.prefix + 'pdbx_PDB_model_num').text),
         'comp_id':
         element.find(self.prefix + 'label_comp_id').text,
         'asym_id':
         element.find(self.prefix + 'label_asym_id').text,
         'entity_id':
         element.find(self.prefix + 'label_entity_id').text,
         'position':
         Vector(float(element.find(self.prefix + 'Cartn_x').text),
                float(element.find(self.prefix + 'Cartn_y').text),
                float(element.find(self.prefix + 'Cartn_z').text)),
         'occupancy':
         float(element.find(self.prefix + 'occupancy').text),
         'beta':
         float(element.find(self.prefix + 'B_iso_or_equiv').text),
     }
     seq_id = element.find(self.prefix + 'label_seq_id').text
     if seq_id is None:
         atom_spec['seq_id'] = None
     else:
         atom_spec['seq_id'] = int(seq_id)
     return atom_spec
Пример #28
0
    def __init__(self,
                 elementary_cell,
                 lattice_vectors,
                 cells,
                 function=None,
                 base=None):
        """
        @param elementary_cell: a list of the points in the elementary cell
        @type elementary_cell: C{list} of L{Scientific.Geometry.Vector}

        @param lattice_vectors: the edges of the elementary cell
        @type lattice_vectors: C{tuple} of three L{Scientific.Geometry.Vector}
        
        @param cells: a tuple of three integers, indicating how often the
                      elementary cell should be replicated along each
                      lattice vector
        @param cells: C{tuple} of C{int}

        @param function: the function to be applied to each point in the
                         lattice in order to obtain the value stored in the
                         lattice. If no function is specified, the point
                         itself becomes the value stored in the lattice.
        @type function: callable
        
        @param base: an offset added to all lattice points
        @type base: L{Scientific.Geometry.Vector}
        """
        if len(lattice_vectors) != len(cells):
            raise TypeError('Inconsistent dimension specification')
        if base is None:
            base = Vector(0, 0, 0)
        self.dimension = len(lattice_vectors)
        self.elements = []
        self.makeLattice(elementary_cell, lattice_vectors, cells, base)
        Lattice.__init__(self, function)
Пример #29
0
 def centerAndMomentOfInertia(self, conf=None):
     """
     :param conf: a configuration object, or None for the
                  current configuration
     :type conf: :class:~MMTK.ParticleProperties.Configuration or NoneType
     :returns: the center of mass and the moment of inertia tensor
               in the given configuration
     """
     from Scientific.Geometry import delta
     offset = None
     universe = self.universe()
     if universe is not None:
         offset = universe.contiguousObjectOffset([self], conf)
     m = 0.
     mr = Vector(0., 0., 0.)
     t = Tensor(3 * [3 * [0.]])
     for a in self.atomIterator():
         ma = a._mass
         if offset is None:
             r = a.position(conf)
         else:
             r = a.position(conf) + offset[a]
         m += ma
         mr += ma * r
         t += ma * r.dyadicProduct(r)
     cm = mr / m
     t -= m * cm.dyadicProduct(cm)
     t = t.trace() * delta - t
     return cm, t
Пример #30
0
    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
Пример #31
0
 def momentum(self, velocities=None):
     "Returns the momentum."
     if velocities is None:
         velocities = self.atomList()[0].universe().velocities()
     p = Vector(0., 0., 0.)
     for a in self.atomList():
         p = p + a._mass * velocities[a]
     return p
Пример #32
0
 def __init__(self, points, **attr):
     """
     @param points: a sequence of points to be connected by lines
     @type points: sequence of L{Scientific.Geometry.Vector}
     @param attr: graphics attributes as keyword parameters
     """
     self.points = points
     ShapeObject.__init__(self, attr, None, None, Vector(0., 0., 0.))
def randomPointInSphere(r):
    """Returns a vector drawn from a uniform distribution within
    a sphere of radius |r|."""
    rsq = r * r
    while 1:
        x = N.array([uniform(-r, r), uniform(-r, r), uniform(-r, r)])
        if N.dot(x, x) < rsq: break
    return Vector(x)
Пример #34
0
    def __init__(self,atoms,outfile=None):
        
        unitcell = atoms.get_cell()
        A = Vector(unitcell[0])
        B = Vector(unitcell[1])
        C = Vector(unitcell[2])

        # lengths of the vectors
        a = A.length()#*angstroms2bohr
        b = B.length()#*angstroms2bohr
        c = C.length()#*angstroms2bohr

        # angles between the vectors
        rad2deg = 360./(2.*math.pi)
        alpha = B.angle(C)*rad2deg
        beta = A.angle(C)*rad2deg
        gamma = A.angle(B)*rad2deg

        scaledpositions = atoms.get_scaled_positions()
        chemicalsymbols = [atom.get_symbol() for atom in atoms]

        input = ''
        input += '%1.3f %1.3f %1.3f %1.3f %1.3f %1.3f\n' % (a,b,c,
                                                            alpha,beta,gamma)
        input += '1 1 0.1 0.1\n' 

        for atom in atoms:
            sym = atom.get_symbol()
            group = 1
            x,y,z = atom.get_position()
            #format(a6,i2,6f9.5)
            input += str(FortranLine((sym,
                                      group,
                                      x,y,z),
                                     FortranFormat('a6,i2,3f9.5')))+'\n'
                    
        pin,pout = os.popen2('symmol')
        pin.writelines(input)
        pin.close()
        self.output = pout.readlines()
        pout.close()

        if outfile:
            f = open(outfile,'w')
            f.writelines(self.output)
            f.close()

        if os.path.exists('symmol.log'):
            os.remove('symmol.log')
    def releasehandler1(self, event):
	self.configure(cursor='top_left_arrow')
	self.update_idletasks()
        try:
            dx = event.x - self.click1x
            dy = event.y - self.click1y
        except AttributeError:
            return
        if dx != 0 or dy != 0:
            normal = Vector(self.axis)
            move = Vector(-dx*self.plane[:,0]+dy*self.plane[:,1])
            axis = normal.cross(move) / \
                   Numeric.minimum.reduce(Numeric.fabs(self.plotbox_size))
            rot = Rotation(axis.normal(), axis.length())
            self.axis = rot(normal).array
            self.plane[:,0] = rot(Vector(self.plane[:,0])).array
            self.plane[:,1] = rot(Vector(self.plane[:,1])).array
            self.clear(1)
            self.redraw()
Пример #36
0
    def set_axis(self, axis):
                        
        try:
            self._axis = Vector(axis)
        except (TypeError,ValueError):
            raise ProjectorError('Wrong axis definition: must be a sequence of 3 floats')
        
        try:
            self._axis = self._axis.normal()
        except ZeroDivisionError:
            raise ProjectorError('The axis vector can not be the null vector')

        self._projectionMatrix = numpy.identity(3) - numpy.outer(self._axis, self._axis)
Пример #37
0
class PlanarProjector(IProjector):

    type = 'planar'

    def set_axis(self, axis):
                        
        try:
            self._axis = Vector(axis)
        except (TypeError,ValueError):
            raise ProjectorError('Wrong axis definition: must be a sequence of 3 floats')
        
        try:
            self._axis = self._axis.normal()
        except ZeroDivisionError:
            raise ProjectorError('The axis vector can not be the null vector')

        self._projectionMatrix = numpy.identity(3) - numpy.outer(self._axis, self._axis)

    def __call__(self, value):

        try:        
            return numpy.dot(value,self._projectionMatrix.T)
        except (TypeError,ValueError):
            raise ProjectorError("Invalid data to apply projection on")
Пример #38
0
'''
Gstar = np.dot(G, G.T)
id2 = np.dot(hkl, np.dot(Gstar, hkl))
print('d_111 spacing (method 2) =',np.sqrt(1 / id2))
# http://books.google.com/books?id=nJHSqEseuIUC&lpg=PA118&ots=YA9TBldoVH
# &dq=reciprocal%20metric%20tensor&pg=PA119#v=onepage
# &q=reciprocal%20metric%20tensor&f=false
'''Finally, many text books on crystallography use long algebraic
formulas for computing the d-spacing with sin and cos, vector lengths,
and angles. Below we compute these and use them in the general
triclinic structure formula which applies to all the structures.
'''
from Scientific.Geometry import Vector
import math
unitcell = ag.get_cell()
A = Vector(unitcell[0])
B = Vector(unitcell[1])
C = Vector(unitcell[2])
# lengths of the vectors
a = A.length()#*angstroms2bohr
b = B.length()#*angstroms2bohr
c = C.length()#*angstroms2bohr
# angles between the vectors in radians
alpha = B.angle(C)
beta = A.angle(C)
gamma = A.angle(B)
print('')
print('a   b   c   alpha beta gamma')
print('{0:1.3f} {1:1.3f} {2:1.3f} {3:1.3f} {4:1.3f} {5:1.3f}\n'.format(a,b,c,                                                                alpha,beta,gamma))
h, k, l = (1, 1, 1)
from math import sin, cos
Пример #39
0
import numpy as np
from Scientific.Geometry import Vector
A = Vector([1,1,1])   #Scientfic
a = np.array([1,1,1]) #numpy
B = Vector([0.0,1.0,0.0])
print '|A| = ',A.length()        #Scientific Python way
print '|a| = ',np.sum(a**2)**0.5 #numpy way
print '|a| = ',np.linalg.norm(a) #numpy way 2
print 'ScientificPython angle = ',A.angle(B) #in radians
print 'numpy angle =            ',np.arccos(np.dot(a/np.linalg.norm(a),B/np.linalg.norm(B)))
#cross products
print 'Scientific A .cross. B = ',A.cross(B)
print 'numpy A .cross. B      = ',np.cross(A,B) #you can use Vectors in numpy
Пример #40
0
def pretty_print(self):
    '''
    __str__ function to print the calculator with a nice summary, e.g. jaspsum
    '''
    # special case for neb calculations
    if self.int_params['images'] is not None:
        # we have an neb.
        s = []
        s.append(': -----------------------------')
        s.append('  VASP NEB calculation from %s' % os.getcwd())
        try:
            images, energies = self.get_neb()
            for i,e in enumerate(energies):
                s += ['image {0}: {1: 1.3f}'.format(i,e)]
        except (VaspQueued):
            s += ['Job is in queue']
        return '\n'.join(s)

    s = []
    s.append(': -----------------------------')
    s.append('  VASP calculation from %s' % os.getcwd())
    if hasattr(self,'converged'):
        s.append('  converged: %s' % self.converged)

    try:
        atoms = self.get_atoms()

        uc = atoms.get_cell()

        try:
            self.converged = self.read_convergence()
        except IOError:
            # eg no outcar
            self.converged = False

        if not self.converged:
            try:
                print self.read_relaxed()
            except IOError:
                print False
        if self.converged:
            energy = atoms.get_potential_energy()
            forces = atoms.get_forces()
        else:
            energy = np.nan
            forces = [np.array([np.nan, np.nan, np.nan]) for atom in atoms]

        if self.converged:
            if hasattr(self,'stress'):
                stress = self.stress
            else:
                stress = None
        else:
            stress = None

        # get a,b,c,alpha,beta, gamma
        from Scientific.Geometry import Vector
        A = Vector(uc[0,:])
        B = Vector(uc[1,:])
        C = Vector(uc[2,:])
        a = A.length()
        b = B.length()
        c = C.length()
        alpha = B.angle(C)*180/np.pi
        beta = A.angle(C)*180/np.pi
        gamma = B.angle(C)*180/np.pi
        volume = atoms.get_volume()

        s.append('  Energy = %f eV' % energy)
        s.append('\n  Unit cell vectors (angstroms)')
        s.append('        x       y     z      length')
        s.append('  a0 [% 3.3f % 3.3f % 3.3f] %3.3f' % (uc[0][0],
                                                     uc[0][1],
                                                     uc[0][2],
                                                     A.length()))
        s.append('  a1 [% 3.3f % 3.3f % 3.3f] %3.3f' % (uc[1][0],
                                                     uc[1][1],
                                                     uc[1][2],
                                                     B.length()))
        s.append('  a2 [% 3.3f % 3.3f % 3.3f] %3.3f' % (uc[2][0],
                                                     uc[2][1],
                                                     uc[2][2],
                                                     C.length()))
        s.append('  a,b,c,alpha,beta,gamma (deg): %1.3f %1.3f %1.3f %1.1f %1.1f %1.1f' % (a,
                                                                                  b,
                                                                                  c,
                                                                                  alpha,
                                                                                  beta,gamma))
        s.append('  Unit cell volume = {0:1.3f} Ang^3'.format(volume))

        if stress is not None:
            s.append('  Stress (GPa):xx,   yy,    zz,    yz,    xz,    xy')
            s.append('            % 1.3f % 1.3f % 1.3f % 1.3f % 1.3f % 1.3f' % tuple(stress))
        else:
            s += ['  Stress was not computed']

        constraints = None
        if hasattr(atoms, 'constraints'):
            from ase.constraints import FixAtoms, FixScaled
            constraints = [[None, None, None] for atom in atoms]
            for constraint in atoms.constraints:
                if isinstance(constraint, FixAtoms):
                    for i, constrained in  enumerate(constraint.index):
                        if constrained:
                            constraints[i] = [True, True, True]
                if isinstance(constraint, FixScaled):
                    constraints[constraint.a] = constraint.mask.tolist()

        if constraints is None:
            s.append(' Atom#  sym       position [x,y,z]         tag  rmsForce')
        else:
            s.append(' Atom#  sym       position [x,y,z]         tag  rmsForce constraints')

        for i,atom in enumerate(atoms):
            rms_f = np.sum(forces[i]**2)**0.5
            ts = '  {0:^4d} {1:^4s} [{2:<9.3f}{3:^9.3f}{4:9.3f}] {5:^6d}{6:1.2f}'.format(i,
                                                           atom.symbol,
                                                           atom.x,
                                                           atom.y,
                                                           atom.z,
                                                           atom.tag,
                                                           rms_f)
            # VASP has the opposite convention of constrained
            # Think: F = frozen
            if constraints is not None:
                ts += '      {0} {1} {2}'.format('F' if constraints[i][0] is True else 'T',
                                                 'F' if constraints[i][1] is True else 'T',
                                                 'F' if constraints[i][2] is True else 'T')

            s.append(ts)

        s.append('--------------------------------------------------')
        if self.get_spin_polarized() and self.converged:
            s.append('Spin polarized: Magnetic moment = %1.2f' % self.get_magnetic_moment(atoms))

    except AttributeError:
        # no atoms
        pass

    if os.path.exists('INCAR'):
        # print all parameters that are set
        self.read_incar()
        ppp_list = self.get_pseudopotentials()
    else:
        ppp_list=[(None, None, None)]
    s += ['\nINCAR Parameters:']
    s += ['-----------------']
    for d in [self.int_params,
              self.float_params,
              self.exp_params,
              self.bool_params,
              self.list_params,
              self.dict_params,
              self.string_params,
              self.special_params,
              self.input_params]:

        for key in d:
            if key is 'magmom':
                np.set_printoptions(precision=3)
                value = textwrap.fill(str(d[key]),
                                      width=56,
                                      subsequent_indent=' '*17)
                s.append('  %12s: %s' % (key, value))
            elif d[key] is not None:
                value = textwrap.fill(str(d[key]),
                                      width=56,
                                      subsequent_indent=' '*17)
                s.append('  %12s: %s' % (key, value))

    s += ['\nPseudopotentials used:']
    s += ['----------------------']

    for sym,ppp,hash in ppp_list:
        s += ['{0}: {1} (git-hash: {2})'.format(sym,ppp,hash)]

    #  if ibrion in [5,6,7,8] print frequencies
    if self.int_params['ibrion'] in [5,6,7,8]:
        freq,modes = self.get_vibrational_modes()
        s += ['\nVibrational frequencies']
        s += ['mode   frequency']
        s += ['------------------']
        for i,f in enumerate(freq):

            if isinstance(f, float):
                s +=  ['{0:4d}{1: 10.3f} eV'.format(i,f)]
            elif isinstance(f, complex):
                s +=  ['{0:4d}{1: 10.3f} eV'.format(i,-f.real)]
    return '\n'.join(s)
Пример #41
0
            natoms = len(atoms)
            try:
                x, V0, e0, B = analyze_eos()
            except TypeError:
                x, V0, e0, B = None, None, None, None

            magmom = atoms.get_magnetic_moment()
            # now we want to write out a row of
            data = [id1, composition, spacegroup, natoms, formation_energy, B, magmom]
            for i, d in enumerate(data):
                sh0.write(NROWS0, i, d)

            # now for sheet 1 - unit cell parameters
            uc = atoms.get_cell()
            A = Vector(uc[0, :])
            B = Vector(uc[1, :])
            C = Vector(uc[2, :])
            a = A.length()
            b = B.length()
            c = C.length()
            alpha = B.angle(C) * 180.0 / np.pi
            beta = A.angle(C) * 180.0 / np.pi
            gamma = B.angle(C) * 180.0 / np.pi
            volume = atoms.get_volume()

            stress = atoms.get_stress()
            if stress is not None:
                sxx, syy, szz, sxy, syz, sxz = stress
            else:
                sxx, syy, szz, sxy, syz, sxz = [None, None, None, None, None, None]
Пример #42
0
"""testing to see in what order the points in sketchup are given
Results: Right hand corkscrew in the direction of the normal"""

from Scientific.Geometry import Vector
import readsketchup
import geometry

txt = open('e.txt', 'r').read()
dct = readsketchup.readsketchup(txt)
for key in dct.keys():
    plane = dct[key]['points']
    normal = Vector(dct[key]['normal'])
    calcnormal = geometry.facenormal(plane)
    # print normal
    # print calcnormal
    print normal.angle(calcnormal)
    print