def testEntityDeletionCascade(self): # fold>>
graph = Graph.Graph()
coords = Infoset.Infoset(graph, InfosetType.getCoordsType())
labels = Infoset.Infoset(graph, InfosetType.getAtomLabelType())
bondtypes = Infoset.Infoset(graph, InfosetType.getBondTypeType())
angles = Infoset.Infoset(graph, InfosetType.getAngleType())
node1 = graph.createEntity()
node2 = graph.createEntity()
node3 = graph.createEntity()
link = graph.createEntity((node1, node2))
angle_entity = 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_entity, 45.0)
graph.deleteEntity(node1)
self.assertEqual(coords.size(), 2)
self.assertEqual(labels.size(), 2)
self.assertEqual(bondtypes.size(), 0)
self.assertEqual(angles.size(), 0)
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 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 __init__(self, atom_list): # fold>>
self._graph = Graph.Graph()
self._elements = Infoset.Infoset(self._graph, InfosetType.getElementType())
self._coords = Infoset.Infoset(self._graph, InfosetType.getCoordsType())
for atom in atom_list:
entity = self._graph.createEntity()
self._elements.setValue(entity, atom[0])
self._coords.setValue(entity, atom[1])
def moleculeCode(self): # fold>>
element_part = []
element_infoset = self._graph.getInfosets(infoset_type=InfosetType.getElementType())[0]
coords_infoset = self._graph.getInfosets(infoset_type=InfosetType.getCoordsType())[0]
element_part= sorted([y.atomicNumber() for x,y in element_infoset.allValues() ])
geometry_part = []
for node_id, element in element_infoset.allValues():
coordinate = coords_infoset.value(node_id).asUnit(Units.bohr).value()
geometry_part.append("%d %15.10f %15.10f %15.10f" % (element.atomicNumber(), coordinate[0], coordinate[1], coordinate[2]))
return "AA-"+_encode("\n".join([ str(x) for x in element_part]))+"-"+_encode("\n".join(geometry_part))
def fromGraph(graph):
elements = graph.getInfosets(infoset_type=InfosetType.getElementType())
coords = graph.getInfosets(infoset_type=InfosetType.getCoordsType())
if len(elements) == 0 or len(coords) == 0:
return None
atom_list = []
for id, value in elements[0].allValues():
atom_list.append( (elements[0].value(id), coords[0].value(id)))
return XYZMolecule(atom_list)
def testGetInfoset(self): # fold>>
graph = Graph.Graph()
coords = Infoset.Infoset(graph, InfosetType.getCoordsType())
coords2 = Infoset.Infoset(graph, InfosetType.getCoordsType())
labels = Infoset.Infoset(graph, InfosetType.getAtomLabelType())
bondtypes = Infoset.Infoset(graph, InfosetType.getBondTypeType())
angles = Infoset.Infoset(graph, InfosetType.getAngleType())
energy = Infoset.Infoset(graph, InfosetType.getHFEnergyType())
self.assertEqual(len(graph.getInfosets()), 6)
self.assertEqual(len(graph.getInfosets(dimensionality=0)), 1)
self.assertEqual(len(graph.getInfosets(dimensionality=1)), 3)
self.assertEqual(len(graph.getInfosets(dimensionality=2)), 1)
self.assertEqual(len(graph.getInfosets(dimensionality=3)), 1)
self.assertEqual(len(graph.getInfosets(dimensionality=4)), 0)
self.assertEqual(len(graph.getInfosets(uuid=coords.uuid())), 1)
self.assertEqual(len(graph.getInfosets(uuid=labels.uuid())), 1)
self.assertEqual(len(graph.getInfosets(uuid=uuid.uuid4())), 0)
self.assertEqual(
len(graph.getInfosets(infoset_type=InfosetType.getCoordsType())),
2)
self.assertEqual(
len(graph.getInfosets(infoset_type=InfosetType.getHFEnergyType())),
1)
self.assertEqual(len(graph.getInfosets(infoset_type=list)), 0)
self.assertEqual(
len(graph.getInfosets(uuid=labels.uuid(), dimensionality=1)), 1)
self.assertEqual(
len(graph.getInfosets(uuid=labels.uuid(), dimensionality=2)), 0)
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 _createXYZFile(mol):
cache_dir = os.path.join(os.path.dirname(__file__),"..","..","cache","jmol")
uuid = mol.uuid()
element = mol.getInfosets(infoset_type=InfosetType.getElementType())[0]
coords = mol.getInfosets(infoset_type=InfosetType.getCoordsType())[0]
f = file(os.path.join(cache_dir,str(uuid)+".xyz"), "w")
num_atoms = len(element.allValues())
f.write(str(num_atoms)+"\n\n")
for node, element in element.allValues():
coordinates = coords.value(node).asUnit(Units.angstrom).value()
f.write( "%s %16.10f %16.10f %16.10f\n" % (element.symbol(), coordinates[0], coordinates[1], coordinates[2]) )
f.close()
def search(request):
if request.POST is None or not request.POST.has_key("molecule_name"):
return render_to_response("application/search.html")
else:
molecule_name = request.POST["molecule_name"]
try:
db = DBAccess.DBAccess(os.path.join(DB_PATH, "db"))
except:
raise Http404
molecule_list = []
all = db.retrieveAll()
for graph in all:
molecule = {}
names = graph.getInfosets(
infoset_type=InfosetType.getConventionalMoleculeNameType())
if len(names) == 0:
molecule["name"] = graph.uuid()
else:
molecule["name"] = names[0].value(graph)
if molecule["name"] == molecule_name:
molecule_list.append(molecule)
return render_to_response("application/browsedb.html", {
"dbname": "db",
"molecule_list": molecule_list
})
def testInfoset(self): # fold>>
graph = Graph.Graph()
node1 = graph.createEntity()
node2 = graph.createEntity()
node3 = graph.createEntity()
coords = Infoset.Infoset(graph, InfosetType.getCoordsType())
self.assertTrue(isinstance(coords, Infoset.Infoset))
self.assertEqual(coords.graph(), graph)
self.assertNotEqual(coords.uuid(), None)
self.assertEqual(coords.typeURI(),
InfosetType.getCoordsType().typeURI())
self.assertEqual(coords.dimensionality(),
InfosetType.getCoordsType().dimensionality())
self.assertEqual(coords.size(), 3)
self.assertEqual(coords.hasNone(), True)
def browsedb(request,dbname):
try:
db = DBAccess.DBAccess(os.path.join(settings.DB_PATH, dbname))
except:
raise Http404
molecule_list = []
all = db.retrieveAll()
molecule_list = []
for graph in all:
molecule={}
code = graph.getInfosets(infoset_type=InfosetType.getMoleculeCodeType())
if len(code) == 0:
continue
else:
molecule["code"] = code[0].value(graph)
name = graph.getInfosets(infoset_type=InfosetType.getConventionalMoleculeNameType())
if len(name) == 0:
molecule["name"] = molecule["code"]
else:
molecule["name"] = name[0].value(graph)
elements = graph.getInfosets(infoset_type=InfosetType.getElementType())
if len(elements) == 0:
continue
else:
molecule["num_of_atoms"] = elements[0].size()
molecule["brute_formula"] = Utilities.hillFormula(map(lambda x: x[1], elements[0].allValues()))
hf_energy = graph.getInfosets(infoset_type=InfosetType.getHFEnergyType())
if len(hf_energy) == 0:
continue
else:
molecule["hf_energy"] = hf_energy[0].value(graph)
#molecule["uuid"] = graph.uuid()
molecule_list.append(molecule)
database = { "name": dbname }
return render_to_response("application/browsedb.html", { "database" : database, "molecule_list" : molecule_list })
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)
def testInfoset2(self): # fold>>
graph = Graph.Graph()
coords = Infoset.Infoset(graph, InfosetType.getCoordsType())
labels = Infoset.Infoset(graph, InfosetType.getAtomLabelType())
bondtypes = Infoset.Infoset(graph, InfosetType.getBondTypeType())
angles = Infoset.Infoset(graph, InfosetType.getAngleType())
node1 = graph.createEntity()
node2 = graph.createEntity()
node3 = graph.createEntity()
link = graph.createEntity((node1, node2))
angle_entity = graph.createEntity((node1, node2, node3))
coords.setValue(node1, (10.0, 0.0, 0.0))
coords.setValue(node2, (10.0, 2.0, 0.0))
self.assertEqual(coords.hasNone(), True)
coords.setValue(node3, (10.0, 2.0, 3.0))
self.assertEqual(coords.hasNone(), False)
self.assertEqual(coords.value(node1), (10.0, 0.0, 0.0))
self.assertEqual(coords.value(node2), (10.0, 2.0, 0.0))
self.assertEqual(coords.value(node3), (10.0, 2.0, 3.0))
bondtypes.setValue(link, 2)
self.assertEqual(bondtypes.value(link), 2)
self.assertEqual(bondtypes.hasNone(), False)
angles.setValue(angle_entity, Measure.Measure(45.0, Units.degrees))
self.assertEqual(angles.hasNone(), False)
self.assertEqual(
angles.value(angle_entity).value(),
Measure.Measure(45.0, Units.degrees).value())
graph.deleteEntity(node1)
self.assertEqual(coords.size(), 2)
self.assertEqual(labels.size(), 2)
self.assertEqual(bondtypes.size(), 0)
self.assertEqual(angles.size(), 0)
def satisfiedBy(self, graph):
infoset = graph.getInfosets(
infoset_type=InfosetType.getAngleType())[0]
if infoset is None:
return False
#if infoset.value(angle).value() > 45.0 and infoset.value(angle).value() < 48.0:
# return True
if infoset.value(angle).value() % 2 == 0:
return True
return False
def _getMoleculeByMoleculeCode(db, molecule_code):
molecules = [x for x in db.retrieveAll()]
for m in molecules:
molecule_code_infoset = m.getInfosets(infoset_type=InfosetType.getMoleculeCodeType())
if len(molecule_code_infoset) != 1:
continue
if molecule_code_infoset[0].value(None) == molecule_code:
return m
return None
def browsemol(request, dbname, mol_code):
try:
db = DBAccess.DBAccess(os.path.join(settings.DB_PATH, dbname))
except:
raise Http404
mol = _getMoleculeByMoleculeCode(db, mol_code)
if mol is None:
raise Http404
infosets = mol.getInfosets()
_createXYZFile(mol)
render_data = { "dbname" : dbname,
"molname" : str(mol.uuid()),
"uuid" : str(mol.uuid())
}
render_data["molecule"] = {}
render_data["grrm"] = {}
render_data["unrecognized"] = []
for i in infosets:
if i.type() == InfosetType.getMoleculeCodeType():
render_data["molecule"]["MoleculeCode"] = i.value(None)
elif i.typeURI() == InfosetTypeURI.INFOSET_TYPE_URI_BASE+"StructureType":
render_data["grrm"]["StructureType"] = i.value(None)
elif i.typeURI() == InfosetTypeURI.INFOSET_TYPE_URI_BASE+"Spin":
render_data["grrm"]["Spin"] = i.value(None)
elif i.typeURI() == InfosetTypeURI.INFOSET_TYPE_URI_BASE+"HFEnergy":
render_data["grrm"]["HFEnergy"] = i.value(None)
elif i.typeURI() == InfosetTypeURI.INFOSET_TYPE_URI_BASE+"ZeroPointVibrationalEnergy":
render_data["grrm"]["ZeroPointVibrationalEnergy"] = i.value(None)
elif i.typeURI() == InfosetTypeURI.INFOSET_TYPE_URI_BASE+"NormalModesEigenvalues":
render_data["grrm"]["NormalModesEigenvalues"] = i.value(None)
elif i.typeURI() == InfosetTypeURI.INFOSET_TYPE_URI_BASE+"ReactionConnectivityMarker":
render_data["grrm"]["ReactionConnectivityMarker"] = i.value(None)
elif i.typeURI() == InfosetTypeURI.INFOSET_TYPE_URI_BASE+"ReactionConnectivityCodes":
render_data["grrm"]["ReactionConnectivityCodes"] = i.value(None)
render_data["grrm"]["first_code"] = i.value(None)[0]
render_data["grrm"]["second_code"] = i.value(None)[1]
else:
render_data["unrecognized"].append( ( i.typeURI(), i.dimensionality()))
return render_to_response("application/browsemol.html", render_data )
def testReification(self): # fold>>
graph = Graph.Graph()
node1 = graph.createEntity()
node2 = graph.createEntity()
node3 = graph.createEntity()
coords = Infoset.Infoset(graph, InfosetType.getCoordsType())
self.assertEqual(len(coords.getReifications()), 0)
id = coords.reify(ReificationTypeURI.COMMENT_REIFICATION_TYPE_URI,
"hello")
type_uri, value = coords.getReifications(id=id)
self.assertEqual(type_uri,
ReificationTypeURI.COMMENT_REIFICATION_TYPE_URI)
self.assertEqual(value, "hello")
self.assertEqual(len(coords.getReifications()), 1)
def browsemol(request, dbname, mol_code):
try:
db = DBAccess.DBAccess(os.path.join(settings.DB_PATH, dbname))
except:
raise Http404
molecules = [x for x in db.retrieveAll()]
mol = None
for m in molecules:
molecule_code_infoset = m.getInfosets(
infoset_type=InfosetType.getMoleculeCodeType())
if len(molecule_code_infoset) != 1:
continue
if molecule_code_infoset[0].value(None) == mol_code:
mol = m
break
if mol is None:
raise Http404
infosets = mol.getInfosets()
_createXYZFile(mol)
infosets_data = []
graph_infosets_data = []
angle_data = []
for i in infosets:
if i.dimensionality() == 0:
graph_infosets_data.append((i.uuid(), i.value(None), i.typeURI()))
else:
infosets_data.append(
(i.uuid(), i.dimensionality(), i.typeURI(), i.size()))
return render_to_response(
"application/browsemol.html", {
"dbname": dbname,
"molname": str(mol.uuid()),
"uuid": str(mol.uuid()),
"graph_infosets_data": graph_infosets_data,
"infosets_data": infosets_data,
"angle_data": angle_data
})
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)
class Search:
def __init__(self, angle):
self._angle = angle
def satisfiedBy(self, graph):
infoset = graph.getInfosets(
infoset_type=InfosetType.getAngleType())[0]
if infoset is None:
return False
#if infoset.value(angle).value() > 45.0 and infoset.value(angle).value() < 48.0:
# return True
if infoset.value(angle).value() % 2 == 0:
return True
return False
results = db.search(Search(angle))
#self.assertEqual(len(results), 2)
for i in results:
print i.getInfosets(
infoset_type=InfosetType.getAngleType())[0].value(angle)
def searchdb(request):
if request.method == "POST" and request.POST:
db_name = request.POST["db_name"]
page = int(request.POST['page'])
rows_per_page = int(request.POST['rp'])
sortname = request.POST['sortname']
sortorder = request.POST['sortorder']
else:
raise Http404
try:
db = DBAccess.DBAccess(os.path.join(settings.DB_PATH, db_name))
except:
raise Http404
all = db.retrieveAll()
json_response = {"page": page, "total": len(all), "rows": []}
rows = []
for id, graph in enumerate(all):
molecule = {}
code = graph.getInfosets(
infoset_type=InfosetType.getMoleculeCodeType())
if len(code) == 0:
continue
else:
# FIXME possible danger of injection of db_name by the user
molecule["code"] = "<a href=\"/browsedb/" + db_name + "/" + code[
0].value(graph) + "\">" + code[0].value(graph) + "</a>"
name = graph.getInfosets(
infoset_type=InfosetType.getConventionalMoleculeNameType())
if len(name) == 0:
molecule["name"] = molecule["code"]
else:
molecule["name"] = name[0].value(graph)
elements = graph.getInfosets(infoset_type=InfosetType.getElementType())
if len(elements) == 0:
continue
else:
molecule["num_of_atoms"] = elements[0].size()
molecule["brute_formula"] = Utilities.hillFormula(
map(lambda x: x[1], elements[0].allValues()))
hf_energy = graph.getInfosets(
infoset_type=InfosetType.getHFEnergyType())
if len(hf_energy) == 0:
molecule["hf_energy"] = ""
else:
molecule["hf_energy"] = hf_energy[0].value(graph).value()
row = {}
row["id"] = molecule["code"]
row["cell"] = [
molecule["code"], molecule["name"], molecule["brute_formula"],
molecule["num_of_atoms"], molecule["hf_energy"], ""
]
rows.append(row)
json_response["rows"].extend(
sortAndTrim(rows, page, rows_per_page, sortname, sortorder))
json_response = {
"total":
3,
"page":
1,
"rows": [{
"cell": ["foo", "bar"]
}, {
"cell": ["foo", "bar"]
}, {
"cell": ["foo", "bar"]
}]
}
return HttpResponse(simplejson.dumps(json_response),
mimetype='application/javascript')