def setUpClass(cls):
add_builtin_models_to_registry()
cls.materials = MemoryStore()
cls.materials.connect()
materials = loadfn(os.path.join(TEST_DATA_DIR, "test_materials.json"))
materials = jsanitize(materials, strict=True, allow_bson=True)
cls.materials.update(materials)
cls.propstore = None
def test_models_have_unique_names(self):
add_builtin_models_to_registry()
from propnet.models.serialized import _EQUATION_MODEL_NAMES_LIST
serialized_model_names_set = set(_EQUATION_MODEL_NAMES_LIST)
serialized_model_names_list = _EQUATION_MODEL_NAMES_LIST.copy()
for name in serialized_model_names_set:
serialized_model_names_list.remove(name)
self.assertTrue(len(serialized_model_names_list) == 0,
msg="Two or more equation models have the "
"same name(s): {}".format(serialized_model_names_list))
from propnet.models.python import _PYTHON_MODEL_NAMES_LIST
python_model_names_set = set(_PYTHON_MODEL_NAMES_LIST)
python_model_names_list = _PYTHON_MODEL_NAMES_LIST.copy()
for name in python_model_names_set:
python_model_names_list.remove(name)
self.assertTrue(len(python_model_names_list) == 0,
msg="Two or more python models have the "
"same name(s): {}".format(python_model_names_list))
from propnet.models.composite import _COMPOSITE_MODEL_NAMES_LIST
composite_model_names_set = set(_COMPOSITE_MODEL_NAMES_LIST)
composite_model_names_list = _COMPOSITE_MODEL_NAMES_LIST.copy()
for name in composite_model_names_set:
composite_model_names_list.remove(name)
self.assertTrue(len(composite_model_names_list) == 0,
msg="Two or more composite models have the "
"same name(s): {}".format(composite_model_names_list))
all_models_set = set.union(serialized_model_names_set,
python_model_names_set,
composite_model_names_set)
all_models_list = \
_EQUATION_MODEL_NAMES_LIST + \
_PYTHON_MODEL_NAMES_LIST + \
_COMPOSITE_MODEL_NAMES_LIST
for name in all_models_set:
all_models_list.remove(name)
sources = defaultdict(list)
for name in all_models_list:
for model_type, name_list in zip(('serialized', 'python', 'composite'),
(_EQUATION_MODEL_NAMES_LIST,
_PYTHON_MODEL_NAMES_LIST,
_COMPOSITE_MODEL_NAMES_LIST)):
if name in name_list:
sources[name].append(model_type)
self.assertTrue(len(all_models_list) == 0,
msg="Two or more models of different types"
" have the same name {{name: [model types]}}:\n{}".format(dict(sources)))
def setUpClass(cls):
add_builtin_models_to_registry()
# This is the visible light dataset used in the propnet paper
path = os.path.join(TEST_DATA_DIR, "vis_bg_ri_data.csv")
test_data = pd.read_csv(path)
graph = Graph()
materials = [
Material([QuantityFactory.create_quantity("band_gap", bg)])
for bg in test_data['Band Gap']
]
cls.evaluated = [graph.evaluate(mat) for mat in materials]
cls.benchmarks = [{
"refractive_index": n
} for n in test_data['Refractive Index']]
def setUpClass(cls):
add_builtin_models_to_registry()
cls.propnet_props = PROPNET_PROPS
cls.propstore = MemoryStore()
cls.propstore.connect()
materials_file = os.path.join(TEST_DATA_DIR,
"correlation_propnet_data.json")
if os.path.exists(materials_file):
with open(materials_file, 'r') as f:
materials = json.load(f)
materials = jsanitize(materials, strict=True, allow_bson=True)
cls.propstore.update(materials)
cls.quantity_store = MemoryStore()
cls.quantity_store.connect()
quantities_file = os.path.join(
TEST_DATA_DIR, "correlation_propnet_quantity_data.json")
if os.path.exists(quantities_file):
with open(quantities_file, 'r') as f:
quantities = json.load(f)
quantities = jsanitize(quantities, strict=True, allow_bson=True)
cls.quantity_store.update(quantities, key='internal_id')
cls.correlation = None
# vickers hardness (x-axis) vs. bulk modulus (y-axis)
cls.correlation_values_vickers_bulk = {
'linlsq': 0.49302857395714916,
'pearson': 0.7021599347421844,
'spearman': 0.7658801470036752,
'mic': 0.7069707677575771,
'theilsen': 0.4498696692135892,
'ransac': 0.412850153689996
}
cls.correlation_values_bulk_vickers = {
'linlsq': 0.49302857395714916,
'pearson': 0.7021599347421844,
'spearman': 0.7658801470036752,
'mic': 0.7069707677575771,
'theilsen': 0.46461142885951223,
'ransac': 0.3699261228882036
}
def setUpClass(cls):
Registry.clear_all_registries()
add_builtin_models_to_registry()
def tearDownClass(cls) -> None:
Registry.clear_all_registries()
add_builtin_models_to_registry()
def tearDownClass(cls) -> None:
Registry.clear_all_registries()
from propnet.models import add_builtin_models_to_registry
add_builtin_models_to_registry()
def setUpClass(cls):
add_builtin_models_to_registry()
cls.mpr = mpr
mpid = 'mp-1153'
cls.mat = cls.mpr.get_material_for_mpid(mpid)
def setUpClass(cls):
add_builtin_models_to_registry()
# Inspiration was taken from the GraphTest class
# I tried to construct the dictionaries for comparison
# without writing out every one explicitly by reusing
# information where it was applicable.
# If this is too unreadable, can change to writing it
# out explicitly in a JSON file and importing it. Would
# still need to replace some fields dynamically.
symbols = StorageTest.generate_symbols()
cls.custom_syms_as_dicts = {
k: {'@module': 'propnet.core.symbols',
'@class': 'Symbol',
'name': k,
'display_names': [k],
'display_symbols': [k],
'units': (1, ()),
'shape': 1,
'object_type': None,
'comment': None,
'category': 'property',
'constraint': None,
'default_value': None,
'is_builtin': False} for k in ['A', 'B', 'C']
}
cls.custom_syms_as_dicts['C'].update(
{"units": None,
"shape": None,
"object_type": "str",
"category": "object"})
cls.custom_symbols_json = copy.deepcopy(cls.custom_syms_as_dicts)
for k in ['A', 'B']:
cls.custom_symbols_json[k]['units'] = [1, []]
a = [QuantityFactory.create_quantity(symbols['A'], 19),
QuantityFactory.create_quantity(symbols['A'], 23)]
b = [QuantityFactory.create_quantity(symbols['B'], 38,
provenance=ProvenanceElement(model='model1',
inputs=[a[0]])),
QuantityFactory.create_quantity(symbols['B'], 46,
provenance=ProvenanceElement(model='model1',
inputs=[a[1]]))]
cls.quantities_custom_symbol = {"A": a,
"B": b}
cls.sq_custom_sym_as_dicts = {
k: [{'@module': 'propnet.dbtools.storage',
'@class': 'StorageQuantity',
'internal_id': vv._internal_id,
'data_type': 'NumQuantity',
'symbol_type': symbols[k],
'value': vv.magnitude,
'units': 'dimensionless',
'provenance': ProvenanceStore.from_provenance_element(vv.provenance),
'tags': [],
'uncertainty': None} for vv in v] for k, v in cls.quantities_custom_symbol.items()
}
provenances_json = {
"A": [{'@module': 'propnet.dbtools.storage',
'@class': 'ProvenanceStore',
'model': None,
'inputs': None,
'source': aa.provenance.source} for aa in a]}
provenances_json['B'] = [
{'@module': 'propnet.dbtools.storage',
'@class': 'ProvenanceStore',
'model': 'model1',
'inputs': [{'@module': 'propnet.dbtools.storage',
'@class': 'ProvenanceStoreQuantity',
'data_type': 'NumQuantity',
'symbol_type': cls.custom_symbols_json['A'],
'internal_id': q.provenance.inputs[0]._internal_id,
'tags': [],
'provenance': p}],
'source': q.provenance.source} for q, p in zip(b, provenances_json['A'])]
cls.sq_custom_sym_json = copy.deepcopy(cls.sq_custom_sym_as_dicts)
for sym in ['A', 'B']:
for q, p in zip(cls.sq_custom_sym_json[sym], provenances_json[sym]):
q['symbol_type'] = cls.custom_symbols_json[sym]
q['provenance'] = p
band_gaps = [QuantityFactory.create_quantity('band_gap', 3.3, 'eV'),
QuantityFactory.create_quantity('band_gap', 2.1, 'eV')]
bg_ri_model = Registry("models")['band_gap_refractive_index_moss']
refractive_indices = [bg_ri_model.evaluate({"Eg": bg}).pop('refractive_index') for bg in band_gaps]
cls.quantities_canonical_symbol = {"band_gaps": band_gaps,
"refractive_indices": refractive_indices}
cls.sq_canonical_sym_as_dicts_no_value = copy.deepcopy(cls.sq_custom_sym_as_dicts)
cls.sq_canonical_sym_as_dicts_no_value['band_gaps'] = cls.sq_canonical_sym_as_dicts_no_value.pop('A')
cls.sq_canonical_sym_as_dicts_no_value['refractive_indices'] = cls.sq_canonical_sym_as_dicts_no_value.pop('B')
for d, sq in zip(cls.sq_canonical_sym_as_dicts_no_value['band_gaps'], band_gaps):
d.update({
"internal_id": sq._internal_id,
"symbol_type": "band_gap",
"units": "electron_volt",
"provenance": ProvenanceStore.from_provenance_element(sq.provenance)
})
d.pop('value')
for d, sq in zip(cls.sq_canonical_sym_as_dicts_no_value['refractive_indices'], refractive_indices):
d.update({
"internal_id": sq._internal_id,
"symbol_type": "refractive_index",
"units": "dimensionless",
"provenance": ProvenanceStore.from_provenance_element(sq.provenance)
})
d.pop('value')
cls.sq_canonical_sym_values = {"band_gaps": [3.3, 2.1],
"refractive_indices": [2.316340583741216, 2.593439239956374]}
provenances_json['band_gaps'] = [
{'@module': 'propnet.dbtools.storage',
'@class': 'ProvenanceStore',
'model': None,
'inputs': None,
'source': bg.provenance.source}
for bg in band_gaps
]
provenances_json['refractive_indices'] = [{
'@module': 'propnet.dbtools.storage',
'@class': 'ProvenanceStore',
'model': 'band_gap_refractive_index_moss',
'inputs': [{'@module': 'propnet.dbtools.storage',
'@class': 'ProvenanceStoreQuantity',
'data_type': 'NumQuantity',
'symbol_type': 'band_gap',
'internal_id': bg._internal_id,
'tags': [],
'provenance': pj}],
'source': ri.provenance.source}
for bg, pj, ri in zip(band_gaps,
provenances_json['band_gaps'],
refractive_indices)
]
cls.sq_canonical_sym_json_no_value = copy.deepcopy(cls.sq_canonical_sym_as_dicts_no_value)
for sym in ["band_gaps", "refractive_indices"]:
for q, p in zip(cls.sq_canonical_sym_json_no_value[sym], provenances_json[sym]):
q['provenance'] = p
cls.quantity_with_uncertainty = NumQuantity.from_weighted_mean(b)
cls.sq_with_uncertainty_as_dict_no_numbers = {
'@module': 'propnet.dbtools.storage',
'@class': 'StorageQuantity',
'internal_id': cls.quantity_with_uncertainty._internal_id,
'data_type': 'NumQuantity',
'symbol_type': symbols['B'],
'units': 'dimensionless',
'provenance': ProvenanceStore.from_provenance_element(
cls.quantity_with_uncertainty.provenance),
'tags': []}
provenances_json = {
'@module': 'propnet.dbtools.storage',
'@class': 'ProvenanceStore',
'model': 'aggregation',
'inputs': [
{'@module': 'propnet.dbtools.storage',
'@class': 'ProvenanceStoreQuantity',
'data_type': 'NumQuantity',
'symbol_type': cls.custom_symbols_json['B'],
'internal_id': b['internal_id'],
'tags': [],
'provenance': b['provenance']}
for b in cls.sq_custom_sym_json['B']],
'source': cls.quantity_with_uncertainty.provenance.source
}
cls.sq_with_uncertainty_json_no_numbers = copy.deepcopy(cls.sq_with_uncertainty_as_dict_no_numbers)
cls.sq_with_uncertainty_json_no_numbers.update({"symbol_type": cls.custom_symbols_json['B'],
"provenance": provenances_json})
cls.sq_with_uncertainty_numbers = {"value": 42.0,
"uncertainty": 4.0}
obj_symbol = symbols['C']
cls.object_quantity = QuantityFactory.create_quantity(obj_symbol, "Test string")
cls.sq_object_as_dict = copy.deepcopy(cls.sq_custom_sym_as_dicts['A'][0])
cls.sq_object_as_dict.update({
"data_type": "ObjQuantity",
"symbol_type": symbols['C'],
"internal_id": cls.object_quantity._internal_id,
"value": "Test string",
"units": None,
"provenance": ProvenanceStore.from_provenance_element(cls.object_quantity.provenance)
})
cls.sq_object_json = copy.deepcopy(cls.sq_object_as_dict)
cls.sq_object_json.update(
{"symbol_type": cls.custom_syms_as_dicts['C'],
"provenance": {'@module': 'propnet.dbtools.storage',
'@class': 'ProvenanceStore',
'model': None,
'inputs': None,
'source': cls.object_quantity.provenance.source}}
)
# This setting allows dict differences to be shown in full
cls.maxDiff = None