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 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 testToRotationMatrix(self): # fold>>
q = Quaternion(Measure.Measure([1.0, 0.0, 0.0], Units.angstrom),
Measure.Measure(0.0615, Units.radians))
m = q.toRotationMatrix()
self.assertAlmostEqual(m[0][0], 1.0)
self.assertAlmostEqual(m[0][1], 0.0)
self.assertAlmostEqual(m[0][2], 0.0)
self.assertAlmostEqual(m[1][0], 0.0)
self.assertAlmostEqual(m[1][1], math.cos(0.0615))
self.assertAlmostEqual(m[1][2], -math.sin(0.0615))
self.assertAlmostEqual(m[2][0], 0.0)
self.assertAlmostEqual(m[2][1], math.sin(0.0615))
self.assertAlmostEqual(m[2][2], math.cos(0.0615))
q = Quaternion(Measure.Measure([1.0, 0.0, 0.0], Units.angstrom),
Measure.Measure(-0.0615, Units.radians))
m = q.toRotationMatrix()
self.assertAlmostEqual(m[0][0], 1.0)
self.assertAlmostEqual(m[0][1], 0.0)
self.assertAlmostEqual(m[0][2], 0.0)
self.assertAlmostEqual(m[1][0], 0.0)
self.assertAlmostEqual(m[1][1], math.cos(-0.0615))
self.assertAlmostEqual(m[1][2], -math.sin(-0.0615))
self.assertAlmostEqual(m[2][0], 0.0)
self.assertAlmostEqual(m[2][1], math.sin(-0.0615))
self.assertAlmostEqual(m[2][2], math.cos(-0.0615))
def momentsOfInertia(molecule, origin_to_center_of_mass=True): # fold>>
tensor = numpy.zeros((3,3))
center_of_mass = centerOfMass(molecule)
for element, coordinate in zip(molecule.elements(), molecule.atomPos()):
mass_dalton = element.mass().asUnit(Units.dalton).value()
coordinate_bohr = coordinate.asUnit(Units.bohr).value()
x = coordinate_bohr[0] - center_of_mass.asUnit(Units.bohr).value()[0]
y = coordinate_bohr[1] - center_of_mass.asUnit(Units.bohr).value()[1]
z = coordinate_bohr[2] - center_of_mass.asUnit(Units.bohr).value()[2]
tensor[0,0] += mass_dalton * (y**2 + z**2)
tensor[0,1] -= mass_dalton * x * y
tensor[0,2] -= mass_dalton * x * z
tensor[1,1] += mass_dalton * (x**2 + z**2)
tensor[1,2] -= mass_dalton * y * z
tensor[2,2] += mass_dalton * (x**2 + y**2)
# symmetrize
tensor[1,0] = tensor[0,1]
tensor[2,0] = tensor[0,2]
tensor[2,1] = tensor[1,2]
val,vec = numpy.linalg.eig(tensor)
inertia = []
for i in xrange(0,3):
axis = Measure.Measure( (vec[0][i], vec[1][i], vec[2][i]), Units.bohr)
moment = Measure.Measure(val[i], Units.dalton * Units.bohr * Units.bohr)
inertia.append( (moment, axis) )
return sorted(inertia, key=lambda x: x[0].value())
def match(cls, reader): # fold>>
start_pos = reader.currentPos()
line = reader.readline()
m1 = re.search("E\(LUMO\)\s:\s+(-?\d+\.\d+)\s+au\s+\(symmetry (\d+)\)", line)
if m1 is None:
reader.toPos(start_pos)
return None
line = reader.readline()
m2 = re.search("-\s+E\(H**O\)\s:\s+(-?\d+\.\d+)\s+au\s+\(symmetry (\d+)\)", line)
if m2 is None:
reader.toPos(start_pos)
return None
line = reader.readline()
line = reader.readline()
m3 = re.search("gap\s+:\s+(-?\d+\.\d+)\s+au\s+", line)
if m3 is None:
reader.toPos(start_pos)
return None
try:
lumo_energy = Measure.Measure(float(m1.group(1)), Units.hartree)
lumo_symmetry = int(m1.group(2))
homo_energy = Measure.Measure(float(m2.group(1)), Units.hartree)
homo_symmetry = int(m2.group(2))
gap = Measure.Measure(float(m3.group(1)), Units.hartree)
except ValueError:
reader.toPos(start_pos)
return None
return cls(homo_energy, homo_symmetry, lumo_energy, lumo_symmetry, gap)
def testDiff(self):
m1 = Measure.Measure(10, Units.hartree)
m2 = Measure.Measure(5, Units.eV)
m_diff = m1 - m2
self.assertEqual(m_diff.unit(), Units.hartree)
self.assertAlmostEqual(m_diff.value(), 10.0 - 5.0 / 27.21138386, 5)
m3 = Measure.Measure((10, 11), Units.eV)
m_diff = m1 - m3
self.assertEqual(m_diff.unit(), Units.hartree)
self.assertEqual(len(m_diff.value()), 2)
self.assertAlmostEqual(m_diff.value()[0], 10.0 - 10.0 / 27.21138386, 5)
self.assertAlmostEqual(m_diff.value()[1], 10.0 - 11.0 / 27.21138386, 5)
m_diff = m3 - m1
self.assertEqual(m_diff.unit(), Units.eV)
self.assertEqual(len(m_diff.value()), 2)
self.assertAlmostEqual(
m_diff.value()[0], 10.0 - 10.0 * 27.21138386,
2) # FIXME this value is too wrong. The tolerance is on the second
# digit. Something serious must be done to the units
self.assertAlmostEqual(m_diff.value()[1], 11 - 10.0 * 27.21138386, 2)
m4 = Measure.Measure((12, 15), Units.hartree)
m_diff = m4 - m3
self.assertEqual(m_diff.unit(), Units.hartree)
self.assertEqual(len(m_diff.value()), 2)
self.assertAlmostEqual(m_diff.value()[0], 12.0 - 10.0 / 27.21138386, 5)
self.assertAlmostEqual(m_diff.value()[1], 15.0 - 11.0 / 27.21138386, 5)
m_wrong = Measure.Measure(10, Units.bohr)
self.assertRaises(Exception, m1.__sub__, m_wrong)
self.assertRaises(Exception, m_wrong.__sub__, m1)
def testSaveTo(self):
xyz = XYZFile.XYZFile()
xyz.createMolecule()
xyz.setComment("hello 1")
xyz.addAtom((PeriodicTable.Hydrogen,
Measure.Measure((1.0, 2.0, 3.0), Units.angstrom)))
xyz.addAtom((PeriodicTable.Carbon,
Measure.Measure((1.0, 2.0, 3.0), Units.angstrom)))
xyz.createMolecule()
xyz.setComment("hello 2")
xyz.addAtom((PeriodicTable.Oxygen,
Measure.Measure((4.0, 6.0, 8.0), Units.angstrom)))
xyz.addAtom((PeriodicTable.Fluorine,
Measure.Measure((5.0, 7.0, 9.0), Units.angstrom)))
xyz.saveTo(os.path.join(moduleDir(), "testfile_saveTo.xyz"))
f1 = file(os.path.join(moduleDir(), "testfile_saveTo.xyz")).read()
f2 = file(os.path.join(moduleDir(), "saveTo.expected")).read()
md1 = hashlib.md5(f1)
md2 = hashlib.md5(f2)
self.assertEqual(md1.hexdigest(), md2.hexdigest())
os.unlink(os.path.join(moduleDir(), "testfile_saveTo.xyz"))
def testMolFile_MixedUnits(self): # fold>>
d = Dalton20.MolFile()
d.addComment("hello","ciao")
d.addAtom("H1",PeriodicTable.H, Measure.Measure((1.0,0.0,0.0), Units.angstrom), "cc-pVDZ")
d.addAtom("C1",PeriodicTable.C, Measure.Measure((0.0,1.0,0.0), Units.bohr), "cc-pVDZ")
self.assertRaises(Exception, d.generateOutput)
def match(cls, reader): # fold>>
start_pos = reader.currentPos()
regexp1 = re.compile("@\s+B-freq\s+=\s+(\d+\.\d+)\s+C-freq\s+=\s+(\d+\.\d+)\s+beta\(([XYZ]);([XYZ]),([XYZ])\)\s+=\s*(-?\d+\.\d+)")
regexp2 = re.compile("@\s+B-freq\s+=\s+(\d+\.\d+)\s+C-freq\s+=\s+(\d+\.\d+)\s+beta\(([XYZ]);([XYZ]),([XYZ])\)\s+=\s+beta\(([XYZ]),([XYZ]),([XYZ])\)")
line = reader.readline()
m1 = regexp1.search(line)
m2 = regexp2.search(line)
if m1 is not None:
b_freq = Measure.Measure(float(m1.group(1)), Units.frequency_au)
c_freq = Measure.Measure(float(m1.group(2)), Units.frequency_au)
components = (m1.group(3), m1.group(4), m1.group(5))
beta = Measure.Measure(float(m1.group(6)), Units.beta_au)
refers_to = None
elif m2 is not None:
b_freq = Measure.Measure(float(m2.group(1)), Units.frequency_au)
c_freq = Measure.Measure(float(m2.group(2)), Units.frequency_au)
components = (m2.group(3), m2.group(4), m2.group(5))
beta = None
refers_to = (m2.group(6), m2.group(7), m2.group(8))
else:
reader.toPos(start_pos)
return None
return cls(b_freq, c_freq, components, beta, refers_to)
def match(cls, reader): # fold>>
start_pos = reader.currentPos()
atom_list = []
line = reader.readline()
m = re.search("Next geometry", line)
if m is None:
reader.toPos(start_pos)
return None
line = reader.readline()
m = re.search("-*", line)
if m is None:
reader.toPos(start_pos)
return None
reader.readline()
valid_data = False
for line in reader:
m1 = re.search("\s+(\w+)\s+(\w+)\s+(-?\d+\.\d+)\s+(-?\d+\.\d+)\s+(-?\d+\.\d+)", line)
if m1 is not None:
atom_label = m1.group(1)
sym_label = m1.group(2)
position = Measure.Measure( (float(m1.group(3)),
float(m1.group(4)),
float(m1.group(5))
), Units.bohr
)
atom_list.append( (atom_label, sym_label, position) )
valid_data = True
continue
m2 = re.search("\s+(\w+)\s+(-?\d+\.\d+)\s+(-?\d+\.\d+)\s+(-?\d+\.\d+)", line)
if m2 is not None:
atom_label = m2.group(1)
sym_label = ""
position = Measure.Measure ( (float(m2.group(2)),
float(m2.group(3)),
float(m2.group(4))
) , Units.bohr
)
atom_list.append( (atom_label, sym_label, position))
valid_data = True
continue
break
if len(atom_list) == 0:
valid_data = False
if valid_data == False:
reader.toPos(start_pos)
return None
return cls(atom_list)
def testMeasure(self): # fold>>
m = Measure.Measure(10, Units.degrees)
self.assertEqual(m.value(), 10)
self.assertEqual(m.unit(), Units.degrees)
m = Measure.Measure((10, 11), Units.degrees)
self.assertEqual(m.value(), (10, 11))
self.assertEqual(m.unit(), Units.degrees)
def match(cls, reader): # fold>>
start_pos = reader.currentPos()
line = reader.readline()
m1 = re.search("@ Singlet linear response function in a.u.", line)
if m1 is None:
reader.toPos(start_pos)
return None
# read empty line
line = reader.readline()
line = reader.readline()
m3 = re.search("@ A operator, symmetry, frequency:\s+(\w+)\s+(\d)\s+(-?\d+\.\d+)", line)
if m3 is None:
reader.toPos(start_pos)
return None
a_freq = Measure.Measure(float(m3.group(3)), Units.frequency_au)
if m3.group(1) == "XDIPLEN":
a_component = "X"
elif m3.group(1) == "YDIPLEN":
a_component = "Y"
elif m3.group(1) == "ZDIPLEN":
a_component = "Z"
else:
a_component = None
line = reader.readline()
m4 = re.search("@ B operator, symmetry, frequency:\s+(\w+)\s+(\d)\s+(-?\d+\.\d+)", line)
if m4 is None:
reader.toPos(start_pos)
return None
b_freq = Measure.Measure(float(m4.group(3)), Units.frequency_au)
if m4.group(1) == "XDIPLEN":
b_component = "X"
elif m4.group(1) == "YDIPLEN":
b_component = "Y"
elif m4.group(1) == "ZDIPLEN":
b_component = "Z"
else:
b_component = None
# read empty line
line = reader.readline()
line = reader.readline()
m5 = re.search("@ Value of linear response -<<A;B>\(omega\):\s+(-?\d+\.\d+)", line)
if m5 is None:
reader.toPos(start_pos)
return None
alpha = Measure.Measure(float(m5.group(1)), Units.alpha_au)
return cls(a_freq, b_freq, [a_component, b_component], alpha)
def testMolFile_3(self): # fold>>
d = Dalton20.MolFile()
d.addComment("hello","ciao")
d.addAtom("H1",PeriodicTable.H, Measure.Measure((1.0,0.0,0.0), Units.bohr), "cc-pVDZ")
d.addAtom("C1",PeriodicTable.C, Measure.Measure((0.0,1.0,0.0), Units.bohr), "cc-pVDZ")
d.addAtom("C2",PeriodicTable.C, Measure.Measure((0.0,2.0,0.0), Units.bohr), "cc-pVDZ")
out = d.generateOutput()
self.assertEqual(out, expectedMolFileResult_3())
def testAddAtom(self):
xyz = XYZFile.XYZFile()
xyz.createMolecule()
xyz.setComment("hello")
xyz.addAtom((PeriodicTable.Hydrogen, Measure.Measure( (1.0, 2.0, 3.0), Units.angstrom)))
xyz.addAtom((PeriodicTable.Carbon, Measure.Measure( (1.0, 2.0, 3.0), Units.angstrom)))
self.assertEqual(xyz.atom(0)[0], PeriodicTable.Hydrogen)
self.assertEqual(xyz.atom(1)[0], PeriodicTable.Carbon)
def translate(self, vector): # fold>>
for entity, pos in self._coords.allValues():
if pos.unit() == vector.unit():
newpos = Measure.Measure( (pos.value()[0]+vector.value()[0], pos.value()[1]+vector.value()[1], pos.value()[2]+vector.value()[2]), pos.unit())
else:
x_conv = vector.value()[0]*vector.unit().as(pos.unit())
y_conv = vector.value()[1]*vector.unit().as(pos.unit())
z_conv = vector.value()[2]*vector.unit().as(pos.unit())
newpos = Measure.Measure( (pos.value()[0]+x_conv.asNumber(), pos.value()[1]+y_conv.asNumber(), pos.value()[2]+z_conv.asNumber()), pos.unit())
self._coords.setValue(entity, newpos)
def testNegative(self):
m = -Measure.Measure(10, Units.degrees)
self.assertEqual(m.value(), -10)
self.assertEqual(m.unit(), Units.degrees)
m = -Measure.Measure((10, 11), Units.degrees)
in_rad = m.asUnit(Units.radians)
self.assertEqual(in_rad.value()[0], -math.pi * 10.0 / 180.0)
self.assertEqual(in_rad.value()[1], -math.pi * 11.0 / 180.0)
self.assertEqual(in_rad.unit(), Units.radians)
def testMolFile_checkOrderOfGroups(self): # fold>>
"""check if the increasing order is respected"""
d = Dalton20.MolFile()
d.addComment("hello","ciao")
d.addAtom("O1",PeriodicTable.O, Measure.Measure((0.0,3.0,0.0), Units.angstrom), "cc-pVDZ")
d.addAtom("H1",PeriodicTable.H, Measure.Measure((1.0,0.0,0.0), Units.angstrom), "cc-pVDZ")
d.addAtom("C1",PeriodicTable.C, Measure.Measure((0.0,1.0,0.0), Units.angstrom), "cc-pVDZ")
d.addAtom("C2",PeriodicTable.C, Measure.Measure((0.0,2.0,0.0), Units.angstrom), "cc-pVDZ")
d.forceAtomBasis(True)
out = d.generateOutput()
self.assertEqual(out, expectedMolFileResult_orderOfGroups())
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)
def testSearch(self):
reinitdb()
db = DBAccess.DBAccess(os.path.join(moduleDir(), "testdb"))
for i in xrange(1, 90):
graph = Graph.Graph()
coords = Infoset.Infoset(graph, InfosetType.getCoordsType())
labels = Infoset.Infoset(graph, InfosetType.getAtomLabelType())
bondtypes = Infoset.Infoset(graph, InfosetType.getBondTypeType())
energy = Infoset.Infoset(graph, InfosetType.getHFEnergyType())
angles = Infoset.Infoset(graph, InfosetType.getAngleType())
node1 = graph.createEntity()
node2 = graph.createEntity()
node3 = graph.createEntity()
link = graph.createEntity((node1, node2))
angle = graph.createEntity((node1, node2, node3))
coords.setValue(node1, (10.0, 0.0, 0.0))
coords.setValue(node2, (10.0, 2.0, 0.0))
coords.setValue(node3, (10.0, 2.0, 3.0))
bondtypes.setValue(link, 2)
angles.setValue(angle, Measure.Measure(float(i), Units.degrees))
db.store(graph)
def match(cls, reader): # fold>>
start_pos = reader.currentPos()
line = reader.readline()
m = re.search("Dipole moment", line)
if m is None:
reader.toPos(start_pos)
return None
line = reader.readline()
m = re.search("-*", line)
if m is None:
reader.toPos(start_pos)
return None
reader.readline()
valid_data = False
line = reader.readline()
m1 = re.search("\s+(-?\d+\.\d+)\s+au\s+(-?\d+\.\d+)\s+Debye", line)
if m1 is None:
reader.toPos(start_pos)
return None
try:
dipole = Measure.Measure(float(m1.group(2)), Units.debye)
except ValueError:
reader.toPos(start_pos)
return None
return cls(dipole)
def testStoreAndRetrieve(self):
reinitdb()
graph = Graph.Graph()
coords = Infoset.Infoset(graph, InfosetType.getCoordsType())
labels = Infoset.Infoset(graph, InfosetType.getAtomLabelType())
bondtypes = Infoset.Infoset(graph, InfosetType.getBondTypeType())
energy = Infoset.Infoset(graph, InfosetType.getHFEnergyType())
angles = Infoset.Infoset(graph, InfosetType.getAngleType())
node1 = graph.createEntity()
node2 = graph.createEntity()
node3 = graph.createEntity()
link = graph.createEntity((node1, node2))
angle = graph.createEntity((node1, node2, node3))
coords.setValue(node1, (10.0, 0.0, 0.0))
coords.setValue(node2, (10.0, 2.0, 0.0))
coords.setValue(node3, (10.0, 2.0, 3.0))
bondtypes.setValue(link, 2)
angles.setValue(angle, Measure.Measure(45, Units.degrees))
db = DBAccess.DBAccess(os.path.join(moduleDir(), "testdb"))
db.store(graph)
molecule_list = db.retrieveAll()
self.assertEqual(len(molecule_list), 1)
def _getOptions(argv): # fold>>
options = Options()
opts, args = getopt.getopt(argv[1:], "t:h", ["translate=", "help"])
for opt in opts:
if opt[0] == "-t" or opt[0] == "--translate":
try:
print opt[1]
t = tuple(map(float, opt[1].split(",")))
except:
_usage("unable to convert translation vector")
sys.exit(1)
if len(t) != 3:
_usage("translation vector length is not equal to 3")
sys.exit(1)
options.translate = Measure.Measure(t, Units.angstrom)
if opt[0] == "-h" or opt[0] == "--help":
_usage()
sys.exit(1)
if len(args) < 2:
_usage("Too few arguments")
sys.exit(1)
options.input_filename = args[0]
options.output_filename = args[1]
return options
def match(cls, reader): # fold>>
start_pos = reader.currentPos()
atom_list = []
valid_data = False
for line in reader:
m1 = re.search(
"(\w+)\s+(-?\d+\.\d+)\s+(-?\d+\.\d+)\s+(-?\d+\.\d+)", line)
if m1 is not None:
atom_label = m1.group(1)
position = Measure.Measure((float(
m1.group(2)), float(m1.group(3)), float(m1.group(4))),
Units.angstrom)
atom_list.append((atom_label, position))
valid_data = True
continue
break
reader.readbackline()
if len(atom_list) == 0:
valid_data = False
if valid_data == False:
reader.toPos(start_pos)
return None
return cls(atom_list)
def testInit(self): # fold>>
q = Quaternion(Measure.Measure([1.0, 2.0, 3.0], Units.angstrom),
Measure.Measure(45.0, Units.degrees))
self.assertAlmostEqual(q._w(), math.cos(math.pi / 8.0))
self.assertAlmostEqual(q._x(), 1.0 * math.sin(math.pi / 8.0))
self.assertAlmostEqual(q._y(), 2.0 * math.sin(math.pi / 8.0))
self.assertAlmostEqual(q._z(), 3.0 * math.sin(math.pi / 8.0))
q = Quaternion(Measure.Measure([1.0, 2.0, 3.0], Units.angstrom),
Measure.Measure(math.pi / 4.0, Units.radians))
self.assertAlmostEqual(q._w(), math.cos(math.pi / 8.0))
self.assertAlmostEqual(q._x(), 1.0 * math.sin(math.pi / 8.0))
self.assertAlmostEqual(q._y(), 2.0 * math.sin(math.pi / 8.0))
self.assertAlmostEqual(q._z(), 3.0 * math.sin(math.pi / 8.0))
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 match(cls, reader): # fold>>
start_pos = reader.currentPos()
line = reader.readline()
m = re.search("Energy at final geometry is\s+:\s+(-?\d*\.\d*)", line)
if m is not None:
return cls( Measure.Measure(float(m.group(1)), Units.hartree))
reader.toPos(start_pos)
return None
def match(cls, reader): # fold>>
start_pos = reader.currentPos()
line = reader.readline()
m = re.search("ZPVE\s+=\s+(-?\d*\.\d*)", line)
if m is not None:
return cls(Measure.Measure(float(m.group(1)), Units.unknown))
reader.toPos(start_pos)
return None
def rotate(self, axis, angle): # fold>>
atom_list = []
q = Quaternion(axis, angle)
m = q.toRotationMatrix()
for entity, pos in self._coords.allValues():
arr = numpy.array([ pos.value()[0], pos.value()[1], pos.value()[2], 1.0 ])
rotated = numpy.dot(m, arr)
newpos = Measure.Measure( (rotated[0], rotated[1], rotated[2]), pos.unit())
self._coords.setValue(entity, newpos)
def match(cls, reader): # fold>>
start_pos = reader.currentPos()
line = reader.readline()
m = re.search("Total mass:\s+(\d*\.\d*)", line)
if m is not None:
return cls( Measure.Measure(float(m.group(1)), Units.dalton))
reader.toPos(start_pos)
return None
def testGraphInfoset(self): # fold>>
graph = Graph.Graph()
energy = Infoset.Infoset(graph, InfosetType.getHFEnergyType())
energy.setValue(None, Measure.Measure(10.4, Units.hartree))
self.assertEqual(energy.dimensionality(), 0)
self.assertEqual(energy.size(), 1)
self.assertEqual(energy.value(None).value(), 10.4)
self.assertEqual(energy.value(None).unit(), Units.hartree)
