class StructureSimilarityBuilderTest(unittest.TestCase):
@classmethod
def setUpClass(self):
# Set up test db, etc.
self.test_site_descriptors = MemoryStore("site_descr")
self.test_site_descriptors.connect()
site_fp_docs = loadfn(test_site_fp_stats, cls=None)
self.test_site_descriptors.update(site_fp_docs)
def test_get_items(self):
test_structure_similarity = MemoryStore("struct_sim")
test_structure_similarity.connect()
sim_builder = StructureSimilarityBuilder(self.test_site_descriptors,
test_structure_similarity,
fp_type='opsf')
items = list(sim_builder.get_items())
self.assertEqual(len(items), 3)
for i in items:
d1 = i[0]
d2 = i[1]
self.assertIn("statistics", d1)
self.assertIn("statistics", d2)
self.assertIn("task_id", d1)
self.assertIn("task_id", d2)
processed = sim_builder.process_item(i)
if processed:
pass
else:
import nose
nose.tools.set_trace()
def test_get_all_site_descriptors(self):
test_structure_similarity = MemoryStore("struct_sim")
test_structure_similarity.connect()
sim_builder = StructureSimilarityBuilder(self.test_site_descriptors,
test_structure_similarity,
fp_type='opsf')
for d in self.test_site_descriptors.query():
dsim = sim_builder.get_similarities(d, d)
self.assertAlmostEqual(dsim['cos'], 1)
self.assertAlmostEqual(dsim['dist'], 0)
C = self.test_site_descriptors.query_one(criteria={"task_id": "mp-66"})
NaCl = self.test_site_descriptors.query_one(criteria={"task_id": "mp-22862"})
Fe = self.test_site_descriptors.query_one(criteria={"task_id": "mp-13"})
d = sim_builder.get_similarities(C, NaCl)
self.assertAlmostEqual(d['cos'], 0.0013649)
self.assertAlmostEqual(d['dist'], 2.6866749)
d = sim_builder.get_similarities(C, Fe)
self.assertAlmostEqual(d['cos'], 0.0013069)
self.assertAlmostEqual(d['dist'], 2.6293889)
d = sim_builder.get_similarities(NaCl, Fe)
self.assertAlmostEqual(d['cos'], 0.0012729)
self.assertAlmostEqual(d['dist'], 2.7235044)
class TaskTaggerTest(unittest.TestCase):
def setUp(self):
coords = list()
coords.append([0, 0, 0])
coords.append([0.75, 0.5, 0.75])
lattice = [
[3.8401979337, 0.00, 0.00],
[1.9200989668, 3.3257101909, 0.00],
[0.00, -2.2171384943, 3.1355090603],
]
structure = Structure(lattice, ["Si", "Si"], coords)
input_sets = {
"GGA Structure Optimization": MPRelaxSet(structure),
"GGA Static": MPStaticSet(structure),
"GGA NSCF Line": MPNonSCFSet(structure, mode="line"),
"GGA NSCF Uniform": MPNonSCFSet(structure, mode="uniform"),
}
tasks = []
t_id = 1
for task_type, input_set in input_sets.items():
doc = {
"true_task_type": task_type,
"last_updated": datetime.now(),
"task_id": t_id,
"state": "successful",
"orig_inputs": {
"incar": input_set.incar.as_dict(),
"kpoints": input_set.kpoints.as_dict(),
},
"output": {
"structure": structure.as_dict()
},
}
t_id += 1
tasks.append(doc)
self.test_tasks = MemoryStore("tasks")
self.task_types = MemoryStore("task_types")
self.test_tasks.connect()
self.task_types.connect()
self.test_tasks.update(tasks)
def test_mp_defs(self):
task_tagger = TaskTagger(tasks=self.test_tasks,
task_types=self.task_types)
for t in task_tagger.get_items():
processed = task_tagger.calc(t)
true_type = self.test_tasks.query_one(
criteria={"task_id": t["task_id"]},
properties=["true_task_type"])["true_task_type"]
self.assertEqual(processed["task_type"], true_type)
class BuilderTest(unittest.TestCase):
def setUp(self):
self.materials = MemoryStore()
self.materials.connect()
materials = loadfn(os.path.join(TEST_DIR, "test_materials.json"))
materials = jsanitize(materials, strict=True, allow_bson=True)
self.materials.update(materials)
self.propstore = MemoryStore()
self.propstore.connect()
def test_serial_runner(self):
builder = PropnetBuilder(self.materials, self.propstore)
runner = Runner([builder])
runner.run()
def test_multiproc_runner(self):
builder = PropnetBuilder(self.materials, self.propstore)
runner = Runner([builder])
runner.run()
def test_process_item(self):
item = self.materials.query_one(criteria={"pretty_formula": "Cs"})
builder = PropnetBuilder(self.materials, self.propstore)
processed = builder.process_item(item)
self.assertIsNotNone(processed)
# Ensure vickers hardness gets populated
self.assertIn("vickers_hardness", processed)
# @unittest.skipIf(not os.path.isfile("runner.json"), "No runner file")
# def test_runner_pipeline(self):
# from monty.serialization import loadfn
# runner = loadfn("runner.json")
# runner.builders[0].connect()
# items = list(runner.builders[0].get_items())
# processed = runner.builders[0].process_item(items[0])
# runner.run()
# Just here for reference, in case anyone wants to create a new set
# of test materials -jhm
@unittest.skipIf(True, "Skipping test materials creation")
def create_test_docs(self):
formulas = ["BaNiO3", "Si", "Fe2O3", "Cs"]
from maggma.advanced_stores import MongograntStore
from monty.serialization import dumpfn
mgstore = MongograntStore("ro:matgen2.lbl.gov/mp_prod", "materials")
builder = PropnetBuilder(mgstore,
self.propstore,
criteria={
"pretty_formula": {
"$in": formulas
},
"e_above_hull": 0
})
builder.connect()
dumpfn(list(builder.get_items()), "test_materials.json")
class TestBondBuilder(unittest.TestCase):
def setUp(self):
self.materials = JSONStore(test_mats)
self.bonding = MemoryStore("bonding")
def test_build(self):
builder = BondBuilder(self.materials, self.bonding)
runner = Runner([builder])
runner.run()
doc = self.bonding.query_one(
criteria={'task_id': 'mp-779001'})["bonding"]["CrystalNN"]
sg = StructureGraph.from_dict(doc['graph'])
self.assertIsInstance(sg, StructureGraph)
self.assertIn('Hf-O(6)', doc['summary']['coordination_envs'])
class SiteDescriptorsBuilderTest(unittest.TestCase):
@classmethod
def setUpClass(self):
# Set up test db, etc.
self.test_materials = MemoryStore("mat_site_fingerprint")
self.test_materials.connect()
struct_docs = loadfn(test_structs, cls=None)
self.test_materials.update(struct_docs)
def test_builder(self):
test_site_descriptors = MemoryStore("test_site_descriptors")
sd_builder = SiteDescriptorsBuilder(self.test_materials,
test_site_descriptors)
sd_builder.connect()
for t in sd_builder.get_items():
processed = sd_builder.process_item(t)
if processed:
sd_builder.update_targets([processed])
else:
import nose
nose.tools.set_trace()
self.assertEqual(len([t for t in sd_builder.get_items()]), 0)
# Remove one data piece in diamond entry and test partial update.
test_site_descriptors.collection.find_one_and_update(
{'task_id': 'mp-66'}, {'$unset': {
'site_descriptors': 1
}})
items = [e for e in list(sd_builder.get_items())]
self.assertEqual(len(items), 1)
def test_get_all_site_descriptors(self):
test_site_descriptors = MemoryStore("test_site_descriptors")
sd_builder = SiteDescriptorsBuilder(self.test_materials,
test_site_descriptors)
C = self.test_materials.query_one(criteria={"task_id": "mp-66"})
NaCl = self.test_materials.query_one(criteria={"task_id": "mp-22862"})
Fe = self.test_materials.query_one(criteria={"task_id": "mp-13"})
# Diamond.
d = sd_builder.get_site_descriptors_from_struct(
Structure.from_dict(C["structure"]))
for di in d.values():
self.assertEqual(len(di), 2)
self.assertEqual(d['cn_VoronoiNN'][0]['CN_VoronoiNN'], 20)
self.assertAlmostEqual(d['cn_wt_VoronoiNN'][0]['CN_VoronoiNN'],
4.5381162)
self.assertEqual(d['cn_JMolNN'][0]['CN_JMolNN'], 4)
self.assertAlmostEqual(d['cn_wt_JMolNN'][0]['CN_JMolNN'], 4.9617398)
self.assertEqual(d['cn_MinimumDistanceNN'][0]['CN_MinimumDistanceNN'],
4)
self.assertAlmostEqual(
d['cn_wt_MinimumDistanceNN'][0]['CN_MinimumDistanceNN'], 4)
self.assertEqual(d['cn_MinimumOKeeffeNN'][0]['CN_MinimumOKeeffeNN'], 4)
self.assertAlmostEqual(
d['cn_wt_MinimumOKeeffeNN'][0]['CN_MinimumOKeeffeNN'], 4)
self.assertEqual(d['cn_MinimumVIRENN'][0]['CN_MinimumVIRENN'], 4)
self.assertAlmostEqual(d['cn_wt_MinimumVIRENN'][0]['CN_MinimumVIRENN'],
4)
self.assertEqual(
d['cn_BrunnerNN_reciprocal'][0]['CN_BrunnerNN_reciprocal'], 4)
self.assertAlmostEqual(
d['cn_wt_BrunnerNN_reciprocal'][0]['CN_BrunnerNN_reciprocal'], 4)
self.assertAlmostEqual(d['opsf'][0]['tetrahedral CN_4'], 0.9995)
#self.assertAlmostEqual(d['csf'][0]['tetrahedral CN_4'], 0.9886777)
ds = sd_builder.get_statistics(d)
self.assertTrue('opsf' in list(ds.keys()))
self.assertTrue('csf' in list(ds.keys()))
for k, dsk in ds.items():
for di in dsk:
self.assertEqual(len(list(di.keys())), 5)
def get_index(li, optype):
for i, di in enumerate(li):
if di['name'] == optype:
return i
raise RuntimeError('did not find optype {}'.format(optype))
self.assertAlmostEqual(
ds['opsf'][get_index(ds['opsf'], 'tetrahedral CN_4')]['max'],
0.9995)
self.assertAlmostEqual(
ds['opsf'][get_index(ds['opsf'], 'tetrahedral CN_4')]['min'],
0.9995)
self.assertAlmostEqual(
ds['opsf'][get_index(ds['opsf'], 'tetrahedral CN_4')]['mean'],
0.9995)
self.assertAlmostEqual(
ds['opsf'][get_index(ds['opsf'], 'tetrahedral CN_4')]['std'], 0)
self.assertAlmostEqual(
ds['opsf'][get_index(ds['opsf'], 'octahedral CN_6')]['mean'],
0.0005)
# NaCl.
d = sd_builder.get_site_descriptors_from_struct(
Structure.from_dict(NaCl["structure"]))
self.assertAlmostEqual(d['opsf'][0]['octahedral CN_6'], 0.9995)
#self.assertAlmostEqual(d['csf'][0]['octahedral CN_6'], 1)
ds = sd_builder.get_statistics(d)
self.assertAlmostEqual(
ds['opsf'][get_index(ds['opsf'], 'octahedral CN_6')]['max'],
0.9995)
self.assertAlmostEqual(
ds['opsf'][get_index(ds['opsf'], 'octahedral CN_6')]['min'],
0.9995)
self.assertAlmostEqual(
ds['opsf'][get_index(ds['opsf'], 'octahedral CN_6')]['mean'],
0.9995)
self.assertAlmostEqual(
ds['opsf'][get_index(ds['opsf'], 'octahedral CN_6')]['std'], 0)
# Iron.
d = sd_builder.get_site_descriptors_from_struct(
Structure.from_dict(Fe["structure"]))
self.assertAlmostEqual(d['opsf'][0]['body-centered cubic CN_8'],
0.9995)
#self.assertAlmostEqual(d['csf'][0]['body-centered cubic CN_8'], 0.755096)
ds = sd_builder.get_statistics(d)
self.assertAlmostEqual(
ds['opsf'][get_index(ds['opsf'],
'body-centered cubic CN_8')]['max'], 0.9995)
self.assertAlmostEqual(
ds['opsf'][get_index(ds['opsf'],
'body-centered cubic CN_8')]['min'], 0.9995)
self.assertAlmostEqual(
ds['opsf'][get_index(ds['opsf'],
'body-centered cubic CN_8')]['mean'], 0.9995)
self.assertAlmostEqual(
ds['opsf'][get_index(ds['opsf'],
'body-centered cubic CN_8')]['std'], 0)
class BuilderTest(unittest.TestCase):
def setUp(self):
self.materials = MemoryStore()
self.materials.connect()
materials = loadfn(os.path.join(TEST_DIR, "test_materials.json"))
materials = jsanitize(materials, strict=True, allow_bson=True)
self.materials.update(materials)
self.propstore = MemoryStore()
self.propstore.connect()
def test_serial_runner(self):
builder = PropnetBuilder(self.materials, self.propstore)
runner = Runner([builder])
runner.run()
def test_multiproc_runner(self):
builder = PropnetBuilder(self.materials, self.propstore)
runner = Runner([builder])
runner.run()
def test_process_item(self):
item = self.materials.query_one(criteria={"pretty_formula": "Cs"})
builder = PropnetBuilder(self.materials, self.propstore)
processed = builder.process_item(item)
self.assertIsNotNone(processed)
# Ensure vickers hardness gets populated
self.assertIn("vickers_hardness", processed)
if 'created_at' in item.keys():
date_value = item['created_at']
else:
date_value = ""
# Check that provenance values propagate correctly
current_quantity = processed['vickers_hardness']['quantities'][0]
at_deepest_level = False
while not at_deepest_level:
current_provenance = current_quantity['provenance']
if current_provenance['inputs'] is not None:
self.assertEqual(current_provenance['source']['source'],
"propnet")
self.assertEqual(current_provenance['source']['source_key'],
current_quantity['internal_id'])
self.assertNotIn(current_provenance['source']['date_created'],
("", None))
current_quantity = current_provenance['inputs'][0]
else:
self.assertEqual(current_provenance['source']['source'],
"Materials Project")
self.assertEqual(current_provenance['source']['source_key'],
item['task_id'])
self.assertEqual(current_provenance['source']['date_created'],
date_value)
at_deepest_level = True
# @unittest.skipIf(not os.path.isfile("runner.json"), "No runner file")
# def test_runner_pipeline(self):
# from monty.serialization import loadfn
# runner = loadfn("runner.json")
# runner.builders[0].connect()
# items = list(runner.builders[0].get_items())
# processed = runner.builders[0].process_item(items[0])
# runner.run()
# Just here for reference, in case anyone wants to create a new set
# of test materials -jhm
@unittest.skipIf(True, "Skipping test materials creation")
def create_test_docs(self):
formulas = ["BaNiO3", "Si", "Fe2O3", "Cs"]
from maggma.advanced_stores import MongograntStore
from monty.serialization import dumpfn
mgstore = MongograntStore("ro:matgen2.lbl.gov/mp_prod", "materials")
builder = PropnetBuilder(
mgstore, self.propstore, criteria={"pretty_formula": {"$in": formulas},
"e_above_hull": 0})
builder.connect()
dumpfn(list(builder.get_items()), "test_materials.json")