def test_measurement_reassignment():
"""Check that a measurement run can be re-assigned to a new material run."""
sample1 = MaterialRun("Sample 1")
sample2 = MaterialRun("Sample 2")
mass = MeasurementRun("Mass of sample", material=sample1)
volume = MeasurementRun("Volume of sample", material=sample1)
assert mass.material == sample1
assert set(sample1.measurements) == {mass, volume}
assert sample2.measurements == []
mass.material = sample2
assert mass.material == sample2
assert sample1.measurements == [volume]
assert sample2.measurements == [mass]
mass.material = None
assert mass.material is None
assert sample2.measurements == []
def ingest_table(material_run, table):
"""Ingest a material run into an existing table."""
for _, row in table.iterrows():
exp = MeasurementRun()
for prop_name in known_properties:
if prop_name in row:
exp.properties.append(Property(name=prop_name,
value=NominalReal(row[prop_name], '')))
for cond_name in known_conditions:
if cond_name in row:
exp.conditions.append(Condition(name=cond_name,
value=NominalReal(row[cond_name], '')))
exp.material = material_run
return material_run
def test_material_soft_link():
"""Test that a measurement run can link to a material run, and that it survives serde."""
dye = MaterialRun("rhodamine",
file_links=FileLink(filename='a.csv', url='/a/path'))
assert dye.measurements == [], "default value of .measurements should be an empty list"
# The .measurements member should not be settable
with pytest.raises(AttributeError):
dye.measurements = [MeasurementRun("Dummy")]
absorbance = MeasurementRun(name="Absorbance",
uids={'id': str(uuid4())},
properties=[
Property(name='Abs at 500 nm',
value=NominalReal(0.1, ''))
])
assert absorbance.material is None, "Measurements should have None as the material by default"
absorbance.material = dye
assert absorbance.material == dye, "Material not set correctly for measurement"
assert dye.measurements == [
absorbance
], "Soft-link from material to measurement not created"
fluorescence = MeasurementRun(name="Fluorescence",
uids={'id': str(uuid4())},
properties=[
Property(name='PL counts at 550 nm',
value=NominalReal(30000, ''))
],
material=dye)
assert fluorescence.material == dye, "Material not set correctly for measurement"
assert dye.measurements == [absorbance, fluorescence], \
"Soft-link from material to measurements not created"
assert loads(dumps(absorbance)) == absorbance, \
"Measurement should remain unchanged when serialized"
assert loads(dumps(fluorescence)) == fluorescence, \
"Measurement should remain unchanged when serialized"
assert 'measurements' in repr(dye)
assert 'material' in repr(fluorescence)
assert 'material' in repr(absorbance)
subbed = substitute_links(dye)
assert 'measurements' in repr(subbed)
def make_data_island(density,
bulk_modulus,
firing_temperature,
binders,
powders,
tag=None):
"""Helper function to create a relatively involved data island."""
binder_specs = keymap(lambda x: MaterialSpec(name=x), binders)
powder_specs = keymap(lambda x: MaterialSpec(name=x), powders)
binder_runs = keymap(lambda x: MaterialRun(name=x.name, spec=x),
binder_specs)
powder_runs = keymap(lambda x: MaterialRun(name=x.name, spec=x),
powder_specs)
all_input_materials = keymap(lambda x: x.spec.name,
merge(binder_runs, powder_runs))
mixing_composition = Condition(
name="composition", value=NominalComposition(all_input_materials))
mixing_process = ProcessRun(name="Mixing",
tags=["mixing"],
conditions=[mixing_composition])
binder_ingredients = []
for run in binder_runs:
binder_ingredients.append(
IngredientRun(
material=run,
process=mixing_process,
mass_fraction=NominalReal(binders[run.spec.name], ''),
))
powder_ingredients = []
for run in powder_runs:
powder_ingredients.append(
IngredientRun(
material=run,
process=mixing_process,
mass_fraction=NominalReal(powders[run.spec.name], ''),
))
green_sample = MaterialRun("Green", process=mixing_process)
measured_firing_temperature = Condition(
name="Firing Temperature",
value=UniformReal(firing_temperature - 0.5, firing_temperature + 0.5,
'degC'),
template=firing_temperature_template)
specified_firing_setting = Parameter(name="Firing setting",
value=DiscreteCategorical("hot"))
firing_spec = ProcessSpec("Firing", template=firing_template)
firing_process = ProcessRun(name=firing_spec.name,
conditions=[measured_firing_temperature],
parameters=[specified_firing_setting],
spec=firing_spec)
IngredientRun(material=green_sample,
process=firing_process,
mass_fraction=NormalReal(1.0, 0.0, ''),
volume_fraction=NormalReal(1.0, 0.0, ''),
number_fraction=NormalReal(1.0, 0.0, ''))
measured_density = Property(name="Density",
value=NominalReal(density, ''),
template=density_template)
measured_modulus = Property(name="Bulk modulus",
value=NormalReal(bulk_modulus,
bulk_modulus / 100.0, ''))
measurement_spec = MeasurementSpec("Mechanical Properties",
template=measurement_template)
measurement = MeasurementRun(
measurement_spec.name,
properties=[measured_density, measured_modulus],
spec=measurement_spec)
tags = [tag] if tag else []
material_spec = MaterialSpec("Coupon", template=material_template)
material_run = MaterialRun(material_spec.name,
process=firing_process,
tags=tags,
spec=material_spec)
measurement.material = material_run
return material_run
def ingest_material_run(data, material_spec=None, process_run=None):
"""Ingest material run with data, a material spec, and an originating process run."""
if isinstance(data, list):
return [ingest_material_run(x, material_spec) for x in data]
if not isinstance(data, dict):
raise ValueError("This ingester operates on dict, but got {}".format(type(data)))
material = MaterialRun()
sample_id = data.get("sample_id")
if sample_id:
material.add_uid("given_sample_id", sample_id)
tags = data.get("tags")
if tags:
material.tags = tags
for experiment in data.get("experiments", []):
measurement = MeasurementRun()
for name in set(known_properties.keys()).intersection(experiment.keys()):
prop = Property(
name=name,
template=known_properties[name],
value=_parse_value(experiment[name])
)
measurement.properties.append(prop)
for name in set(known_conditions.keys()).intersection(experiment.keys()):
cond = Condition(
name=name,
template=known_conditions[name],
value=_parse_value(experiment[name])
)
measurement.conditions.append(cond)
for name in set(known_parameters.keys()).intersection(experiment.keys()):
param = Parameter(
name=name,
template=known_parameters[name],
value=_parse_value(experiment[name])
)
measurement.parameters.append(param)
scan_id = experiment.get("scan_id")
if scan_id:
measurement.add_uid("given_scan_id", scan_id)
tags = experiment.get("tags")
if tags:
measurement.tags = tags
measurement.material = material
if material_spec:
material.material_spec = material_spec
if process_run:
material.process = process_run
return material