Exemple #1
0
def _getAlignmentOperations(molecule):  # fold>>
    xyz_mol = molecule.createXYZMolecule()
    center_of_mass = XYZMolecule.centerOfMass(xyz_mol)

    xyz_mol.translate(-center_of_mass)
    moments_of_inertia = XYZMolecule.momentsOfInertia(xyz_mol)

    # we multiply the eigenvectors by -1 if needed.
    # we want to keep the molecule oriented so that it does not change dramatically
    # (ex. we don't want it to flip just because the diagonalization returned the
    # inertial axis in the other direction)
    v0 = numpy.array(moments_of_inertia[0][1].value())
    if v0[0] < 0.0:
        v0 = -v0
    v1 = numpy.array(moments_of_inertia[1][1].value())
    if v1[1] < 0.0:
        v1 = -v1
    v2 = numpy.array(moments_of_inertia[2][1].value())
    if v2[2] < 0.0:
        v2 = -v2

    rotation = numpy.zeros((3, 3))
    rotation[0, 0] = v0[0]
    rotation[0, 1] = v0[1]
    rotation[0, 2] = v0[2]
    rotation[1, 0] = v1[0]
    rotation[1, 1] = v1[1]
    rotation[1, 2] = v1[2]
    rotation[2, 0] = v2[0]
    rotation[2, 1] = v2[1]
    rotation[2, 2] = v2[2]

    return (-center_of_mass, rotation)
    def testMoleculeCode(self):
        mol = XYZMolecule.XYZMolecule( [
                                        (PeriodicTable.H, Measure.Measure( ( 0.0000000000,0.0000000000,0.0000000000  ), Units.bohr) ),
                                        (PeriodicTable.H, Measure.Measure( ( 0.0000000000,1.7920231678,-3.1038751750 ), Units.bohr) ),
                                        (PeriodicTable.H, Measure.Measure( ( 0.0000000000,4.0095495535,2.3149145141  ), Units.bohr) ),
                                        (PeriodicTable.H, Measure.Measure( ( 0.0000000000,6.3710924130,-3.1870231249 ), Units.bohr) ),
                                        (PeriodicTable.H, Measure.Measure( ( 0.0000000000,8.5886187987,2.2317665642  ), Units.bohr) ),
                                        (PeriodicTable.H, Measure.Measure( ( 0.0000000000,10.3806419665,-0.8721086108), Units.bohr) ),
                                        (PeriodicTable.C, Measure.Measure( ( 0.0000000000,1.7920231678,-1.0346250583 ), Units.bohr) ),
                                        (PeriodicTable.C, Measure.Measure( ( 0.0000000000,4.0095495535,0.2456643974  ), Units.bohr) ),
                                        (PeriodicTable.C, Measure.Measure( ( 0.0000000000,6.3710924130,-1.1177730082 ), Units.bohr) ),
                                        (PeriodicTable.C, Measure.Measure( ( 0.0000000000,8.5886187987,0.1625164475  ), Units.bohr) ),
                                        ]
                                    )

        self.assertEqual(mol.moleculeCode(), "AA-T73FCFQ-ZCQX6AY") 

        mol2 = XYZMolecule.XYZMolecule( [
                                        (PeriodicTable.H, Measure.Measure( ( 0.0000000000,0.0000000000,1.0000000000  ), Units.bohr) ),
                                        (PeriodicTable.H, Measure.Measure( ( 0.0000000000,1.7920231678,-3.1038751750 ), Units.bohr) ),
                                        (PeriodicTable.H, Measure.Measure( ( 0.0000000000,4.0095495535,2.3149145141  ), Units.bohr) ),
                                        (PeriodicTable.H, Measure.Measure( ( 0.0000000000,6.3710924130,-3.1870231249 ), Units.bohr) ),
                                        (PeriodicTable.H, Measure.Measure( ( 0.0000000000,8.5886187987,2.2317665642  ), Units.bohr) ),
                                        (PeriodicTable.H, Measure.Measure( ( 0.0000000000,10.3806419665,-0.8721086108), Units.bohr) ),
                                        (PeriodicTable.C, Measure.Measure( ( 0.0000000000,1.7920231678,-1.0346250583 ), Units.bohr) ),
                                        (PeriodicTable.C, Measure.Measure( ( 0.0000000000,4.0095495535,0.2456643974  ), Units.bohr) ),
                                        (PeriodicTable.C, Measure.Measure( ( 0.0000000000,6.3710924130,-1.1177730082 ), Units.bohr) ),
                                        (PeriodicTable.C, Measure.Measure( ( 0.0000000000,8.5886187987,0.1625164475  ), Units.bohr) ),
                                        ]
                                    )

        self.assertNotEqual(mol.moleculeCode(), mol2.moleculeCode()) 
        self.assertEqual(mol.moleculeCode()[0:10], mol2.moleculeCode()[0:10]) 
    def testMomentsOfInertia(self): # fold>>
        mol = XYZMolecule.XYZMolecule( [
                                        (PeriodicTable.H, Measure.Measure( ( 0.0000000000,0.0000000000,0.0000000000  ), Units.bohr) ),
                                        (PeriodicTable.H, Measure.Measure( ( 0.0000000000,1.7920231678,-3.1038751750 ), Units.bohr) ),
                                        (PeriodicTable.H, Measure.Measure( ( 0.0000000000,4.0095495535,2.3149145141  ), Units.bohr) ),
                                        (PeriodicTable.H, Measure.Measure( ( 0.0000000000,6.3710924130,-3.1870231249 ), Units.bohr) ),
                                        (PeriodicTable.H, Measure.Measure( ( 0.0000000000,8.5886187987,2.2317665642  ), Units.bohr) ),
                                        (PeriodicTable.H, Measure.Measure( ( 0.0000000000,10.3806419665,-0.8721086108), Units.bohr) ),
                                        (PeriodicTable.C, Measure.Measure( ( 0.0000000000,1.7920231678,-1.0346250583 ), Units.bohr) ),
                                        (PeriodicTable.C, Measure.Measure( ( 0.0000000000,4.0095495535,0.2456643974  ), Units.bohr) ),
                                        (PeriodicTable.C, Measure.Measure( ( 0.0000000000,6.3710924130,-1.1177730082 ), Units.bohr) ),
                                        (PeriodicTable.C, Measure.Measure( ( 0.0000000000,8.5886187987,0.1625164475  ), Units.bohr) ),
                                        ]
                                    )

        inertia = XYZMolecule.momentsOfInertia(mol)
        self.assertEqual(len(inertia), 3)
        self.assertAlmostEqual(inertia[0][0].asUnit(Units.dalton * Units.angstrom * Units.angstrom).value(),  12.836878, 5)
        self.assertAlmostEqual(inertia[1][0].asUnit(Units.dalton * Units.angstrom * Units.angstrom).value(),  110.58507, 5)
        self.assertAlmostEqual(inertia[2][0].asUnit(Units.dalton * Units.angstrom * Units.angstrom).value(),  123.421950, 5)

        self.assertAlmostEqual(inertia[0][1].value()[0], 0.0) 
        self.assertAlmostEqual(inertia[0][1].value()[1], 0.994406, 5) 
        self.assertAlmostEqual(inertia[0][1].value()[2], 0.105628, 5) 

        self.assertAlmostEqual(inertia[1][1].value()[0], 0.0) 
        self.assertAlmostEqual(inertia[1][1].value()[1], -0.105628, 5) 
        self.assertAlmostEqual(inertia[1][1].value()[2], 0.994406, 5) 

        self.assertAlmostEqual(inertia[2][1].value()[0], 1.0) 
        self.assertAlmostEqual(inertia[2][1].value()[1], 0.0, 5) 
        self.assertAlmostEqual(inertia[2][1].value()[2], 0.0, 5) 
    def testTranslate(self):  # fold>>
        mol = XYZMolecule.XYZMolecule([
            (PeriodicTable.Carbon, Measure.Measure((1.0, 1.0, 0.0),
                                                   Units.bohr)),
            (PeriodicTable.Oxygen, Measure.Measure((-1.0, 1.0, 0.0),
                                                   Units.bohr)),
            (PeriodicTable.Nitrogen,
             Measure.Measure((-1.0, -1.0, 0.0), Units.bohr)),
            (PeriodicTable.Fluorine,
             Measure.Measure((1.0, -1.0, 0.0), Units.bohr)),
            (PeriodicTable.Hydrogen,
             Measure.Measure((0.0, 0.0, 1.0), Units.bohr)),
        ])

        mol.translate(Measure.Measure((2.0, 3.0, 4.0), Units.bohr))

        self.assertEqual(mol.atomPos()[0].value(), (3.0, 4.0, 4.0))
        self.assertEqual(mol.atomPos()[0].unit(), Units.bohr)
        self.assertEqual(mol.atomPos()[1].value(), (1.0, 4.0, 4.0))
        self.assertEqual(mol.atomPos()[1].unit(), Units.bohr)
        self.assertEqual(mol.atomPos()[2].value(), (1.0, 2.0, 4.0))
        self.assertEqual(mol.atomPos()[2].unit(), Units.bohr)
        self.assertEqual(mol.atomPos()[3].value(), (3.0, 2.0, 4.0))
        self.assertEqual(mol.atomPos()[3].unit(), Units.bohr)
        self.assertEqual(mol.atomPos()[4].value(), (2.0, 3.0, 5.0))
        self.assertEqual(mol.atomPos()[4].unit(), Units.bohr)

        mol = XYZMolecule.XYZMolecule([
            (PeriodicTable.Carbon, Measure.Measure((1.0, 1.0, 0.0),
                                                   Units.bohr)),
            (PeriodicTable.Oxygen, Measure.Measure((-1.0, 1.0, 0.0),
                                                   Units.bohr)),
            (PeriodicTable.Nitrogen,
             Measure.Measure((-1.0, -1.0, 0.0), Units.bohr)),
            (PeriodicTable.Fluorine,
             Measure.Measure((1.0, -1.0, 0.0), Units.bohr)),
            (PeriodicTable.Hydrogen,
             Measure.Measure((0.0, 0.0, 1.0), Units.bohr)),
        ])

        mol.translate(Measure.Measure((2.0, 3.0, 4.0), Units.angstrom))

        self.assertNotEqual(mol.atomPos()[0].value(), (3.0, 4.0, 4.0))
        self.assertEqual(mol.atomPos()[0].unit(), Units.bohr)
        self.assertNotEqual(mol.atomPos()[1].value(), (1.0, 4.0, 4.0))
        self.assertEqual(mol.atomPos()[1].unit(), Units.bohr)
        self.assertNotEqual(mol.atomPos()[2].value(), (1.0, -2.0, 4.0))
        self.assertEqual(mol.atomPos()[2].unit(), Units.bohr)
        self.assertNotEqual(mol.atomPos()[3].value(), (3.0, -2.0, 4.0))
        self.assertEqual(mol.atomPos()[3].unit(), Units.bohr)
        self.assertNotEqual(mol.atomPos()[3].value(), (2.0, 3.0, 5.0))
        self.assertEqual(mol.atomPos()[3].unit(), Units.bohr)
    def testRotate(self): # fold>>
        mol = XYZMolecule.XYZMolecule( [
                                        (PeriodicTable.Carbon, Measure.Measure( (1.0, 1.0, 0.0), Units.bohr)),
                                        (PeriodicTable.Oxygen, Measure.Measure( (-1.0, 1.0, 0.0), Units.bohr)),
                                        (PeriodicTable.Nitrogen, Measure.Measure( (-1.0, -1.0, 0.0), Units.bohr)),
                                        (PeriodicTable.Fluorine, Measure.Measure( (1.0, -1.0, 0.0), Units.bohr)),
                                        (PeriodicTable.Hydrogen, Measure.Measure( (0.0, 0.0, 1.0), Units.bohr)),
                                        ]
                                    )

        mol.rotate( Measure.Measure( (0.0,0.0,1.0) ,Units.bohr), Measure.Measure(45.0, Units.degrees) )

        self.assertAlmostEqual(mol.atomPos()[0].value()[0], 0.0)
        self.assertAlmostEqual(mol.atomPos()[0].value()[1], math.sqrt(2.0))
        self.assertAlmostEqual(mol.atomPos()[0].value()[2], 0.0)
        self.assertEqual(mol.atomPos()[0].unit(), Units.bohr  ) 

        self.assertAlmostEqual(mol.atomPos()[1].value()[0], -math.sqrt(2.0))
        self.assertAlmostEqual(mol.atomPos()[1].value()[1], 0.0)
        self.assertAlmostEqual(mol.atomPos()[1].value()[2], 0.0)
        self.assertEqual(mol.atomPos()[1].unit(), Units.bohr  ) 

        self.assertAlmostEqual(mol.atomPos()[2].value()[0], 0.0)
        self.assertAlmostEqual(mol.atomPos()[2].value()[1], -math.sqrt(2.0))
        self.assertAlmostEqual(mol.atomPos()[2].value()[2], 0.0)
        self.assertEqual(mol.atomPos()[2].unit(), Units.bohr  ) 

        self.assertAlmostEqual(mol.atomPos()[3].value()[0], math.sqrt(2.0))
        self.assertAlmostEqual(mol.atomPos()[3].value()[1], 0.0)
        self.assertAlmostEqual(mol.atomPos()[3].value()[2], 0.0)
        self.assertEqual(mol.atomPos()[3].unit(), Units.bohr  ) 
    def testXYZMolecule(self): # fold>>
        mol = XYZMolecule.XYZMolecule( [
                                        (PeriodicTable.Carbon, Measure.Measure((1.0, 1.0, 0.0), Units.bohr)),
                                        (PeriodicTable.Oxygen, Measure.Measure((-1.0, 1.0, 0.0), Units.bohr)),
                                        (PeriodicTable.Nitrogen, Measure.Measure((-1.0, -1.0, 0.0), Units.bohr)),
                                        (PeriodicTable.Fluorine, Measure.Measure((1.0, -1.0, 0.0), Units.bohr)),
                                        (PeriodicTable.Hydrogen, Measure.Measure((0.0, 0.0, 1.0), Units.bohr)),
                                        ]
                                    )

        self.assertEqual(len(mol.elements()), 5)
        self.assertEqual(mol.elements()[0], PeriodicTable.Carbon)
        self.assertEqual(mol.elements()[1], PeriodicTable.Oxygen)
        self.assertEqual(mol.elements()[2], PeriodicTable.Nitrogen)
        self.assertEqual(mol.elements()[3], PeriodicTable.Fluorine)
        self.assertEqual(mol.elements()[4], PeriodicTable.Hydrogen)

        self.assertEqual(len(mol.atomPos()), 5)
        self.assertEqual(mol.atomPos()[0].__class__, Measure.Measure) 
        self.assertEqual(mol.atomPos()[1].__class__, Measure.Measure) 
        self.assertEqual(mol.atomPos()[2].__class__, Measure.Measure) 
        self.assertEqual(mol.atomPos()[3].__class__, Measure.Measure) 
        self.assertEqual(mol.atomPos()[4].__class__, Measure.Measure) 

        self.assertEqual(mol.atomPos()[0].value(), (1.0,1.0,0.0)  ) 
        self.assertEqual(mol.atomPos()[0].unit(), Units.bohr  ) 
        self.assertEqual(mol.atomPos()[1].value(), (-1.0,1.0,0.0)  ) 
        self.assertEqual(mol.atomPos()[1].unit(), Units.bohr  ) 
        self.assertEqual(mol.atomPos()[2].value(), (-1.0,-1.0,0.0)  ) 
        self.assertEqual(mol.atomPos()[2].unit(), Units.bohr  ) 
        self.assertEqual(mol.atomPos()[3].value(), (1.0,-1.0,0.0)  ) 
        self.assertEqual(mol.atomPos()[3].unit(), Units.bohr  ) 
        self.assertEqual(mol.atomPos()[4].value(), (0.0,0.0,1.0)  ) 
        self.assertEqual(mol.atomPos()[4].unit(), Units.bohr  ) 
    def testCenterOfMass(self): # fold>>
        mol = XYZMolecule.XYZMolecule( [
                                        (PeriodicTable.H, Measure.Measure( ( 0.0000000000,0.0000000000,0.0000000000  ), Units.bohr) ),
                                        (PeriodicTable.H, Measure.Measure( ( 0.0000000000,1.7920231678,-3.1038751750 ), Units.bohr) ),
                                        (PeriodicTable.H, Measure.Measure( ( 0.0000000000,4.0095495535,2.3149145141  ), Units.bohr) ),
                                        (PeriodicTable.H, Measure.Measure( ( 0.0000000000,6.3710924130,-3.1870231249 ), Units.bohr) ),
                                        (PeriodicTable.H, Measure.Measure( ( 0.0000000000,8.5886187987,2.2317665642  ), Units.bohr) ),
                                        (PeriodicTable.H, Measure.Measure( ( 0.0000000000,10.3806419665,-0.8721086108), Units.bohr) ),
                                        (PeriodicTable.C, Measure.Measure( ( 0.0000000000,1.7920231678,-1.0346250583 ), Units.bohr) ),
                                        (PeriodicTable.C, Measure.Measure( ( 0.0000000000,4.0095495535,0.2456643974  ), Units.bohr) ),
                                        (PeriodicTable.C, Measure.Measure( ( 0.0000000000,6.3710924130,-1.1177730082 ), Units.bohr) ),
                                        (PeriodicTable.C, Measure.Measure( ( 0.0000000000,8.5886187987,0.1625164475  ), Units.bohr) ),
                                        ]
                                    )

        center_of_mass = XYZMolecule.centerOfMass(mol)
        self.assertAlmostEqual(center_of_mass.value()[0], 0.000000, 6)
        self.assertAlmostEqual(center_of_mass.value()[1], 5.190321, 6)
        self.assertAlmostEqual(center_of_mass.value()[2], -0.436054, 6)
    def testFromGraph(self):
        g = Graph.Graph()
        elements = Infoset.Infoset(g, InfosetType.getElementType())
        coords = Infoset.Infoset(g, InfosetType.getCoordsType())

        e = g.createEntity()
        elements.setValue(e, PeriodicTable.C)
        coords.setValue(e,Measure.Measure( ( 0.0000000000,8.5886187987,0.1625164475  ), Units.bohr))
        e = g.createEntity()
        elements.setValue(e, PeriodicTable.C)
        coords.setValue(e,Measure.Measure( ( 0.0000000000,8.5886187987,0.1625164475  ), Units.bohr))

        mol = XYZMolecule.fromGraph(g)

        self.assertEqual(mol.__class__, XYZMolecule.XYZMolecule)
Exemple #9
0
def main(argv): # fold>>

    options = _getOptions(argv)

    infile = XYZFile.XYZFile(options.input_filename)
    outfile = XYZFile.XYZFile()


    for mol_idx in xrange(infile.numOfMolecules()):
        atom_list = []
        for atom_idx in xrange(infile.numOfAtoms(mol_idx)):
            atom_list.append(infile.atom(mol_idx, atom_idx))
            

        molecule = XYZMolecule.XYZMolecule(atom_list)
        molecule.translate(-XYZMolecule.centerOfMass(molecule))

        new_mol_index = outfile.createMolecule()
        for atom in zip(molecule.elements(), molecule.atomPos()):
            outfile.addAtom(new_mol_index,atom)
            


    outfile.saveTo(options.output_filename)
Exemple #10
0
 def createXYZMolecule(self):  # fold>>
     atom_list = []
     for element, coords in zip(self.elements_list, self.coordinates_list):
         atom_list.append((element, coords))
     return XYZMolecule.XYZMolecule(atom_list)